GZFLS Computer Science

CS188 Chapter 14 Probabilistic Reasoning

Sun, 13 Jun 2021 00:00:00 +0000

14.1 Representing Knowledge in an Uncertain Domain

This section will introduce a data structure called Bayesian network to represent the dependencies between variables. Bayesian network can represent any full-joint probability distribution and in many cases can do so very concisely.

A Bayesian network is a directed acyclic graph (DAC) where each node is annotated with quantitative probability information.

Each node corresponds to a random variable, which may be discrete or continuous.
A set of directed links or arrows connects pairs of nodes. If there is an arrow from node $X$ to $Y$, $X$ is said to be a parent of $Y$.
Each node $X_i$ has a conditional probability distribution $\mathbf{P}(X_i\mid Parents(X_i))$ that quantifies the effect of the parents on the node.

In each node of the Bayesian network, a conditional probability table (CPT) is stored. For instance, the node “$Toothache$” stores $\mathbf{P}(Toothache \mid Cavity)$.

In general, a table for a Boolean variable with $k$ Boolean parents contains $2^k$ independently specifiable probabilities.

14.2 The Semantics of Bayesian Networks

14.2.1 Representing the full joint distribution

The full joint distribution of variables $X_1$ to $X_n$ can be represented in this way:

\[P(x_1, \cdots, x_n) = \prod_{i=1}^{n}{P(x_i \mid parents(X_i))}\]

Where $parents(X_i)$ is the parent nodes of variable $X_i$.This equation defines what a given Bayesian network means.

How to construct Bayesian Networks

Except the equation above, there is another way to calculate $P(x_1, \cdots, x_n)$. Using product rule, we can also represent it in this way:

\[P(x_1, \cdots, x_n) = P(x_n \mid x_{n-1}, x_{n-2}, \cdots, x_1)P(x_{n-1}, x_{n-2}, \cdots, x_1)\]

Applying product rule recursively on the equation above, we can represent $P(x_1, \cdots, x_n)$ in a long product:

\[P(x_1, \cdots, x_n) = P(x_n \mid x_{n-1}, x_{n-2}, \cdots, x_1)P(x_{n-1} \mid x_{n-2}, \cdots, x_1)\cdots P(x_2 \mid x_1)P(x_1) \\= \prod_{i=1}^{n}{P(x_i \mid x_{i-1} \cdots x_1)}\]

Therefore, we can learn that[图片]

\[P(X_i\mid X_{i-1}. \cdots. X_i) = P(X_i \mid parents(X_i))\]

This equation indicates that … $P(X\mid Parents(X))\;\bot\; P(Ancestor(X) \mid Parents(X))$

Nodes: First find a set of variables $X_1, \cdots, X_n$ that will be included into the Bayes Network. The network will be more compact if the variables are ordered such that cause precede effect
Links For $i = 1$ to $n$, do
- Choose from $X_1, \cdots, X_{i-1}$ a minimal set of parents for $X_i$, such that Equation $P(X_i\mid X_{i-1}. \cdots. X_i) = P(X_i \mid parents(X_i))$ is satisfied.
- For each parent insert a link from parent to $X_{i}$
- Write down the conditional probability table, $\mathbf{P}(X_i \mid Parents(X_i))$

The Bayesian network is a correct representation of the domain only if each node is conditionally independent of its other predecessors in the node ordering, given its parents.

Some information is omitted here as they requires sophisticated knowledge in 2D Gaussian distribution, topology, etc. You can find them in Chapter 14.2 - 14.3

14.4 Exact Inference in Bayesian Networks

The basic task for probabilistic inference system is to compute the posterior probability distribution for a set of query variables, given some observed event (the assignment of values to a set of evidence variables).

\[\text{All Variables} = \text{Query Variables }\cup\text{ Evidence Variables }\cup\text{ Hidden Variables}\]

A typical query asks for the posterior probability distribution $\mathbf{P}(X\mid \mathbf{e})$

14.4.1 Inference by Enumeration

A query $\mathbf{P}(X \mid \mathbf{e})$ can be answered using the equation below:

\[\mathbf{P}(X \mid \mathbf{e}) = \alpha \mathbf{P}(X, \mathbf{e}) = \alpha \sum_y{\mathbf{P}(X,\mathbf{e}, \mathbf{y})}\]

a query can be answered using a Bayesian Network by computing sums of products of conditional probablities from the network.

Example

Suppose we have such a Bayesian Network

We use $B$ to represent the variable $Burglary$, $m$ and $j$ represent the known value of $JohnCalls$ and $MaryCalls$ (True or False). Now we want to calculate $\mathbf{P}(B\mid m, j)$
\[\begin{aligned} \mathbf{P}(B\mid m, j) &= \left\langle \frac{P(b, j, m)}{P(j, m)}, \frac{P(\neg b, j, m)}{P(j, m)} \right\rangle\\ &= \alpha \left\langle \underbrace{P(b, j, m)}_{\text{Expand}}, P(\neg b, j, m)\right\rangle \end{aligned}\]
Using Chain Rule, we can expand $P(b, j, m, E, A)$
\[\begin{aligned} P(b, j, m) &= \sum_E{\sum_A{P(b, j, m, E, A)}}\\ &= \sum_E{\sum_A{P(m \mid j, A, E, b)P(j \mid A, E, b)P(A \mid E, b)P(E\mid b)P(b)}} \end{aligned}\]

Note: For simplicity

$x\bot y$ is the shorten for $P(x)\bot P(y)$

$x\bot y \mid a$ is the shorten for $P(x\mid a) \bot P(y\mid a)$

$x\bot y, z \mid a$ is the shorten for $P(x\mid a)\bot P(y\mid a)$ and $P(x\mid a)\bot P(z\mid a)$

According to the structure of Bayesian Network, we can know that $m \bot j$, $m \bot b, E \mid A$, $j \bot b, E \mid A$ and $b\mid E$. Therefore, we can simplify the formula above
\[\begin{aligned} P(b, j, m) &= \sum_E{\sum_A{P(m \mid j, A, E, b)P(j \mid A, E, b)P(A \mid E, b)P(E\mid b)P(b)}}\\ &= \sum_E{\sum_A{P(m\mid A)P(j \mid A)P(A\mid E, b)P(E)P(b)}} \end{aligned}\]
To simplify this formula, we can “extract the common factor” out from nested sum$\sum$.
\[\begin{aligned} &P(b, j, m)\\ = &P(b)\sum_E\left({P(E)\sum_A\left({P(m \mid A)P(j\mid A)P(A\mid E, b)}\right)}\right)\\ = &P(b)\sum_E\left({P(E)\sum_A\left({\underbrace{P(m\mid Parents(m))P(j\mid Parents(j))P(A\mid Parents(A))}_{\text{Find these value in Bayesian Network}}}\right)}\right) \end{aligned}\]

The worst time complexity of query with enumeration is $O(n2^n)$

To formally describe the process of Inference by Enumeration, we can use two functions - $\text{ENUMERATION-ASK}$ and $\text{ENUMERATE-ALL}$.

The $\times$ here represents the pointwise product between vectors instead of scalar product.

Here’s how to use $\text{ENUMERATION-ASK}$ and $\text{ENUMERATE-ALL}$ to evaluate $\text{ENUMERATION-ASK}(B, \lbrace j,m\rbrace, bn)$.

Some information is omitted here. You can find them in Chapter 14.4.2 - 14.4.4

14.5 Approximate Inference in Bayesian Networks

This section describes randomized sampling algorithms, also called Monte Carlo algorithms, that provide approximate answers whose accuracy depends on the number of samples generated.

14.5.1 Direct Sampling Methods

Prior Sample

Step 1. Use topological sort to sort all variables in the Bayesian Network.

Step 2. Assign a value to the first variable (the node with no Parents) randomly with probability distribution $\mathbf{P}(X_1)$.

Step 3. Assign a value to next variable with probability distribution $\mathbf{P}(X_2 \mid Parents(X_2))$

Step 4. Repeat Step 3 until all variables in Bayesian Network has an assignment

After step 4, we successfully construct a sample from Bayesian network. By repeating the sampling for many times, we can approximate the Probability distribution $\mathbf{P}(X\mid e)$.

Suppose $S_{PS}(x_1, \cdots, x_n)$ represents the probability of getting sample where $X_1 = x_1, \cdots, X_n=x_n$.

\[S_{PS}(x_1\cdots x_n) = \prod_{i=1}^n{P(x_i\mid Parents(X_i))}\]

Suppose we have take $N$ direct samples and among them, there are $N_{PS}(x_1\cdots x_n)$ sample where $X_1=x_1\cdots X_n=x_n$. The ration between $N$ and $N_{SP}$ will converge as $N$ approach $\infty$.

\[\lim_{N\rightarrow\infty}{\frac{N_{PS}(x_1\cdots x_n)}{N}} = S_{PS}(x_1, \cdots, x_n)=P(x_1, \cdots, x_n)\]

The estimated probability becomes exact in the large-sample limit. Such an estimate is called consistent.

\[P(x_1, \cdots, x_m)\approx N_{PS}(x_1, \cdots, x_m)/N\]

Rejection Sampling

Rejection sampling is a general method for producing samples from a hard-to-sample distribution given an easy-to-sample distribution. It can produce a consistent estimation of the true probability.

The biggest problem of rejection sampling is that it rejects too much samples! The number of samples being rejected increases exponentially as the number of evidence variable increases.

CS188 Ch13. Case Study - Recognize MNIST base on Naive Bayes

Fri, 04 Jun 2021 00:00:00 +0000

开始之前……

先下载 Case Study Package，其中包括了 Jupyter Notebook 文件，MNIST 数据集，和 Python 文件

提取码：gwcs

Using Naive Bayes’ Network to Recognize MNIST Handwriting Figures

This dataset contains two files - mnist_test.csv and mnist_train.csv. They are in the data directory. You can also download them from this link

What is MNIST?

MNIST is a set of hand-writing images collected by NIST. Each image is cropped to $28px \times 28px$. There exist a single digit in each image.

The image is gray-scaled. Each pixel has a value in range $[0, 255]$. Where $0$ represents “white” and $255$ represents “black”.

Now, let’s take a look at MNIST first.

def load_csv(pathToCSV: str) -> list:
    """
    加载 csv 数据
    """
    data = []
    lines = open(pathToCSV, "r").read().strip().split("\n")
    data = [list(map(int, line.split(","))) for line in lines]
    return data

train_set = load_csv("./data/mnist_train.csv")      # 训练集，共 60,000 张（行）
test_set = load_csv("./data/mnist_test.csv")        # 测试集，共 10,000 张（行）

