Data Structure

資料結構

keaucucal

Review

預習

1. 區間查詢

2. 前綴和

Range Sum

區間和

更快的寫法？

更快的寫法？

先計算從頭到每一個位置的加總

先計算從頭到每一個位置的加總

\Rightarrow 前綴和

\Rightarrow 前綴和

\text{sum}(l, r) = \text{sum}(0, r) - \text{sum}(0, a - 1)

\text{sum}(l, r) = \text{sum}(0, r) - \text{sum}(0, a - 1)

複雜度\ O(1)

複雜度\ O(1)

1

4

8

16

22

23

27

29

0

1

2

3

4

5

6

7

Range Sum

區間和

定義\ S(X)\ 為左上角到\ X\ 的加總

定義\ S(X)\ 為左上角到\ X\ 的加總

則灰色區域和為\ S(A) - S(B) - S(C) + S(D)

則灰色區域和為\ S(A) - S(B) - S(C) + S(D)

\text{2D 前綴和}

\text{2D 前綴和}

D

C

B

A

Range Sum

區間和

剛剛的前綴和是\ O(n)\ 修改\ O(1)\ 查詢

剛剛的前綴和是\ O(n)\ 修改\ O(1)\ 查詢

如果會修改很多次\Rightarrow 用差分

如果會修改很多次\Rightarrow 用差分

對於一次修改\ [l, r]\ 可以視為在\ l\ 加上該值並且\ r + 1\ 時再減去

對於一次修改\ [l, r]\ 可以視為在\ l\ 加上該值並且\ r + 1\ 時再減去

+3

-3

-3

最後再做一次前綴和就可以達成\ O(1)\ 修改\ O(n)\ 查詢單點值

最後再做一次前綴和就可以達成\ O(1)\ 修改\ O(n)\ 查詢單點值

0

0

0

3

3

3

3

0

0

1

2

3

4

5

6

7

0

6

0

3

0

-6

-6

0

-3

-3

0

1

2

3

4

5

6

7

+6

-6

-6

0

6

6

9

9

3

3

0

0

1

2

3

4

5

6

7

Minimum Queries

區間最小值

O(n \log n)\ 預處理\rightarrow 計算所有\ r - l + 1\ 為二的冪次的\ \text{min}(l, r)

O(n \log n)\ 預處理\rightarrow 計算所有\ r - l + 1\ 為二的冪次的\ \text{min}(l, r)

\text{min}(l, r) = \text{min}(\text{min}(l, l + k - 1), \text{min}(l + k, r))

\text{min}(l, r) = \text{min}(\text{min}(l, l + k - 1), \text{min}(l + k, r))

設\ k = (r - l + 1) / 2

設\ k = (r - l + 1) / 2

1

3

4

8

6

1

4

2

0

1

2

3

4

5

6

7

0

1

2

3

4

5

6

7

l

l

r

0

1

2

3

4

5

6

7

\text{min}(l, r)

\text{min}(l, r)

1

3

4

8

6

1

4

2

0

1

2

3

4

5

6

l

l

r

1

2

3

4

5

6

7

\text{min}(l, r)

\text{min}(l, r)

1

3

4

6

1

1

2

0

1

2

3

4

l

l

r

3

4

5

6

7

\text{min}(l, r)

\text{min}(l, r)

1

3

1

1

1

0

7

1

Minimum Queries

區間最小值

O(n \log n)\ 預處理完就可以\ O(1)\ 查詢了

O(n \log n)\ 預處理完就可以\ O(1)\ 查詢了

設\ k\ 為不超過\ r - l + 1\ 的最大二冪次

設\ k\ 為不超過\ r - l + 1\ 的最大二冪次

\Rightarrow \text{min}(l, r) = \text{min}\left(\text{min}(l, l + k - 1), \text{min}(r - k + 1, r)\right)

\Rightarrow \text{min}(l, r) = \text{min}\left(\text{min}(l, l + k - 1), \text{min}(r - k + 1, r)\right)

1

3

4

8

6

1

4

2

0

1

2

3

4

5

6

7

1

3

4

8

6

1

4

2

0

1

2

3

4

5

6

7

1

3

4

8

6

1

4

2

0

1

2

3

4

5

6

7

Implement

如果要求最大值就把它改成\ \text{max}\ 就好

如果要求最大值就把它改成\ \text{max}\ 就好

 vector<vector<int>> st(__lg(n) + 1, vector<int>(n));
for (int i = 0; i < n; i++) st[0][i] = arr[i];
for (int i = 1; i <= __lg(n); i++) {
	int len = 1 << (i - 1);
    for (int j = 0; j < n; j++) {
    	st[i][j] = min(st[i - 1][j], st[i - 1][j + len]);
    }
}

\text{Build}

\text{Build}

 int query(int l, int r) {
	int k = __lg(r - l + 1);
    return min(st[k][l], st[k][r - (1 << k) + 1]);
}

\text{Query}

\text{Query}

Range Sum

區間和

但如果要改值就需要\ O(n)\ 的時間重新建構整個陣列

但如果要改值就需要\ O(n)\ 的時間重新建構整個陣列

1

3

4

8

6

1

4

2

1

3

4

6

7

8

2

5

剛剛講過可以用前綴和

剛剛講過可以用前綴和

1

4

8

16

22

23

27

29

1

2

3

4

5

6

7

8

Binary Indexed Tree (BIT)

aka Fenwick Tree

設\ p(k)\ 為可以整除\ k\ 的最大二冪次

設\ p(k)\ 為可以整除\ k\ 的最大二冪次

使\ tree[k] = sum(k - p(k) + 1, k)

使\ tree[k] = sum(k - p(k) + 1, k)

1

3

4

8

6

1

4

2

雖然說樹但他其實只是個陣列

雖然說樹但他其實只是個陣列

1

2

3

4

5

6

7

8

1

4

4

16

6

7

4

29

就可以構成這個陣列

就可以構成這個陣列

1

2

3

4

5

6

7

8

Binary Indexed Tree (BIT)

把它畫成對應到原陣列的和

把它畫成對應到原陣列的和

1

4

4

16

6

7

4

29

1

2

3

4

5

6

7

8

1

3

4

8

6

1

4

2

Binary Indexed Tree (BIT)

查詢\ [1, 7]

查詢\ [1, 7]

\text{sum}(1, 7) = \text{sum}(1, 4) + \text{sum}(5, 6) + \text{sum}(7, 7) = 16 + 7 + 4 = 27

\text{sum}(1, 7) = \text{sum}(1, 4) + \text{sum}(5, 6) + \text{sum}(7, 7) = 16 + 7 + 4 = 27

查詢複雜度\ O(\log n)

查詢複雜度\ O(\log n)

1

4

4

16

6

7

4

29

1

2

3

4

5

6

7

8

Binary Indexed Tree (BIT)

改值也可以在\ O(\log n)\ 的時間內處理完

改值也可以在\ O(\log n)\ 的時間內處理完

改位置為\ 3\ 的值

改位置為\ 3\ 的值

1

4

4

16

6

7

4

29

1

2

3

4

5

6

7

8

Implement

首先要知道怎麼計算\ p(k)

首先要知道怎麼計算\ p(k)

就神奇的發現\ p(k) = lowbit(k)\ 了

就神奇的發現\ p(k) = lowbit(k)\ 了

問題就變成怎麼計算\ lowbit

問題就變成怎麼計算\ lowbit

設\ p(k)\ 為可以整除\ k\ 的最大二冪次\\ 使\ tree[k] = sum(k - p(k) + 1, k)

設\ p(k)\ 為可以整除\ k\ 的最大二冪次\\ 使\ tree[k] = sum(k - p(k) + 1, k)

6 = 00110_{2}

6 = 00110_{2}

k

p(k)

p(k)

2 = 00010_2

2 = 00010_2

7=00111_2

7=00111_2

1 = 00001_2

1 = 00001_2

12=01100_2

12=01100_2

4 = 00100_2

4 = 00100_2

Implement

繼續觀察

繼續觀察

很愉快的又發現了\ lowbit(k) = k \text{\&} -\!k

很愉快的又發現了\ lowbit(k) = k \text{\&} -\!k

6 = 00110_{2}

6 = 00110_{2}

k

-k

-k

2 = 00010_2

2 = 00010_2

7=00111_2

7=00111_2

1 = 00001_2

1 = 00001_2

12=01100_2

12=01100_2

4 = 00100_2

4 = 00100_2

lowbit(k)

lowbit(k)

-6 = 11010_{2}

-6 = 11010_{2}

-7 = 11001_{2}

-7 = 11001_{2}

-12 = 10100_{2}

-12 = 10100_{2}

Implement

 void add(int k, int x) {
	while (k <= n) {
    	tree[k] += x;
        k += k & -k;
    }
}

\text{Modify}

\text{Modify}

 int sum(int k) {
	int ret = 0; // return
    while (k) { // while k >= 1
    	ret += tree[k];
        k -= k & -k;
    }
    return ret;
}

\text{Query}

\text{Query}

要注意他是\ \text{1-based}\ 不然\ k = k \text{\&} -\!k\ 他不會變

要注意他是\ \text{1-based}\ 不然\ k = k \text{\&} -\!k\ 他不會變

Other Technique

如果操作改成差分