def display_image(pixels: list) -> None:
    """
    Display the image using ASCII char, also show the label on image
    """
    assert len(pixels) == 1 + 28 * 28, "Unable to display image other than size 28 * 28 and 1 label"
    gray_chars = " .:-=+*#%@"
    gray_scale = 9
    print("Label: {}".format(pixels[0]))
    for index, pixel in enumerate(pixels[1:]):
        if(index % 28) == 0: print()
        print(gray_chars[pixel * gray_scale // 255], end=" ")
    print("\n")

Code:

display_image(train_set[1])

Output:

Label: 0

                                                                   
                                                        
                              . + % + .                 
                            . % % % % %                 
                          . % % % % % % :               
                        : # % % % # : % % =             
                      + % % % % % % - * % +             
                    . % % % * = % % . : @ +             
                  . % % % *   : =       % % .           
                . + % % # :             % % +           
                * % % :                 % % *           
              : % % :                   % % *           
              * % *                     @ % *           
            : % % -                     % % +           
            - % %                     = % *             
            - % #                   = % # :             
            - % +               . + % *                 
            - % #             = % % +                   
            - % % + . . - * # % # + .                   
            - % % % % # % % % * =                       
              # % % % % % % +                           
                = % % % = .                             
                                                        

Simplification on image: Binarization

To further simplify the model (and reduce the memory requirement of naive bayes classifier), we can binarize the image.

def binarize_image(pixels: list, threshold=120):
    """
    [Label, Pixel 1, Pixel 2, ..., Pixel 784]
    """
    binaryImg = [pixels[0]] # include the label
    binaryImg += [0 if pixel < threshold else 1 for pixel in pixels[1:]]    # binarize image based on threshold
    return binaryImg

def display_binary_image(pixels: list):
    display_image([pixels[0]] + [pixel * 255 for pixel in pixels[1:]])

binary_train_set = [binarize_image(img) for img in train_set]
binary_test_set = [binarize_image(img) for img in test_set]

Code:

display_binary_image(binarize_image(train_set[5]))

Output:

Label: 2

                                                        
                                                        
                                    @                   
                            @ @ @ @ @ @                 
                        @ @ @ @ @ @ @ @                 
                    @ @ @ @ @ @     @ @                 
                    @ @ @ @ @       @ @                 
                  @ @ @ @ @         @ @                 
                    @               @ @                 
                                  @ @ @                 
                            @ @ @ @ @ @                 
                        @ @ @ @ @ @ @                   
                    @ @ @ @ @ @ @ @ @                   
                  @ @ @       @ @ @ @ @                 
              @ @ @ @       @ @ @ @ @ @ @ @             
            @ @ @         @ @ @         @ @ @ @ @       
            @ @       @ @ @ @               @ @         
          @ @ @ @ @ @ @ @ @                             
          @ @ @ @ @ @                                   
              @ @                                       
                                                        
                                                       

Bayes Network on Image Recognition?

To begin with, we assume that the binary values on pixel are conditionally independent under the condition of label.

\[\mathbf{P}(Pixel_1 \mid Label) \bot \mathbf{P}(Pixel_2 \mid Label) \bot ... \mathbf{P}(Pixel_{784} \mid Label)\]

Since we know the input image, we know the value of each pixel, we can easily calculate $\mathbf{P}(pixel_1, pixel_2, \cdots ,pixel_{784} \mid Label)$ using this equation:

\[\mathbf{P}(pixel_1, pixel_2, \cdots, pixel_{784} \mid Label) = \prod_{i \in [1, 784]}{\mathbf{P}(pixel_i \mid Label)}\]

For simplicity, use $X$ denotes for $\lbrace pixel_1, pixel_2, \cdots, pixel_{784} \rbrace$

\[\begin{aligned} \mathbf{P}(Label \mid X) &= \alpha \mathbf{P}(X \mid Label)\mathbf{P}(Label)\\ &= \alpha \langle P(X \mid label_0)P(label_0), P(X\mid label_1)P(label_1), \cdots, P(X\mid label_9)P(label_9)\rangle\\ &= \alpha \langle \prod{P(pixel_i \mid label_0)\cdot P(label 0), \cdots}\rangle \end{aligned}\]

LabelCount = [0] * 10                           # Counter for Label, used to calculate P(Label)
PixelCount = [[0] * 784 for _ in range(10)]     # Counter for Pixel | Label, used to calculate P(pixel | label)

for img in binary_train_set:
    LabelCount[img[0]] += 1
    for index in range(1, len(img)): PixelCount[img[0]][index - 1] += img[index]    # +1 if pixel is black, 0 otherwise

LabelDistribution = [LabelCountElem / len(train_set) for LabelCountElem in LabelCount]
PixelDistribution = [
    [ pixel / LabelCount[i] for pixel in PixelCount[i]]
    for i in range(10)]

Code:

print("Label Distribution:\n", LabelDistribution)

Output ($\mathbf{P}(Label)$)：

Label Distribution:
 [0.09871666666666666, 0.11236666666666667, 0.0993, 0.10218333333333333, 0.09736666666666667, 0.09035, 0.09863333333333334, 0.10441666666666667, 0.09751666666666667, 0.09915]

With the statistical data collected from the Training set, we can now construct our Naive Bayes classifier.

def get_pixel_prob(index, value, label):
    global PixelDistribution
    try:
        black_probability = PixelDistribution[label][index]
    except:
        print(label, index)
    if value: return black_probability
    return 1 - black_probability

def predict_image(pixels):
    global PixelDistribution, LabelDistribution
    assert len(pixels) == 784, "only predict image without label at 0"
    pred_probability = [0] * 10
    for pred_label in range(10):
        posterior_probability_list = [get_pixel_prob(index, value, pred_label) for index, value in enumerate(pixels)]
        posterior_probability = 1
        for prob in posterior_probability_list: posterior_probability *= prob
        # posterior_probability = \prod{P(pixel_i | label_pred)}
        pred_probability[pred_label] = posterior_probability * LabelDistribution[pred_label]
    alpha = sum(pred_probability)
    return [prob / alpha for prob in pred_probability]

Classification on Test Set

Code:

selected_image_index = 3101
print("Predict Probability:\n", list(predict_image(binary_test_set[selected_image_index][1:])))
display_image(test_set[selected_image_index])

Output:

Predict Probability:
 [0.0, 0.0, 0.0, 1.3577222853703937e-55, 2.3620356632673247e-37, 1.0415370695140759e-36, 0.0, 0.9999999999999999, 6.262374232930145e-42, 1.1556946478312145e-16]
Label: 7

                                                        
                                                        
                                                        
                  + + - . : + + * % % % *               
                * % % % % % % % % % % % % =             
                # @ % % % % % % % % % % % % .           
              . % % % % % % % + - - * % % % .           
                # @ % % % +         = % % #             
                = % % % % :       . % % % =             
                . % % % +         + % % %               
                  : + = .       . % % % *               
                                # % % #                 
                              * % % % =                 
                            * % % % =                   
                          - % % % *                     
                        : % % % *                       
                        # % % * .                       
                    . * % % %                           
                    # % % % *                           
                  - % @ % #                             
                  * % % % #                             
                  % % @ % *                             
                  . * % +                               
                                                        

二维前缀和 2D Prefix Sum

Wed, 26 May 2021 00:00:00 +0000

前提条件

数据结构：前缀和 Prefix Sum

应用场景

在一些算法题中，我们需要快速求出二维数组内一个特定区域的所有值的和。这种时候，如果我们每次都使用遍历的方法求和，每次查询的时间复杂度是 $O(n^2)$，对于铜组以上的算法题来说这种时间复杂度一般是不可接受的。

二维前缀和就是专门用于解决这个问题的一种数据结构。二位前缀和会在初始化的时候使用 $O(n^2)$ 的时间复杂度建立一张二维数组从当前位置到 $[0][0]$ 的所有数字的和的表格。当初始化完成后，每次 $query$ 操作只需要 $O(1)$ 的时间复杂度就可以完成。

注意这种数据结构并不适合在二维数组需要大量更新的情况下使用，因为二位前缀和数组每次更新需要重新构造从更新位置开始的所有表格。每次更改的时间复杂度是 $O(n^2)$

原理

二位前缀和数据结构会在内部维护两张表格 $T$ 和 $S$。$S[y][x]$ 处存储的值等于 $T$ 中所有 $(0, 0)$ 到 $(x, y)$ 的位置的值之和。

当我们想查询两个点 $(x_1, y_1)$ 与 $(x_2, y_2)$ 构成的矩形内部所有数字的和时，我们可以这样计算：

表格 $S$ 可以使用下面这个公式遍历的方法生成

\[S[x][y] = S[x - 1][y] - S[x - 1][y - 1] + S[x][y - 1] + T[x][y]\]

注意上面 $S$ 中内容的运算顺序，对于 Java 等数值类型有最大值的语言，这样的顺序可以一定程度上的避免出现 Overflow 问题

实现

下面是基于 Java 范型 (Generic Type) 实现的一个二维数组。它可以存储任意数字类型的二维数组，但是查询时返回的内容总是 double 类型。

import java.util.ArrayList;

public class PrefixSum2D<T extends Number> {
    public static void main(String[] args) {
        Integer[][] arr = new Integer[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        PrefixSum2D<Integer> test = new PrefixSum2D<Integer>(arr);
        System.out.println(test.query2DSum(1, 0, 2, 2));
    }

    private ArrayList<ArrayList<T>> valueTable = new ArrayList<ArrayList<T>>();
    private ArrayList<ArrayList<Double>> sumTable = new ArrayList<ArrayList<Double>>();

    public PrefixSum2D(T[][] valueTable){
        for (int i = 0; i < valueTable.length; i ++){
            if (i == this.valueTable.size()){ this.valueTable.add(new ArrayList<T>()); }
            for (int j = 0; j < valueTable[0].length; j ++){
                this.valueTable.get(i).add(valueTable[i][j]);
            }
        }
        this.initializeTable(valueTable[0].length, valueTable.length);
        this.constructTable(0, 0);
    }

    public double query2DSum(int x1, int y1, int x2, int y2){
        /*
            Query the sum of all numbers in range ([x1, x2], [y1, y2]) with Time Complexity O(1)
                (x1, y1) ------------- (x2, y1)
                    |                     |
                    |                     |
                (x1, y2) ------------- (x2, y2)
        */
        x1 -= 1; y1 -= 1;
        if (x1 < 0 && y1 < 0){ return this.getTable(x2, y2); }
        else if (x1 < 0) { return this.getTable(x2, y2) - this.getTable(x2, y1); }
        else if (y1 < 0) { return this.getTable(x2, y2) - this.getTable(x1, y2); }
        else { return this.getTable(x2, y2) - this.getTable(x1, y2) - this.getTable(x2, y1) + this.getTable(x1, y1); }
    }

    public void slowUpdateTable(int x, int y, T value){
        /* Update 2D Prefix Sum Table with O(n^2) complexity */
        this.valueTable.get(y).set(x, value);
        this.constructTable(x, y);
    }

    private void initializeTable(int x, int y){
        /* Initialize the SumTable with size x * y and filled with null */
        for (int i = 0; i < y; i ++){
            this.sumTable.add(new ArrayList<Double>());
            for (int j = 0; j < x; j ++){
                this.sumTable.get(this.sumTable.size() - 1).add(null);
            }
        }
    }

    private void constructTable(int x, int y){
        /*
        Construct Table from T[y][x]
        Time Complexity: O(n^2), slow, don't call this method frequently
         */
        for (int i = y; i < this.sumTable.size(); i ++){
            for ( int j = x; j < this.sumTable.get(0).size(); j ++){
                double value = this.valueTable.get(i).get(j).doubleValue();
                if (i - 1 >= 0){ value += this.sumTable.get(i - 1).get(j); }
                if (i - 1 >= 0 && j - 1 >= 0){ value -= this.sumTable.get(i - 1).get(j - 1); }
                if (j - 1 >= 0){ value += this.sumTable.get(i).get(j - 1); }
                this.sumTable.get(i).set(j, value);
            }
        }
    }

    private double getTable(int x, int y){ return this.sumTable.get(y).get(x); }
}

线段树 Segment Tree

Fri, 21 May 2021 00:00:00 +0000

前提条件

使用场景

线段树的应用场景与二进制索引树相似，当我们需要多次查询数组子区间的特性/数据并同时高效修改数组内容的时候，我们可以使用线段树。

线段树并不是一种单一的数据结构 - 它代表了一类具有相同思想方法的数据结构 - 通过二叉树做到区间内容的高效查询，这里的内容可以是区间最大/最小值，区间和，等等。

数据结构

线段树是一个二叉树，线段树中的每一个节点代表序列中的一个区间。假设对于长度为 $N$ 的 array $A$，我们有对应的线段树 $T$，那么……

$T$ 的根节点代表整个 array $A$
$T$ 的每个叶子节点都代表 array $A$ 中的一个值 $A[i]$，$0\leq i\lt N$
$T$ 中的每一个非叶节点都代表 array $A$ 的一个子序列 $A[i:j]$，$0\leq i\lt j \lt N$

在一个线段树中，所有的叶子节点一定代表原数组中的一个值

注意线段树不一定是满二叉树

时间复杂度

初始化复杂度 - $O(n)$

对于一个长度为 $n$ 的 array，对应的线段树中最多一共有 $2n + 1$ 个节点。每个节点的初始化都是 $O(1)$ 的时间复杂度，所以线段树的初始化复杂度是 $O(n)$。

更新复杂度 - $O(\log{n})$

对于一个长度为 $n$ 的 array，每次修改一个单一的值需要修改这个节点的所有父节点与“祖先节点”（例如父节点的父节点，父节点的父节点的父节点……）。对于一颗线段树，最多有 $\log_2{n}$ 的高度，所以更新一次线段树的值的时间复杂度是 $O(\log_2{n}) = O(\log{n})$

查询复杂度 - $O(\log{n})$

查询节点数量最多的情况出现于查询 $[l, l]$ 时，这时候我们需要从根节点一路递归的遍历到叶子节点，一共遍历 $O(\log{n})$ 个节点。所以查询区间的时间复杂度是 $O(\log{n})$

Java实现

一个线段树有三个主要的方法：

初始化（Constructor）- 给定一个 Array，构建这个 Array 对应的线段树
查询（Query）- 给定一个区间范围 $[l, r]$，返回这个区间的信息（最大值，最小值，和 etc）
更新（Update）- 给定 index $i$ 与新的值 $v$，更新线段树

下面，我们会实现一个基于范型 (Generic Type) 的最小线段树。对于任意实现了 Comparable 接口的类型 T 的 ArrayList<T>，我们都可以使用这个线段树来求出区间 $[l, r]$ 中的最小对象 $T$。

Helper Functions

在正式实现线段树前，我们先写一些后面可以用到的 Helper Functions。

genericMin 函数通过比对 T.compareTo 的值来返回两个 T 对象中较小的一个对象
getLChild 计算出当前节点的左子节点的 index
getRChild 计算出当前节点的右子节点的 index
inInterval 计算出区间 $[l1, r1]$ 和 $[l2, r2]$ 之间的关系

public class SegmentTree <T extends Comparable<T>>{
    private ArrayList<T> tree;
    private T[] value;
    
	private int getLChild(int index){ return index * 2 + 1; }
    private int getRChild(int index){ return index * 2 + 2; }
    private T genericMin(T o1, T o2){
        if (o1.compareTo(o2) > 0){ return o2; }
        return o1;
    }
    private int inInterval(int l1, int r1, int l2, int r2){
        if (r2 < l1 || l2 > r1){ return 0; }        // Intervals do not have any intersection
        else if (l2 >= l1 && r2 <= r1){ return 1; } // Interval 2 complete in Interval 1
        else{ return 2; }                           // Interval 2 partially intersect with Interval 1
    }
}

注意我们的 tree 属性使用的是 ArrayList 而不是 array

这是因为 Java 中不能创造 Generic Type Array

Construct Segment Tree

我们使用递归的方法来构建线段树 - 根节点的范围是 $[0, arr.length - 1]$，计算出中间的节点 $mid = (arr.length - 1) / 2$，左节点的范围就是 $[0, mid]$，右节点的范围是 $[mid + 1, arr.length - 1]$。

当节点的范围是 $[l, r]$ 且 $l = r$ 时，节点的值就是 Array 中对应元素的值 - 此时这个节点时叶子节点。

public SegmentTree(T[] values){
    this.tree = new ArrayList<>(Collections.nCopies(values.length * 2 + 1, null));
    this.value = values;
    this.constructTree(0, 0, values.length - 1);
}

private void constructTree(int node, int l, int r) {
    if (l == r) {
        tree.set(node, value[l]);
    } else {
        int mid = (l + r) / 2;
        this.constructTree(this.getLChild(node), l, mid);
        this.constructTree(this.getRChild(node), mid + 1, r);
        tree.set(node, this.genericMin(tree.get(this.getLChild(node)), tree.get(this.getRChild(node))));
    }
}

Update Segment Tree

类似的，我们在更新 Segment Tree 时也使用递归的方法更新 - 如果要修改的 index 在当前节点的范围内，我们就递归的修改下一层，最后再 bottom-up 的更新整条路径上的 $O(\log{n})$ 个节点

public void updateTree(int index, T val){
    this.updateTree(0, 0, this.value.length - 1, index, val);
}

private void updateTree(int node, int l, int r, int index, T val){
    if (l == r){
        this.tree.set(node, val);
        this.value[l] = val;
    }
    else{
        int mid = (l + r) / 2;
        if (l <= index && index <= mid){ this.updateTree(this.getLChild(node), l, mid, index, val); }
        else{ this.updateTree(this.getRChild(node), mid + 1, r, index, val); }
        this.tree.set(node, this.genericMin(this.tree.get(this.getLChild(node)), this.tree.get(this.getRChild(node))));
    }
}

Query Interval Minimum

在查询线段树中的区间最小值时，我们把所有情况分为三种：

当前节点代表的区间完全在查询的区间内
当前节点代表的区间部分在查询的区间内
当前节点代表的区间完全不在查询的范围内

对这三种情况，我们采取不同的动作

情况	操作
节点区间完全在查询区间内	返回当前节点的值
节点区间部分在查询区间内	继续向下递归，返回左节点与右节点返回值的较小值
节点区间完全不在查询区间内	返回 `null`

public T queryMin(int l, int r){
    return queryMin(0, 0, this.value.length - 1, l, r);
}

private T queryMin(int node, int start, int end, int l, int r){
    if (this.inInterval(l, r, start, end) == 0){ return null; }
    else if (this.inInterval(l, r, start, end) == 1){ return this.tree.get(node); }
    int mid = (start + end) / 2;
    T leftInterval = this.queryMin(this.getLChild(node), start, mid, l, r);
    T rightInterval = this.queryMin(this.getRChild(node), mid + 1, end, l, r);
    if (leftInterval == null){ return rightInterval; }
    else if (rightInterval == null){ return leftInterval; }
    else{ return this.genericMin(leftInterval, rightInterval); }
}

对于基于数组

Integer[]{1, 2, 3, 4, 5, 6}

的线段树，我们执行 queryMin(2, 3) 时函数的递归情况如下

Click to see Java Full Code

        
 /* Segment Tree, Java */

import java.util.*;

public class SegmentTree <T extends Comparable<T>>{

    public static void main(String[] args) {
        SegmentTree<Integer> test = new SegmentTree<>(new Integer[]{1, 2, 3, 4, 5, 6});
        System.out.println(test.dumpTree());
        // test.updateTree(0, 7);
        // System.out.println(test.dumpTree());
        System.out.println(test.queryMin(2, 5));
    }
    
    private ArrayList<T> tree;
    private T[] value;
    
    public SegmentTree(T[] values){
        this.tree = new ArrayList<>(Collections.nCopies(values.length * 2 + 1, null));
        this.value = values;
        this.constructTree(0, 0, values.length - 1);
    }
    
    public void updateTree(int index, T val){
        this.updateTree(0, 0, this.value.length - 1, index, val);
    }
    
    public T queryMin(int l, int r){
        return queryMin(0, 0, this.value.length - 1, l, r);
    }
    
    public ArrayList<T> dumpTree(){
        return this.tree;
    }
    
    private T queryMin(int node, int start, int end, int l, int r){
        if (this.inInterval(l, r, start, end) == 0){ return null; }
        else if (this.inInterval(l, r, start, end) == 1){ return this.tree.get(node); }
        int mid = (start + end) / 2;
        T leftInterval = this.queryMin(this.getLChild(node), start, mid, l, r);
        T rightInterval = this.queryMin(this.getRChild(node), mid + 1, end, l, r);
        if (leftInterval == null){ return rightInterval; }
        else if (rightInterval == null){ return leftInterval; }
        else{ return this.genericMin(leftInterval, rightInterval); }
    }
    
    private void updateTree(int node, int l, int r, int index, T val){
        if (l == r){
            this.tree.set(node, val);
            this.value[l] = val;
        }
        else{
            int mid = (l + r) / 2;
            if (l <= index && index <= mid){ this.updateTree(this.getLChild(node), l, mid, index, val); }
            else{ this.updateTree(this.getRChild(node), mid + 1, r, index, val); }
            this.tree.set(node, this.genericMin(this.tree.get(this.getLChild(node)), this.tree.get(this.getRChild(node))));
        }
    }
    
    private void constructTree(int node, int l, int r) {
        if (l == r) {
            tree.set(node, value[l]);
        } else {
            int mid = (l + r) / 2;
            this.constructTree(this.getLChild(node), l, mid);
            this.constructTree(this.getRChild(node), mid + 1, r);
            tree.set(node, this.genericMin(tree.get(this.getLChild(node)), tree.get(this.getRChild(node))));
        }
    }
    
    private int getLChild(int index){ return index * 2 + 1; }
    private int getRChild(int index){ return index * 2 + 2; }
    private T genericMin(T o1, T o2){
        if (o1.compareTo(o2) > 0){ return o2; }
        return o1;
    }
    private int inInterval(int l1, int r1, int l2, int r2){
        if (r2 < l1 || l2 > r1){ return 0; }        // Intervals do not have any intersection
        else if (l2 >= l1 && r2 <= r1){ return 1; } // Interval 2 complete in Interval 1
        else{ return 2; }                           // Interval 2 partially intersect with Interval 1
    }
}

问题练习

Leetcode 307. Range Sum Query - Mutable 非常 straight-forward 的 Segment Tree 问题
Leetcode 218. The Skyline Problem
Leetcode 318. Count of Small Numbers After Self
USACO 2020 US Open Contest, Gold Problem 1. Haircut
USACO 2017 January Contest, Gold Problem 1. Balanced Photo
USACO 2017 February Contest, Gold Problem 3. Why Did the Cow Cross the Road III

CS188 Chapter 6 Constraint Satisfaction Problems

Tue, 11 May 2021 00:00:00 +0000

6.1 Define Constraint Satisfaction Problems

A CSP contains three components - $X$, $D$ and $C$.

$X$ is a set of variables
$D$ is a set of domains, one for each variable.
$C$ is a set of constraints that specify the allowable combination between variables.

Each constraint can be represent in two parameters - the $scope$ and the $relation$. The $scope$ define the variables that is related with this constraint. The $relation$ define the values that variables can take.

The $relation$ can be either an explicit list of all legal value tuple the variables can get or an abstract relation.

Example 1 (Abstract, Implicit Relation) : If the constraint is $x < y$. The formal way to represent constraint will be:
\[\langle scope:(x, y),\quad relation:\;\lt\rangle\]
Example 2 (Explicit Relation): If we have $0 < x < 4$ and $0 < y < 3$, the constraint can be represented in this way:
\[\langle scope: (x, y),\quad relation: [(1, 1), (1, 2), \cdots, (3, 1), (3, 2)] \rangle\]

To solve the Constraint Satisfaction Problem (abbr. as CSP below), we need to define the solution and state space for CSP first. Each state of CSP is defined by an **assignment** of values to some or all of the variables.

An assignment that does NOT violate any constraint in $C$ is called a consistent assignment (or, legal assignment).

A Complete Assignment is an assignment where every variable in $X$ is assigned.

The Solution of CSP is both Complete Assignment and Consistent Assignment.

6.2 Why we need CSP

In the real world, many problems can be converted to CSP. As long as we have a legal CSP solver, we can generalize this solver to different problems with little difficulty. It will be easier to use a generalized CSP solver than design a custom solution using domain-specific knowledge.

6.3 Solving CSP

When we are finding the solution of CSP, once we find out that a partial assignment is not a solution, we can immediately discard further refinements of the partial assignment.

6.3.1 Types of Constraints in CSP

Constraint Type	Explanation
Unary Constraint	Constraint that only contain one variable in the scope Example: $\langle (x), x\neq 2\rangle$
Binary Constraint	Constraint that contains two variables in the scope Example: $\langle (x, y), x < y \rangle$
k-ary Constraint	Constraint that contains $k$ variables in the scope Example: $\langle (x, y, z), \max(x, y, z) < 5 \rangle$
Global Constraint	Constraint that involving all variables in $X$ Example: $Alldiff$ Constraint requires all variables in $X$ has different assigned value.

Every finite-domain constraint can be converted to a set of binary constraints if enough auxiliary variables are introduced. Therefore, we can Transform every CSP into CSP with binary constraint only.

6.3.2 Constraint Propagation: Inference in CSP

A regular search algorithm can only do one thing: search. In CSP, the algorithm can search or do specific type of inference called constraint propagation in CSP. Using constraint to reduce the number of legal values of a variable, which, in turn reduce the legal values of another variable.

Constraint propagation can work during the search process or work as a pre-processing step.

The key idea of constraint propagation is the local consistency. If we see each variable in CSP as node, binary constraint as edge of graph, the local consistency is the consistency in a part of the whole constraint graph.

Basically, you can see local consistency as a set of pruning algorithms running on CSP. By cutting off domain of each variable, the workload for search algorithm is greatly reduced.

Node Consistency

Node Consistency Check tighten the unary domain using unary constraint

A single variable is node-consistent if all the values in the variable’s domain satisfy the variable’s unary constraints.

It is always possible to eliminate all the unary constraints in a CSP by running node consistency.

Arc Consistency

Arc Consistency Check tighten the unary domain using binary constraint

A variable in a CSP is arc-consistent if every value in its domain satisfies the variable’s binary constraints.

Formally speaking, $X_i$ is arc-consistent with respect to $X_j$ if for every value in $D_i$ there exist some value in $D_j$ such that the binary constraint between $X_i$ and $X_j$ is satisfied.

Note - iff stands for if and only if

AC3 is the most popular algorithm for arc consistency. To make every variable arc-consistent, the AC-3 algorithm maintains a queue of arcs to consider. Initially, the queue contains all the arcs in the CSP. AC-3 then pops off an arbitrary arc $(X_i, X_j)$ from the queue and makes $X_i$ arc-consistent with respect to $X_j$.

If this step makes the domain $D_i$ of variable $X_i$ unchanged, we will move forward to next arc.

If not, we add to the queue all arcs $(X_k, X_i)$ where $X_k$ is a neighbor of $X_i$. This is because the change of domain $D_i$ may lead to further reduction in the domain of $D_k$, even if we have previously considered $X_k$.

An arc-consistency CSP is equivalent to original CSP, but faster to search because its variables has smaller domains.

Path Consistency

Path Consistency Check tighten the binary constraints by using implicit constraints that are inferred by triples of variables

In Arc Consistency, we are using binary constraint to optimize the unary domain. For most of the cases, this works well and can directly find solution (every domain is restricted to only 1 value) or prove that there is no solution for CSP (at least one domain contains 0 valid value).

However, in some situation, the arc consistency has nothing to do with the unary domain using only binary constraint.

Example 3. A situation that arc consistency doesn’t work as expected

$X = {x, y, z}$

$D = {[Red, Blue], [Red, Blue], [Red, Blue]}$

$C = {\langle(x, y), x\neq y\rangle, \langle(z, y), z\neq y\rangle, \langle(x, z), x\neq z\rangle}$

If we are running arc consistency on this CSP, no domain will be changed. (When $x = Red$, $y = Blue$ is valid and vice versa). However, it is clear that this CSP will have no solution.

To solve this problem, we introduce the thought of Path Consistency.

Formal description of Path Consistency:

A two-variable set ${x_i, x_j}$ is path consistent with a third-variable ${x_k}$ if for every assignment ${x_i = a, x_j=b}$ that satisfy the constraint between $x_i$ and $x_j$, there exists a valid assignment to $x_k$ such that the constraint between $x_k$ and $x_i$, $x_k$ and $x_j$ is not violated.

$k$-Consistency

A generalized way to represent consistency of CSP is called $k$-consistency. A CSP is $k$-consistent if for any set of $k-1$ variables and for any consistent assignment to these variables, there always exist a consistent assignment to $k$th variable.

Node Consistency = 1-consistency, Arc Consistency = 2-consistency, Path Consistency = 3-consistency

A CSP is strongly k-consistent if it is $k$-consistent and is also $(k-1)$-consistent, $(k-2)$-consistent … all the way to $1$-consistent.

队列 Queue

Mon, 10 May 2021 00:00:00 +0000

前置条件

在学习这个知识点前，你应该先学习……

队列

队列 (Queue) 是一种用于收集数据的线性数据结构，主要有两个操作：

放入 (Push): 将元素放入队列中
取出 (Pop) : 将最先放入的元素从队列中取出

因为在这个数据结构中，最先放入的元素会被最先取出来，和日常生活中的排队情境一样，所以这个数据结构被称作队列。

编程实现

0 - 一个基于 `list` 的朴素实现

在 Python 与 Java 中，语言的 list 都提供了删除特定元素和在列表末尾添加元素的方法。所以一种最朴素的实现可以直接使用语言的 list 来完成。

	
class Queue:
	def __init__(self):
		self.data = list()

	def push(self, element):
		self.data.append(element)
	
	def pop(self):
		if len(self.data) > 0: return self.data.pop(0)
		else: raise Exception("Cannot pop from an Empty Queue")
	
	
	
import java.util.*;

class Queue{
	private ArrayList<Integer> arr = new ArrayList<>();

	public void push(int element){
		this.arr.add(element);
	}
	
	public int pop(){
		if (this.arr.size() > 0){
			int result = this.arr.get(0);
			this.arr.remove(0);
			return result;
		}
		else{
			return -1;
		}
	}
}

这种实现方法虽然可以 work，但是当你考虑时间复杂度的时候，你会发现这个实现实际上是非常低效的 - 每次从队列中取出一个元素的时候，你都要从队列中拿出第 0 项，同时将 1 ~ n 的所有元素依次向前挪动一格。这说明每次从队列中取出元素的时间复杂度是 $O(n)$。

那么有没有可能换一种实现数据结构的方法，从而达到放取都是 $O(1)$ 的时间复杂度的效果呢？

下面我们来看看如何使用刚刚学习的链表数据结构来提高 Queue 的效率

1 - 更加高效的队列（链表）

虽然访问链表中间的第 $n$ 个元素需要 $O(n)$ 的时间复杂度，我们可以非常方便的在链表的首尾做对元素进行增删的操作。每次在链表末尾增添一个元素只需要 $O(1)$ 的时间复杂度；同时，删除链表头部的元素也只需要 $O(1)$ 的时间复杂度。通过这两个特性，我们可以让队列做到进出都只需要 $O(1)$ 的时间复杂度。

	
class LinkedListNode:
    def __init__(self, val: int) -> None:
        self.next = None
        self.val = val

class Queue:
    def __init__(self) -> None:
        self.head = None
        self.tail = None
        self.size = 0
    
    def push(self, val: int) -> None:
        self.size += 1
        new_node = LinkedListNode(val)
        if self.head == None:
            self.head = new_node
            self.tail = new_node
        else:
            self.tail.next = new_node
            self.tail = self.tail.next
    
    def pop(self) -> int:
        self.size -= 1
        val = self.head.val
        self.head = self.head.next
        return val
    
    def size(self) -> int:
        return self.size
    
    def peek(self) -> int:
        return self.head.val
    
    def __str__(self) -> str:
        ptr = self.head
        string = "HEAD -> "
        while ptr.next != None:
            string += str(ptr.val) + " -> "
            ptr = ptr.next
        string += str(ptr.val) + " -> "
        string += "TAIL"
        return string
    
    
Not Implemented yet, see Python Version

2 - 更加高效的队列（循环数组）

除了链表以外，我们还可以用循环数组来实现队列。

	
class Queue:
    def __init__(self, max_capacity: int) -> None:
        self.arr = [0] * max_capacity
        self.max_len = max_capacity
        self.start = 0
        self.end = 0
    
    def size(self) -> int:
        return self.end - self.start
    
    def push(self, item: int) -> None:
        self.end += 1
        actual_index = (self.end - 1) % self.max_len
        self.arr[actual_index] = item
    
    def pop(self) -> None:
        actual_index = self.start % self.max_len
        self.start += 1
        return self.arr[actual_index]
    
    def peek(self) -> int:
        return self.arr[self.start % self.max_len]
    
    def __str__(self) -> str:
        string = "[ "
        for index, num in enumerate(self.arr):
            string += str(num)
            if index == self.start % self.max_len:
                string += "(START)"
            if index == self.end % self.max_len:
                string += "(END)"
            string += " | "
        string += " ]"
        return string
	
	
Not Implemented Yet, see Python Version

练习

Binary Index Tree (Fenwick Tree) 二叉索引树

Sun, 09 May 2021 00:00:00 +0000

前置技能

Python Version not Implemented Yet.

Traditional Approach 1

在实际生活中，我们常常需要计算一个给定array 特定范围内所有数的和。如果只有这一个需求的话，我们可以很方便的构建出一个静态的数组来达到$O(1)$的时间复杂度。在这样的一个数组中，每一个位置上的数符合：

\[\text{arr}[n] = \text{arr}[n - 1] + x[n]\] \[\text{arr}[0] = x[0]\]

这样，当我们需要计算数列x中m到n的数字的和时，我们只用计算 arr[n] - arr[m]就可以了。

然而，与计算的超高性能相比，这种方法要求我们操作的数列x是基本保持不变的，一旦x中的某一个值发生了变化，我们就要更新一次整个arr数组，这直接导致了修改的$O(n)$复杂度。

Traditional Approach 2

如果我们想要我们的数据结构可以接受大量的修改，我们也可以使用一个更加朴素的方法 - 我们只存储数列x，每次要计算区间和时，我们就遍历一次整个区间从而计算区间内所有元素的和。

使用这种朴素的方法，虽然计算区间和的复杂度位$O(n)$，每次我们对数组x进行修改却不需要额外的操作，只有$O(1)$的复杂度。

Why Traditional Approach Fail

我们知道，一个算法的时间复杂度是由算法中最耗时间的步骤所决定的，也就是说，如果我们在一个循环中同时需要查询数组x的区间和并且修改x，那么整个循环内的时间复杂度会由其中最耗时间的步骤决定 - $O(n)$。

二进制索引树被设计出来处理这种情况，它很好的在两种传统方法间做出取舍，使得我们可以同时以$O(\log{n})$的时间复杂度进行数组的修改和区间和查询操作。

Data Structure - BIT

虽然BIT的名字是“二叉索引树”，实际上在程序中，我们并没有使用一个“树”的结构去存储BIT对象，而是将其放在一个数组中，这种结构被称为“树状数组”，许多树结构也使用了这样的形式 - 例如二叉堆模型。

这是一个BIT数据结构的内部属性：

public class BinaryIndexTree{
    private int[] tree;
    private int[] val;
    
    // ...
    
}

BIT之所以中间有一个“index”，是因为BIT的构造和操作过程中都要使用索引的一个属性 - 索引( + 1后)二进制中最后一个1的位置。

Helper Function - Least Significant One

在 Java 中，我们可以写一个这样的函数来找到整数二进制最后一位的1在哪里：

public int findLastBinaryOne(int index){
    String binaryIndex = Integer.toBinaryString(index + 1);
    for (int i = binaryIndex.length() - 1; i > -1; i --){
        if (binaryIndex.substring(i, i + 1).equals("1")){return binaryIndex.length() - i;}
    }
    return -1;
}

通过计算索引 + 1后的二进制的最后一位1在哪里，我们可以得到BIT中这个位置的节点在树中的高度。

Construct BIT

如果findLastBinaryOne 返回为1，数组中这个位置是BIT的叶子节点，只存储输入数列x在这个位置的值（例如在下图中的 index = 0, 2, 4, 6, …）的位置。

如果findLastBinaryOne(index)的返回是n 且$n > 1$，在BIT中，这个位置的值等于x中这个位置的值加上BIT[index - 2**0]， BIT[index - 2 ** 1] … BIT[index - 2 ** (n - 2)]

假设我们计算BIT中一个位置的值（假设BIT树中前面的值都是正确的），我们可以这样写：

private int getBITVal(int i){
    //return the BIT value on i
    int sum = 0;
    int power = 0;
    int pos = i;
    int maxPower = this.findLastBinaryOne(i);
    while (i >= 0 && power < maxPower){
        if (power == 0){sum += this.val[i];}
        else{sum += this.tree[i];}
        i = pos;
        i -= (int) Math.pow(2, power);
        power ++;
    }
    return sum;
}

因为每次我们调用getBITVal函数的时候我们都假设BIT中左侧的地方已经被初始好了，当我们初始化整个BIT时，我们需要从左到右的计算数组中每一个位置的 BIT值

private void initializeBIT(){
    for (int i = 0; i < this.tree.length; i ++){this.tree[i] = this.getBITVal(i);}
}

考虑到每次调用getBITVal都需要$O(\log{n})$的时间复杂度，我们初始化整个BIT数组的时间复杂度会是$O(n \log{n})$。虽然高于传统方法的$O(n)$，但是考虑到一般初始化代码只会执行一次，这个时间复杂度是可以接受的

Get Sum from BIT

我们现在已经有了BIT，那么我们怎么使用它查询一个区间内的元素和呢？首先，我们先看如何通过BIT查询 0 - index的区间和。观察上面的图，我们不难发现，一个BIT并不是单独的一棵树，而是很多棵子树所构成的，每个子树的根节点代表它所有叶子节点的和。那么，如果我们要计算0 - index的区间和的话，我们只需要找到index的二进制，然后每次去掉其中排在最后的一个1即可。（对应的是index前的根节点）

例子：如果我们需要计算 0 - 6之间的区间和，我们要 …

binary (6 + 1) = 1011

sum = tree[1011] + tree[1010] + tree[1000] = tree[7] + tree[6] + tree[4]

用java代码表示，就是这样：

public int getSum(int endIndex){
    int sum = 0;
    if(endIndex == 0){return this.tree[0];}
    while(endIndex > 0){
        sum += this.tree[endIndex];
        endIndex -= (int) Math.pow(2, this.findLastBinaryOne(endIndex) - 1);
    }
    return sum;
}

注意到循环的执行次数最大为索引二进制数的长度，也就是$\log_2{\text{index}}$，这说明调用一次getSum函数只会有$O(\log{n})$的时间复杂度

有了从0到index的区间和，我们就可以很方便的计算出任意两个索引之间的区间和（因为同是求区间和，这里直接重载了之前的getSum函数）

public int getSum(int startIndex, int endIndex){
    return this.getSum(endIndex) - this.getSum(startIndex);
}

Update BIT Tree

前文提到过BIT最大的优势是在保证快速求出区间和的同时可以快速进行数据结构的更新，接下来我们看看BIT是怎么进行数据结构的更新的：

如果我们想要更改this.val中的数据，我们必须更新其对应的树结构。因为BIT中兄弟节点是互不影响的，我们只用更新被更新索引所在的BIT树的所有父节点就可以了。

因为树的高度取决于索引二进制的长度，总共需要更新的节点数量的上限为$O(\log{n})$，用Java代码可以这样写：

private ArrayList<Integer> getParents(int index){
    ArrayList<Integer> parents = new ArrayList<Integer>();
    while (true){
        int currStep = (int) Math.pow(2, this.findLastBinaryOne(index) - 1);
        index += currStep;
        if(index > this.tree.length){break;}
        parents.add(index);
    }
    return parents;
}

public void updatePoint(int index, int newVal){
    this.tree[index] -= this.val[index] - newVal;
    this.val[index] = newVal;
    ArrayList<Integer> parents = this.getParents(index);
    for (int i = 0; i < parents.size(); i ++){
        this.tree[parents.get(i)] = this.getBITVal(parents.get(i));
    }
}

（上面的代码因为每个父节点更新都调用了一次getBITval函数，实际上的时间复杂度是$O((\log{n})^2)$，通过修改实现方式，我们可以达到 $O(\log{n})$ 的时间复杂度）

练习

最小生成树 Min-Span Tree

Mon, 03 May 2021 00:00:00 +0000

最小生成树

假设要在国际部的每个教室间接网线，每条网线只能直接连接两间教室，如何才能用最少的网线，让所有的教室都连通？

这是一个很典型的最小生成树问题。对于一个图，你需要找到一组 edge, 使得所有的 vertex 都连通，同时 cost 最少。解决这个问题通常会使用 Kruskal 或者 Prim 算法。

Prim 算法的思路是这样的，我把所有的节点分成两个部分，一部分是已经在最小生成树上的节点，一部分是还没添加的节点。当我需要添加一个节点时，我要找出剩下的节点中，离已有的书直接相连并且 cost 最低的点。不断重复这个过程直到所有的点都添加到了树上。

伪代码

T = {s}
将 s 的所有 edge 都添加到优先队列 PQ 中
当 PQ 不为空时:
  v, cost = PQ.pop()
  如果 v 不在 T 中:
    将 v 加入 T
    将所有 v 的 edge 都加入到 PQ
T

代码实现


def prim(graph, start=0):
  """ 
  生成 graph 的 prim

    参数:
      graph: 你要处理的图
      start: 表示从哪个 vertex 开始生成，对于一般情况来说，从哪个 vertex 开始都一样，默认从 0 号开始
  """
  MAX_INT = 9999999
  distance = [MAX_INT] * graph.getNumVertices() # distance 表示的是所有 vertex 到最小生成树任意节点的最小 cost，初始化为正无穷
  isInTree = [False] * graph.getNumVertices() # isInTree 表示 vertex 是否在树上

  vertex = start # vertex 表示当前要添加进树的节点
  distance[vertex] = 0
  while not isInTree[vertex]:
    isInTree[vertex] = True

    # 枚举 vertex 的所有邻居，如果需要的话更新它们到树的距离
    for (neighbor, cost) in graph.getNeighbors(vertex):
      if not isInTree(neighbor):
        distance[neighbor] = min(distance[neighbor], cost)

    # 找出下一个要添加的 vertex
    minCost, minVertex = MAX_INT, 0
    for (v, cost) in enumerate(distance):
      if (not isInTree[v]) and cost < minCost:
        minCost, minVertex = cost, v

    vertex = minVertex


    Not Implemented Yet

题目

优先队列 Priority Queue

Fri, 30 Apr 2021 00:00:00 +0000

前置条件

优先队列

在日常生活中，大家也许遇到过下面这些情景 - 在堵车的时候，救护车和消防车可以优先通过拥堵路段；在排队的时候，一些人的优先级比别人的高…… 在这些情景中，我们既希望可以维持一个类似队列的结构，也希望能够为这个队列提供一定的灵活性 - 一些优先级高的内容可以优先出队列。

优先队列就是专门设计用来解决这些问题的一种数据结构。正如他的名字所言，优先队列就是一个有优先级规则的队列。

数据结构实现

一般我们会使用最小堆来实现优先队列。如果你还记得，一个最小堆实际上是一颗二叉树 - 在根节点处的值总是整个堆中的最小值，每个父节点都一定大于等于自己的子节点们。如果我们按照内容的优先级做排序就可以保证优先级最高的项目无论什么时候加入优先队列都会排在优先队列的第一位。

代码实现

	
# Suppose we have the minHeap class already
class PriorityQueueItem:
	def __init__(self, priority, value):
		self.priority = priority
		self.val = value

	def __lt__(self, other):
		return self.priority < other.priority

	def __eq__(self, other):
		return self.priority == other.priority

	def __gt__(self, other):
		return self.priority > other.priority


class PriorityQueue:
	def __init__(self):
		self.heap = minHeap()

	def pushItem(value, priority=0):
		"""
		put Priority Queue Item into the Priority Queue, with default priority 0.
		"""
		self.heap.push(PriorityQueueItem(priority, value))

	def popItem():
		"""
		get item from Priority Queue
		"""
		return self.heap.pop().val

	def isEmpty():
		return self.heap.isEmpty()
	
	
Not Implemented Yet. See Python Version.

实际使用

在实际的竞赛中，我们出于对速度和 debug 方面的考虑一般不会使用自己实现的 Priority Queue，而是会使用官方实现好的内置 Priority Queue 实现。下面我们会介绍一下各个语言中 Priority Queue 的实际用法。

Python - heapq 内置库

在 Python 中，我们可以用 heapq 库实现 Priority Queue。heapq 对于优先队列的实现与大部分数据结构不同 - 一般我们实现一个数据类型的时候，我们都会单独定义一个 class 来实现我们的数据结构，每次需要的时候对数据结构进行实例化。

然而，在 heapq 中，Priority Queue 的实现使用了一种类似于函数式编程的思想 - 这个库并没有实现class PriorityQueue，而是设计了三个函数来对 list 进行操作来“模拟”一个 Priority Queue。

下面是三个非常常用的函数：

heapq.heappush(arr: list, element: Comparable) -> None 来向优先队列 arr 添加元素
heapq.heappop(arr: list) -> element 从优先队列arr中取出元素
heapq.heapify(arr: list) -> None 对 list arr 中的元素重新排序，使 arr 中的元素排序符合最小二分堆的要求

Java - java.util.PriorityQueue

Oracle Java.util.PriorityQueue 官方文档

Priority Queue 实例化方法

PriorityQueue<T> a = new PriorityQueue<>(); - 生成一个优先队列，其中的元素都是 class T 或者 class T 的子类。
PriorityQueue<T> a = new PriorityQueue<>(ComparatorT) - 实例化一个优先队列，使用 ComparatorT 对优先队列中的元素进行排序。

Java 中的 Priority Queue 默认是使用 NaturalOrder 对队列中的元素进行排序的，如果需要使用自定义的比较器，需要在实例化 Priority Queue 的时候将比较器实例作为参数传入构造函数。

Priority Queue 常用函数

add(E object) - 添加一个元素到 Priority Queue 中
peek() - 在不将队列底部元素（下一个被 pop 出来的元素）移出 Priority Queue 的前提下查看队列底部。
poll() - 返回 Priority Queue 的底部元素并同时在 Priority Queue 内删除该元素

代价统一搜索 Uniform Cost Search

Thu, 29 Apr 2021 00:00:00 +0000

前置条件

代价统一搜索策略

在之前的深度优先搜索和广度优先搜索中，我们一般都只考虑目标节点与出发节点之间的图上距离¹而非真实距离² - 这在一些简单的场景下没有什么问题，但是在一些情况下图上的距离与真实距离并不一致。例如下图：

在下面这张图中， $G$ 与 $S$ 之间的图上距离最小路径应该是直线 $A$。但是，如果我们要看 $G$ 和 $S$ 之间的路径权重之和最小的话我们会发现最优路径并不是 $A$ 而是 $A*$，因为 $A$ 的路径权重之和为 $10 + 5 = 15$ 而 $A*$ 的路径权重之和为 $1 + 2 + 1 + 1 = 5$。

为了找到实际距离最短的路径而不是图上距离最短的路径，人们在 BFS 的基础上做出了改动，产生了更加准确的 UCS 代价统一搜索策略。在 BFS 中，Queue 的性质距离初始节点图上距离最小的节点会优先被展开，而在 UCS 中，我们用 Priority Queue 实现 Fringe，这个优先队列对待探索节点的排序是基于初始节点到待探索节点的实际距离决定的。

一张图的 “等 Cost 线“

在 UCS 对图像进行遍历的过程中，如果在 Fringe 中 Actual Cost 最小的节点的 Actual Cost 为 $C$，则所有已探索的节点的 Actual Cost 都一定$\leq C$。通过这个性质，我们可以轻易证明UCS找到的第一个目标节点一定是距离初始节点实际距离最小的目标节点（即最优解）。

代价统一算法的实现

    
import heapq    # The Python Module for Priority Queue

def uniformCostSearch(initialState, getSuccessor, getValidActions, getActionCost):
    """
    :param initialState: The Initial State of problem (sometimes the 'current state')
    :param getSuccessor: The State Transition Function that return the successors given the current state and action
    :param getValidActions: A function that takes current state and return a list of valid actions under current state
    :param getActionCost: A function that will return cost of action given action and current state
    """
    fringe = []    # The only difference between BFS and DFS
    exploredStates = set()
    
    # Add the Initial State into the Fringe before Searching Actually Start.
    # Instead of storing state directly in the fringe, we will use a tuple to store state, where the 
    # 0th param of tuple is cumulative cost
    # 1th param of tuple is the state
    
    heapq.heappush(fringe, (0, initialState))	# The initial cost is 0
    while len(fringe) > 0:
    	cost, currState = heapq.heappop(fringe)
        if currState in exploredStates: continue
        else: exploredState.add(currState)
            
        # Do Something Here
        
        for action in getValidActions(currState):
            # Add Successor States into the fringe
            successor = getSuccessor(currState, action)
            if successor not in exploredStates:
                deltaCost = getActionCost(currrState, action)
                heapq.heappush((cost + deltaCost, successor))
    
    
Not Implemented Yet, see Python Version

练习

暂无练习（一般与其他算法搭配使用，很少有单独的练习出现，思考一下之前做过的一些 BFS / DFS 题目有没有可能用 UCS 取代原来的算法来优化？）

图上距离指节点之间的边的数量 ↩
真实距离指节点之间的边的权重之和 ↩

CS188 Chapter 5 Adversarial Search

Thu, 22 Apr 2021 00:00:00 +0000

5.1 Games

This chapter describes the Competitive Environments for agents, where their goals are conflict. Such problem is called the adversarial search problems - often known as games.

In the field of AI, the most common games are a special kind of game - the Deterministic, Turn-taking, Two-player, Zero-sum games of Perfect Information (such as chess).

Games are interesting since they are hard to solve using direct search - the branching factor of game is too large that it is impossible to search through all possible states. Also, games penalize inefficiency severely so the program should be as fast as possible.

Pruning （剪枝） allows us to ignore portions of search tree that make no difference to the final choice. Heuristic Evaluation Functions allow us to approximate the true utility of a state without doing a complete search.

Suppose there are two agents - “MAX” and “MIN”. In a game, “MAX” move first and they take turn to move until the game is over. The winner get points and loser get penalty.

5.1.1 Formally Defined Game

A game can be formally defined with these elements

Element	Explanation
$S_0$	The Initial State of game (the setup of game)
$Player(s)$	Defines which player has a move in the current state $s$
$Actions(s)$	Returns a list of legal actions in a state $s$
$Result(s, a)$	The state transition model, which defines the result of an action $a$
$Terminal-Test(s)$	Returns `true` if the game is over, `false` otherwise
$Utility(s, p)$	A utility function defines the numeric value for a game that ends in terminal state $s$ for player $p$

The Zero-sum game is defined as one where the total payoff to all players is the same for every instance of the game.

The initial state $S_0$, $Action$ function and $Result$ function define the game tree for the game - a tree where the nodes are game states and the edges are actions.

In a game tree, we record the utility value of the terminal state from the point of view of $MAX$ agent.

Though a game tree is well-defined and has finite amount of nodes in it, it is better thought to be a theoretical construct we can’t realize in physical world as it has too many nodes in it (the Go has $10^40$ nodes, tic-tac-toe has more than $3\times 10^5$ nodes). We usually use term search tree to represent a tree that is extracted from the full game tree, and contains enough nodes to allow a player to determine what action to make.

5.2 Optimal Decision in Games

In an adversarial search scene, the MAX agent must find a contingent strategy. An optimal strategy leads to outcomes at least as good as other strategy when one is playing an infallible opponent.

In the graph above, the maximum utility at node $A$ is 3, since the MAX agent can’t change the choice of MIN agent, and in the worst situation (no matter which action MAX agent choose, MIN will always select the successor with min utility for MAX), the maximum utility at $A$ is 3, when MAX takes action $a_1$.

In game theory, we combine a move of MAX and a move of MIN as “one move”, and call two half-moves the “ply”.

Given a game tree, the optimal strategy can be determined from the minimax value of each node. The minimax value of a node is the utility for MAX at that state assuming that both players play optimally from there to the end of the game.

\[MINMAX(s) = \begin{cases} Utility(s) & \text{if }TERMINAL-TEST(s)\\ max_{a\in Action(s)}{MINIMAX(RESULT(s, a))} & \text{if }Player(s) = MAX\\ min_{a\in Action(s)}{MINIMAX(RESULT(s, a))} & \text{if }Player(s) = MIN\\ \end{cases}\]

The image above shows the minimax decision at the root of game tree: action $a_1$ is the optimal choice for MAX because it leads to the state with the highest minimax value. The minimax decision maximize the worst-case outcome for MAX.

Other strategies may do better than the minimax strategy when playing with sub-optimal agent, but in the worst case, they are necessarily worse than the minimax decision.

5.2.1 Minimax Algorithm

The minimax algorithm computes the minimax decision from the current state. The recurssion proceeds all the way down to the leaves of the tree, and then back up through the tree as the recurrsion call back.

def minValue(s) -> int:
    """
    return the minimum utility that can achieve from state s assuming MAX agent is playing optimally
    we assume this is the utility that MIN agent's move will result to
    """
    if TERMINAL_TEST(s): return UTILITY(s)
    minVal = float('inf')
    for a in ACTION(s):
        minVal = min(minVal, maxValue(RESULT(s, a)))
    return minVal

def maxValue(s) -> int:
    """
    return the maximum utility that can achieve from state s assuming MIN agent is playing optimally
    we assume this is the utility that MAX agent's move will result to
    """
    if TERMINAL_TEST(s): return UTILITY(s)
    maxVal = -1 * float('inf')
    for a in ACTION(s):
        maxVal = max(maxVal, minValue(RESULT(s, a)))
    return maxVal

def minimaxDecision(s) -> Action:
    """
    Return the action that maximize the minimax value at s
    """
    resAction = None
    maxMinimax = -1 * float('inf')
    for a in ACTION(s):
        if minValue(RESULT(s, a)) > maxMinimax:
            maxMinimax = minValue(RESULT(s, a))
            resAction = a
    return resAction

Though the game we discuss is zero-sum game, alliances is still a possible choice. Collaboration may emerge from purely selfish behavior.

5.3 Alpha-Beta Pruning

When we are using minimax decision algorithm, we have to travel through the game tree using DFS. The node we have to explore will grow exponentially as the depth of game tree grow. Though we can’t eliminate the exponential term in time complexity, we can effectively reduce its size by applying pruning methods.

Here, we will apply alpha-beta pruning on the standard minimax tree. It will return the same move as minimax decision algorithm would and prunes away branches that can’t possibly influence the final decision.

The idea of alpha-beta pruning comes from a very simple observation - in some cases, we don’t need to find all successors’ utilities to calculate the minimax value at a node. For instance, in the fig above, when we see the maximum minimax value at $C$ is 2, we know its minimax value must be smaller than $B$’s minimax value (which is 3) and we can ignore the other two nodes (dash line) under $C$.

If Player has a better choice than $n$, $n$ will never be reached in actual play. Therefore, once we find enough information about $n$ to reach this conclusion, we can prune it.

Below shows a general case for alpha-beta pruning:

$\alpha=$ the minimax value of the best choice (max-value) we have found so far at any choice point along the path for MAX

$\beta=$ the minimax value of the best choice (min-value) we have found so far at any choice point along the path for MIN

Alpha-beta pruning update the $\alpha$ and $\beta$ as it goes along and prunes the remaining branches at a node as soon as the value of the current node is known to be worse than the current $\alpha$ or $\beta$ for MAX and MIN respectively.

def maxValue(s, alpha, beta) -> int:
    """
    returns an integer represent the minimax value at current state (or the last value before the node is pruned)
    """
    if TERMINAL_TEST(s): return UTILITY(s)
    minimaxVal = -1 * float("inf")
    for a in ACTION(s):
        minimaxVal = max(minimaxVal, minValue(RESULT(s, a), alpha, beta))
        if minimaxVal >= beta:      # Since the MIN agent is optimal, this scnerio will never occur
            return minimaxVal       # the following expansion is pruned
    return minimaxVal

def minValue(s, alpha, beta) -> int:
    """
    returns an integer represent the min minimax value at current state (or the last value before the node is pruned)
    """
    if TERMINAL_TEST(s): return UTILITY(s)
    minimaxVal = float("inf")
    for a in ACTION(s):
        minimaxVal = min(minimaxVal, maxValue(RESULT(s, a), alpha, beta))
        if minimaxVal <= alpha:     # Since the MAX agent is optimal, the MAX agent will never reach this node (as there exist better path)
            return minimaxValue     # the following expansion is pruned
    return minimaxValue

To start searching from the root, use maxValue(root, -1 * float("inf"), float("inf"))

5.4 Backtracking

Backtracking is a way to prune the search space. When we are searching through a search space, sometimes we can make sure the current solution is impossible when we haven’t reach the end of action sequence.

Suppose a game need 4 actions to make up an action sequence, we can sometimes know we will lose when playing only 2 actions yet. In this case, we can stop searching and go back to previous step and choose another action to play. (this is the reason why it is called Backtracking)

The effect of backtracking will be more significant if we can identify whether it is possible or not to get to goal node from a shallower node. In such situation, much of the search space will be pruned.

A famous problem that can be solved by Backtracking is the “eight queens” problem. Detailed description of a more general case (n-queen problem) is in this link: UVA-11195 Another n-Queen Problem.

def nQueen(state, currCol):
    if currCol == len(state): return 1

    resultState = 0
    for candidate in range(len(state)):
        if isValidState(state, candidate, currCol):
            newState = state[:]
            newState[currCol] = candidate
            resultState += nQueen(newState, currCol + 1)
    return resultState

def isValidState(state, candidate, currColumn):
    if candidate in state: return False     # are queens on the same row
    for i, position in enumerate(state):
        if i >= currColumn: break
        if abs(position - candidate) == (currColumn - i):
            return False                    # are queens on the same diagonal
    return True

栈 Stack

Thu, 15 Apr 2021 00:00:00 +0000

前置条件

在学习这个知识点前，你应该先学习……

理论基础：时间复杂度 Time Complexity

栈

栈(stack)是一种用于收集数据的线性数据结构，主要有两个操作

放入(push): 将元素放进集合
取出(pop) : 将最后放入的元素取出

因为Stack的两个操作，我们也可以将Stack记为LIFO(last in, first out)，也叫后进先出。

在栈(stack)中，还有几种常见的方法：

peek: 查看当前的栈最后的一个元素
isEmpty: 判断当前栈是否是空的

代码实现


class Stack:
    def __init__( self ):
        self.stack = []

    def push( self, item ):
        self.stack.append( item )
        return self.stack

    def pop( self ):
        if self.isempty(): return -1
        self.stack.pop()
        return self.stack

    def peek(self):
        return self.stack[ -1 ]

    def isempty(self):
        if len( self.stack ) == 0: return True
        return False


import java.util.ArrayList;

public class Stack {
    ArrayList<Integer> stack = new ArrayList<Integer>();

    public void push( int item ){
        stack.add( item );
    }

    public int pop(){
        if ( ! stack.isEmpty() ) {
            return stack.remove(stack.size() - 1);
        }
        return -1;
    }

    public int peek(){
        return stack.get( -1 );
    }

    public boolean isempty(){
        if ( stack.size() == 0 ) {
            return true;
        }
        return false;
    }
}

时间复杂度 Time Complexity

栈的push 和 pop 方法的时间复杂度都是 $O(1)$，因为每次将一个 object 放入栈中的时候，我们只需要在 ArrayList 末尾添加一个元素即可。每次从栈中取出一个 object，我们只是读取 ArrayList 末尾的元素并删除而已。

深度优先搜索 Depth First Search

Mon, 12 Apr 2021 00:00:00 +0000

前置条件

在学习这个知识点前，你应该先学习……

深度优先算法

搜索实际上可以看作遍历图的所有节点，直到遇到目标节点为止的过程。深度优先搜索在遍历的过程中遵循这样的规则：

在所有待遍历的节点中，最深的节点最先被探索

这里的“深”指的是节点到开始探索的节点的距离（边的数量）。注意：与广度优先算法不同的地方在于深度优先算法不能保证找到的目标节点是最浅（最优）的。

深度优先算法的实现

与 BFS 不同，在 DFS 中我们要维护一个 queue 来作为 Fringe 存储待探索的节点。


def depthFirstSearch(initialState, getSuccessor, getValidActions):
    """
    :param initialState: The Initial State of problem (sometimes the 'current state')
    :param getSuccessor: The State Transition Function that return the successors given the current state and action
    :param getValidActions: A function that takes current state and return a list of valid actions under current state
    """
    fringe = queue()    # The only difference between BFS and DFS
    exploredStates = set()
    
    # Add the Initial State into the Fringe before Searching Actually Start.
    fringe.push(initialState)
    while len(fringe) > 0:
		currState = fringe.pop()
        exploredState.add(currState)
            
        # Do Something Here
        
        for action in getValidActions(currState):
            # Add Successor States into the fringe
            successor = getSuccessor(currState, action)
            if successor not in exploredStates: fringe.push(successor)


Not Implemented Yet. See Python Version.

深度优先算法的复杂度

时间复杂度

深度优先算法的时间复杂度与广度优先算法的时间复杂度相同 - 是 $O(E + V)$，具体的解释和广度优先搜索的基本一致（使用双向链表deque 实现的 queue 在取出节点时的时间复杂度也是 $O(1)$），所以直接 quote 过来。

假设我们要在图 $G(V, E)$ （图 $G$ 有 $V$ 个节点，$E$ 条边）上使用广度优先算法进行遍历，算法最多只会遍历所有节点1次（不会出现重复查看的情况），如果 Fringe 的 Stack 是用双头链表 deque 实现的，那么每次从 Fringe 中取出节点的时间复杂度是 $O(1)$。这总共贡献了 $O(V)$ 的时间复杂度。因为每一条边只会在一端的节点被探索到时被查看一次，所以边最多被探索 $2E$ 次。每次探索一条边（因为是从 dictionary 中取出）只会有 $O(1)$ 的时间复杂度，所以探索边的总时间复杂度是 $O(2E) = O(E)$。

综上所述，BFS 的时间复杂度是 $O(V + E)$

空间复杂度

假设我们在图 $G$ 上运行DFS，在 $G$ 中平均每个节点有 $\alpha$ 个子节点，目标节点在第 $n$ 层，那么当探索到目标节点时，算法的空间复杂度应该是 $Space(\alpha, n) = n \times (\alpha - 1)$，也就是 $O(n\alpha)$。

注意到这个空间复杂度比 BFS 的 $O(\alpha^n)$ 要好非常多倍，我们在已知目标节点深度较深或者图的 $\alpha$ 值较大时应该优先选择 DFS。

练习

广度优先搜索 Breadth First Search

Mon, 12 Apr 2021 00:00:00 +0000

前置条件

在学习这个知识点前，你应该先学习……

广度优先搜索策略

搜索实际上可以看作遍历图的所有节点，直到遇到目标节点为止的过程。广度优先搜索在遍历的过程中遵循这样的规则：

在所有待遍历的节点中，最浅的节点最先被探索

这里的“浅”指的是节点到开始探索的节点的距离（边的数量）。因为广度优先搜索总是优先探索浅的节点，如果算法正在探索深度为 $h$ 的节点，那么所有深度小于 $h$ 的节点都一定已经被探索了。

也就是说，如果整个图中存在多个目标节点，那么BFS找到的第一个目标节点一定是距离初始节点最近的节点。

广度优先搜索的实现

在广度优先搜索的过程中，我们需要维护一个 Stack，其中保存着所有与已探索节点相邻但是还没有探索的节点，这样的一个数据结构被称作 Fringe （已探索部分的边缘）。在探索 $h-1$ 层节点的时候， $h$ 层的节点会被放入 Fringe 中，只有在探索完 $h-1$ 层的节点以后才会探索 $h$ 层的节点。这时候，所有 $h$ 层的节点都已经被探索或者在 Fringe 中了，所以后面压入栈的 $h+1$ 层节点一定会比 $h$ 层节点更晚被探索。


def breadthFirstSearch(initialState, getSuccessor, getValidActions):
    """
    :param initialState: The Initial State of problem (sometimes the 'current state')
    :param getSuccessor: The State Transition Function that return the successors given the current state and action
    :param getValidActions: A function that takes current state and return a list of valid actions under current state
    """
    fringe = stack()
    exploredStates = set()
    
    # Add the Initial State into the Fringe before Searching Actually Start.
    fringe.push(initialState)
    while len(fringe) > 0:
        currState = fringe.pop()
        exploredState.add(currState)
            
        # Do Something Here
        
        for action in getValidActions(currState):
            # Add Successor States into the fringe
            successor = getSuccessor(currState, action)
            if successor not in exploredStates: fringe.push(successor)


    Not Implemented Yet. See Python Version of BFS.

广度优先算法的复杂度

时间复杂度

假设我们要在图 $G(V, E)$ （图 $G$ 有 $V$ 个节点，$E$ 条边）上使用广度优先算法进行遍历，算法最多只会遍历所有节点1次（不会出现重复查看的情况），如果 Fringe 的 Stack 是用双头链表 deque 实现的，那么每次从 Fringe 中取出节点的时间复杂度是 $O(1)$。这总共贡献了 $O(V)$ 的时间复杂度。因为每一条边只会在一端的节点被探索到时被查看一次，所以边最多被探索 $2E$ 次。每次探索一条边（因为是从 dictionary 中取出）只会有 $O(1)$ 的时间复杂度，所以探索边的总时间复杂度是 $O(2E) = O(E)$。

综上所述，BFS 的时间复杂度是 $O(V + E)$

空间复杂度

假设图 $G$ 中平均一个节点会连接到 $\alpha$ 个子节点，目标节点在第 $n$ 层，那么BFS的空间复杂度会是 $O(\alpha^n)$。

从这里我们也可以看出 BFS 并 不适合在目标节点很深的情况下使用，如果目标节点在 28 层，即使 $\alpha = 2$，每个节点只占一个 32 位 int 的大小，内存也会占用 $1G$ 的大小来存放 Fringe，而 USACO 等算法竞赛的内存上限一般是 $256M$。

练习

参考书目

《算法导论》Chapter 22.2 Breadth First Search

数组的排序

Tue, 09 Mar 2021 00:00:00 +0000

注意，这个页面并不是描述排序算法的页面。这个页面描述的是各个语言具体如何实现对数组的排序。如果你想看排序算法相关的内容，点击这里

前置条件

数据结构：列表 Array (List) and ArrayList

在 Java 中，一般我们只会对 ArrayList 中的对象进行排序操作。在对数组排序时，我们会使用 ArrayList.sort 方法。这个方法不会有返回值，会直接在原来的 ArrayList 上进行修改。

在 Java 中对语言自带的类型进行排序

如果我们要对数组进行排序，仅仅调用 ArrayList.sort() 是不够的，我们还要告诉 Java 如何对 List 中的对象进行排序 - 这里我们就要引入 Comparator 的概念了。Comparator 对象是专门用来比较两个对象大小的。ArrayList 进行排序的时候会调用传入的 Comparator 对象进行排序。


import java.util.*;

public class compareExample {
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(8);
        arr.add(3);
        arr.add(5);
        arr.sort(Comparator.naturalOrder());
        System.out.println(arr);    // Output: [1, 3, 5, 8]
        arr.sort(Comparator.reverseOrder());
        System.out.println(arr);    // Output: [8, 5, 3, 1]
    }
}

在上面这段代码中，我们向 arr 传入了 Comparator.naturalOrder() 这样一个对象。如同它的名字所描述的，这个比较器的作用就是将Array中的内容按照“自然顺序”排列 - 也就是从小到大的顺序。类似naturalOrder，java.util.Comparator 中还有其他的比较器，例如 reverseOrder （将List中的元素从大到小的排序）等。

如果你想排序的 ArrayList 中存放的元素是 Java 已给出的数据类型，那么对它们进行排序就只需要上面这一步就好了。然而，如果你想对自己声明的类型进行排序，我们还需要做一些额外的工作……

在 Java 中对自己定义的类进行排序

如果你想对自己定义的类进行排序，那么有以下两种方法实现：

在自己的类中实现 Java 定义的 Comparable 接口
自己为自己的类实现一个 Comparator 类型，并将这个 Comparator 传到 arr.sort() 中。

下面，假设我们要对这样一个 Java 类进行排序：


class Person{
    public int age;
    public String name;

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public String toString(){
        return "( age: " + this.age + ", name: " + this.name + " )";
    }
}

实现 Comparable 接口（推荐）

通过实现 Comparable 接口，Java会识别到这个类是“可比较的”。在调用 ArrayList.sort()的时候，Comparator会调用你的类中的 compareTo方法来判断两个对象之间的大小关系。


public int compareTo(object other){
    /*
        If this object is bigger than the "other" given in the parameter, return a positive integer.
        if this object is smaller than the "other" given in parameter, return a negative integer.
        Otherwise, return 0.
    */
}

具体的写法如下：


class Person implements Comparable<Person>{
    public int age;
    public String name;

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public int compareTo(Person other){
        if (this.equals(other)){ return 0; }
        if (this.age != other.age){ return this.age - other.age; }
        else{ return this.name.compareTo(other.name); }
    }

    public boolean equals(Person other){
        return this.age == other.age && this.name.equals(other.name);
    }

    public String toString(){
        return "( age: " + this.age + ", name: " + this.name + " )";
    }
}

如果你在自己的Java类上实现了Comparable 接口，那么在数组排序时所有 java.util.Comparator 中的比较器都可以直接传入给 ArrayList。


import java.util.*;

public class compareTest{
    public static void main(String[] args) {
        ArrayList<Person> arr = new ArrayList<>();
        arr.add(new Person(17, "Mark"));
        arr.add(new Person(14, "Test"));
        arr.add(new Person(18, "wyn"));
        arr.sort(Comparator.naturalOrder());
        System.out.println(arr);
    }
}

运行结果：

[( age: 14, name: Test ), ( age: 17, name: Mark ), ( age: 18, name: wyn )]

实现 Comparator 类型（不推荐）

除了直接实现Comparable接口以外，我们还可以直接定义一个可以比较两个自己类型对象的比较器（Comparator）来达到对存储这个类型对象的数组进行排序的目的。这种情况下，我们要新建一个比较器类型来实现 Comparator 抽象类。Comparator 抽象类只有一个函数 - compare。所以如果我们想实现一个效果和上文的方案相同的比较器，我们可以这样写：


class PersonComparator implements Comparator<Person>{
    public int compare(Person o1, Person o2){
        if (o1 == o2){ return 0; }
        if (o1.age != o2.age) { return o1.age - o2.age; }
        else{ return o1.name.compareTo(o2.name); }
    }
}

这种情况下，我们要对Person类进行排序就需要将自己定义的比较器传入ArrayList.sort()中来进行排序。


import java.util.*;

public class compareTest{
    public static void main(String[] args) {
        ArrayList<Person> arr = new ArrayList<>();
        arr.add(new Person(17, "Mark"));
        arr.add(new Person(14, "Test"));
        arr.add(new Person(18, "wyn"));
        arr.sort(new PersonComparator());
        System.out.println(arr);
    }
}

输出结果如下：

[( age: 14, name: Test ), ( age: 17, name: Mark ), ( age: 18, name: wyn )]

Python 对元组和内置数据类型的排序

对于 Python 来说，数组的排序会变得简单很多：在Python中，你可以随意创建含有多个不同类型元素的数据对象 - Tuple (元组）。Python在比较元组大小时会先比较第0位大小，如果大小相同比较第1位……依此类推，直到找到最后一位或者大小不同的一位为止。

例子：


arr = [(1, "test"), (10, "ebc"), (10, "abc"), (3, "wasd")]
arr.sort()

结果：

[(1, 'test'), (3, 'wasd'), (10, 'abc'), (10, 'ebc')]

Python 对自己写的类进行排序

如果你试着直接对一个装有自己写的类的对象进行排序，Python会丢出这样的报错：

Traceback (most recent call last):
  File "d:\Python_Files\prime\compareV1.py", line 8, in <module>
    ...
TypeError: '>' not supported between instances of 'Person' and 'Person'

这是因为我们没有规定如何比较两个 Person 对象之间的大小关系。和Java类似，在Python中也有两种方法对自己写的类进行排序。

为自己的类实现 __gt__, __lt__, __eq__ 等方法使类的对象之间支持比较大小
在 arr.sort 时手动写入一个Comparator函数用来比较两个对象的大小关系，以 keyword arguement 形式将这个函数传入sort方法。

假设我们要对装有这样一个类的对象的数组进行排序……


class Person:
    def __init__(self, age, name):
        self.age = age
        self.name = name
        
    def __repr__(self):
        return "(age: {}, name: {})".format(self.age, self.name)

实现Python内置的，用于比较大小的方法

这种方法和 Java 中为自己的类实现 Comparable 接口非常相似，唯一的不同是没有显式的表明自己实现了Comparable接口/功能。 Python 中一共有五个内置的，用于比较对象之间大小关系的函数：__gt__, __lt__, __eq__, __ge__, __le__，分别对应大于，小于，相等，大于等于和小于等于的判断。这里我们只需要实现前三个函数就好了。这三个函数返回一个布尔值，表明自己和传入的对象之间的关系是否是函数名所描述的关系。


class Person:
    def __init__(self, age, name):
        self.age = age
        self.name = 
    
    def __repr__(self):
        return "(age: {}, name: {})".format(self.age, self.name)
    
    def __lt__(self, otherPerson):
        if self.age != otherPerson.age: return self.age < otherPerson.age
        else: return self.name < otherPerson.name
    
    def __gt__(self, otherPerson):
        if self.age != otherPerson.age: return self.age > otherPerson.age
        else: return self.name > otherPerson.name
    
    def __eq__(self, otherPerson):
        return self.age == otherPerson.age and self.name == otherPerson.name

效果：


arr = [Person(23, "test1"), Person(17, "John"), Person(19, "Penny"), Person(21, "Mary"), Person(23, "test2")]
arr.sort()
print(arr)

[(age: 17, name: John), (age: 19, name: Penny), (age: 21, name: Mary), (age: 23, name: test1), (age: 23, name: test2)]

向 `List.sort()`传入比较方法

在我们调用sort方法时，有一个隐藏的 keyword arguement 是 key = function。这里的 function 是一个函数。如果这个参数被传递进了 sort 方法，那么在sort在比较大小时，Python会先将list中的对象传入 function，然后根据函数返回值进行排序。例如我们只想通过 Person 的 age 属性对 Person 对象进行排序，那么我们可以用这样一个 lambda 函数作为 key 传入 sort 方法。（注意：这时候即使 Person 没有实现 __lt__, __gt__, __eq__ 方法也可以进行排序。）


arr = [Person(23, "test1"), Person(17, "John"), Person(19, "Penny"), Person(21, "Mary"), Person(23, "test2")]
arr.sort(key= lambda personObj: personObj.age)
print(arr)

当然，如果 key 所对应的函数逻辑较为复杂，也可以在外面定义完以后再传入key参数。


def convertPerson(personObj):
    # convert a person object into a comparable object
    return str(personObj.age) + personObj.name

arr = [Person(23, "test1"), Person(17, "John"), Person(19, "Penny"), Person(21, "Mary"), Person(23, "test2")]
arr.sort(key = convertPerson)
print(arr)

GZFLS Computer Science

CS188 Chapter 14 Probabilistic Reasoning

14.1 Representing Knowledge in an Uncertain Domain

14.2 The Semantics of Bayesian Networks

14.2.1 Representing the full joint distribution

How to construct Bayesian Networks

14.4 Exact Inference in Bayesian Networks

14.4.1 Inference by Enumeration

14.5 Approximate Inference in Bayesian Networks

14.5.1 Direct Sampling Methods

Prior Sample

Rejection Sampling

CS188 Ch13. Case Study - Recognize MNIST base on Naive Bayes

开始之前……

Using Naive Bayes’ Network to Recognize MNIST Handwriting Figures

What is MNIST?

Simplification on image: Binarization

Bayes Network on Image Recognition?

Classification on Test Set

二维前缀和 2D Prefix Sum

前提条件

应用场景

原理

实现

线段树 Segment Tree

前提条件

使用场景

数据结构

时间复杂度

Java实现

Helper Functions

Construct Segment Tree

Update Segment Tree

Query Interval Minimum

Click to see Java Full Code

问题练习

CS188 Chapter 6 Constraint Satisfaction Problems

6.1 Define Constraint Satisfaction Problems

6.2 Why we need CSP

6.3 Solving CSP

6.3.1 Types of Constraints in CSP

6.3.2 Constraint Propagation: Inference in CSP

Node Consistency

Arc Consistency

Path Consistency

$k$-Consistency

队列 Queue

前置条件

队列

编程实现

0 - 一个基于 list 的朴素实现

1 - 更加高效的队列（链表）

2 - 更加高效的队列（循环数组）

练习

Binary Index Tree (Fenwick Tree) 二叉索引树

前置技能

Traditional Approach 1

Traditional Approach 2

Why Traditional Approach Fail

Data Structure - BIT

Helper Function - Least Significant One

Construct BIT

Get Sum from BIT

Update BIT Tree

练习

更多

最小生成树 Min-Span Tree

最小生成树

伪代码

代码实现

题目

优先队列 Priority Queue

前置条件

优先队列

数据结构实现

代码实现

实际使用

Python - heapq 内置库

Java - java.util.PriorityQueue

代价统一搜索 Uniform Cost Search

0 - 一个基于 `list` 的朴素实现

实现 Comparable 接口（推荐）

实现 Comparator 类型（不推荐）

向 `List.sort()`传入比较方法