如果操作改成差分

達成\ O(\log n)\ 區間改值\ O(\log n)\ 單點查詢

達成\ O(\log n)\ 區間改值\ O(\log n)\ 單點查詢

剛剛講的是單點改值區間查詢

剛剛講的是單點改值區間查詢

\Rightarrow value(x) = sum(1, x)

\Rightarrow value(x) = sum(1, x)

1

4

4

16

6

7

4

29

1

2

3

4

5

6

7

8

Other Technique

當然也有區間改值區間查詢

當然也有區間改值區間查詢

講了單點改值區間查詢和區間改值單點查詢

講了單點改值區間查詢和區間改值單點查詢

設原數列\ A\ 以及差分陣列\ D，得出\ [1, x]\ 區間和為

設原數列\ A\ 以及差分陣列\ D，得出\ [1, x]\ 區間和為

\sum_{i=1}^{x} A_i= D_1 \times x + D_2 \times (x - 1) + \cdots + D_x \times 1= \sum_{i = 1}^{x}D_i \times (x - i + 1)

\sum_{i=1}^{x} A_i= D_1 \times x + D_2 \times (x - 1) + \cdots + D_x \times 1= \sum_{i = 1}^{x}D_i \times (x - i + 1)

拆開得到

拆開得到

(x + 1)(\sum_{i =1}^{x}D_i) - (\sum_{i=1}^{x}D_i \times i)

(x + 1)(\sum_{i =1}^{x}D_i) - (\sum_{i=1}^{x}D_i \times i)

開兩個\ \text{BIT}\ 一個維護\ D_i\ 一個維護\ D_i \times i

開兩個\ \text{BIT}\ 一個維護\ D_i\ 一個維護\ D_i \times i

\Rightarrow O(\log n)\ 區間修改\ O(\log n)\ 區間查詢

\Rightarrow O(\log n)\ 區間修改\ O(\log n)\ 區間查詢

Segment Tree

線段樹

能滿足大多區間操作和查詢的資料結構

能滿足大多區間操作和查詢的資料結構

除了寫起來麻煩沒有啥缺點了

除了寫起來麻煩沒有啥缺點了

以下為一顆求和的線段樹

以下為一顆求和的線段樹

每個節點對應到某個二的冪次的區間

每個節點對應到某個二的冪次的區間

39

22

17

5

8

6

3

2

7

2

6

13

9

9

8

arr

arr

Implement

看起來很簡單但要怎麼寫

看起來很簡單但要怎麼寫

把它重新編號

把它重新編號

肉眼可見\ tree[k] = tree[k \times 2] + tree[k \times 2 + 1]

肉眼可見\ tree[k] = tree[k \times 2] + tree[k \times 2 + 1]

39

22

17

5

8

6

3

2

7

2

6

13

9

9

8

8

9

10

11

12

13

14

15

1

2

3

4

5

6

7

Implement

tree[k]\ 還是等於\ tree[k \times 2] + tree[k \times 2 + 1]

tree[k]\ 還是等於\ tree[k \times 2] + tree[k \times 2 + 1]

算最小值的話\\ tree[k] = min(tree[k \times 2], tree[k \times 2 + 1])

算最小值的話\\ tree[k] = min(tree[k \times 2], tree[k \times 2 + 1])

5

8

6

3

2

7

2

6

8

9

10

11

12

13

14

15

塞到一維陣列裡面

塞到一維陣列裡面

39

22

17

13

9

9

8

1

2

3

4

5

6

7

Implement

39

22

17

5

8

6

3

2

7

2

6

13

9

9

8

看起來很簡單但要怎麼寫

看起來很簡單但要怎麼寫

8

9

10

11

12

13

14

15

1

2

3

4

5

6

7

求原陣列區間\ sum(1, 8)

求原陣列區間\ sum(1, 8)

l=9,\, r=15

l=9,\, r=15

l=5,\, r=7

l=5,\, r=7

l=3,\, r=3

l=3,\, r=3

8

9

17

=8 + 9 + 17 = 34

=8 + 9 + 17 = 34

複雜度\ O(\log n)

複雜度\ O(\log n)

Segment Tree

當前節點除以二就是父節點

當前節點除以二就是父節點

複雜度\ O(\log n)

複雜度\ O(\log n)

39

22

17

5

8

6

3

2

7

2

6

13

9

9

8

修改時要修改包含他的節點

修改時要修改包含他的節點

8

9

10

11

12

13

14

15

1

2

3

4

5

6

7

Implement

迭代式

迭代式

 void add(int k, int x) {
	k += n; // 先移到對應位置
    tree[k] += x;
    for (k /= 2; k > 0; k /= 2) {
    	tree[k] = tree[2 * k] + tree[2 * k + 1];
    }
}

\text{Modify}

\text{Modify}

 int sum(int l, int r) {
	l += n, r += n;
    int ret = 0;
    while (l <= r) {
    	// 如果父節點會超出範圍就縮進來
    	if (l % 2 == 1) ret += tree[l++];
        if (r % 2 == 0) ret += tree[r--];
        l /= 2, r /= 2; // 移動到上一層
    }
    return ret;
}

\text{Query}

\text{Query}

Implement

遞迴式

遞迴式

 struct segmentTree {
	int n;
    segmentTree(vector<int> data) : n(data.size()) {
    	data.resize(n * 4);
        build(1, 1, n, data);
    }
    
    void build(int id, int l, int r, vector<int> data) {
    	if (l == r) {
        	tree[id] = data[l];
            return;
        }
        int mid = (l + r) / 2;
        build(id * 2, l, mid, data);
        build(id * 2 + 1, mid + 1, r, data);
        tree[id] = tree[id * 2] + tree[id * 2 + 1];
    }
    
    void add(int id, int k, int x, int l, int r) {
        if (l == r) {
            tree[id] += x;
            return;
        }
        int mid = (l + r) / 2;
        if (k <= mid) modify(id * 2, k, x, l, mid);
        else modify(id * 2 + 1, k, x, mid + 1, r);
        tree[id] = tree[id * 2] + tree[id * 2 + 1];
	}
    
    int sum(int id, int l, int r, int L, int R) {
    	if (l <= L && R <= r) {
        	return tree[id];
        }
        int mid = (l + r) / 2;
        int ret = 0;
    	if (L <= mid) ret += query(id * 2, l, mid, L, R);
		if (R > mid) ret += query(id * 2 + 1, mid + 1, r, L, R);
		return ret;
    }
};

大小要開\ n \times 4

大小要開\ n \times 4

Data Structure 資料結構 keaucucal

Data Structure

INDEX

Review

Sparse Table

Binary Indexed Tree

Segment Tree

掰掰

	vector<vector<int>> st(__lg(n) + 1, vector<int>(n));
	for (int i = 0; i < n; i++) st[0][i] = arr[i];
	for (int i = 1; i <= __lg(n); i++) {
	int len = 1 << (i - 1);
	for (int j = 0; j < n; j++) {
	st[i][j] = min(st[i - 1][j], st[i - 1][j + len]);
	}
	}

	int query(int l, int r) {
	int k = __lg(r - l + 1);
	return min(st[k][l], st[k][r - (1 << k) + 1]);
	}

	void add(int k, int x) {
	while (k <= n) {
	tree[k] += x;
	k += k & -k;
	}
	}

	int sum(int k) {
	int ret = 0; // return
	while (k) { // while k >= 1
	ret += tree[k];
	k -= k & -k;
	}
	return ret;
	}

	void add(int k, int x) {
	k += n; // 先移到對應位置
	tree[k] += x;
	for (k /= 2; k > 0; k /= 2) {
	tree[k] = tree[2 * k] + tree[2 * k + 1];
	}
	}

	int sum(int l, int r) {
	l += n, r += n;
	int ret = 0;
	while (l <= r) {
	// 如果父節點會超出範圍就縮進來
	if (l % 2 == 1) ret += tree[l++];
	if (r % 2 == 0) ret += tree[r--];
	l /= 2, r /= 2; // 移動到上一層
	}
	return ret;
	}

	struct segmentTree {
	int n;
	segmentTree(vector<int> data) : n(data.size()) {
	data.resize(n * 4);
	build(1, 1, n, data);
	}

	void build(int id, int l, int r, vector<int> data) {
	if (l == r) {
	tree[id] = data[l];
	return;
	}
	int mid = (l + r) / 2;
	build(id * 2, l, mid, data);
	build(id * 2 + 1, mid + 1, r, data);
	tree[id] = tree[id * 2] + tree[id * 2 + 1];
	}

	void add(int id, int k, int x, int l, int r) {
	if (l == r) {
	tree[id] += x;
	return;
	}
	int mid = (l + r) / 2;
	if (k <= mid) modify(id * 2, k, x, l, mid);
	else modify(id * 2 + 1, k, x, mid + 1, r);
	tree[id] = tree[id * 2] + tree[id * 2 + 1];
	}

	int sum(int id, int l, int r, int L, int R) {
	if (l <= L && R <= r) {
	return tree[id];
	}
	int mid = (l + r) / 2;
	int ret = 0;
	if (L <= mid) ret += query(id * 2, l, mid, L, R);
	if (R > mid) ret += query(id * 2 + 1, mid + 1, r, L, R);
	return ret;
	}
	};