learn segment tree

README.md

@@ -76,12 +76,24 @@ ll ksm(ll a,ll b,ll M){
 ## Day6
 [CSP-S1 模拟赛.pdf](./day6/CSP-S1%20模拟赛.pdf)
 >??:4.13.14.20.21
-## T9
+### T9
 1. 先与后或先&后|
+### 快速幂学习笔记
+[cpp模板](./day6/binaryExponentiation/binaryExponentiation.cpp)
+
 
 ## Day7
 ### 离线算法和在线算法
 >有预处理和没有预处理的区别
+### 逆元：学习笔记
+[markdown](./day7/inverse/inverse_by_chat.md)
+[pdf](./day7/inverse/inverse_by_chat.pdf)
+### 线段树：学习笔记
+[mardown](./day7/SegmentTree/SegmentTree.md)
+[pdf](./day7/SegmentTree/SegmentTree.pdf)
+### 待学：
+>扫描线
+>矩阵乘法
 
 # 排序
 ## 稳定性

day7/SegmentTree/1.in

@@ -0,0 +1,6 @@
+5
+10 11 12 13 14
+3
+1 2
+2 3
+1 5

day7/SegmentTree/1.out

@@ -0,0 +1,3 @@
+21
+23
+60

day7/SegmentTree/SegmentTree.cpp

@@ -1,8 +0,0 @@
-#include<bits/stdc++.h>
-using namespace std;
-
-
-
-int main(){
-    
-}

day7/SegmentTree/SegmentTree.cpp.old

@@ -0,0 +1,68 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+// #define ASSERTM(c,m){if(!(c)){cerr<<"assert failed :"<<#c<<" "<<m<<endl;return -1;}}
+#define ASSERT(c){if(!(c)){cerr<<"assert failed :"<<#c<<endl;return -1;}}
+// #define PRINT_VALUE(v){cout<<#v<<" :"<<(v)<<endl;}
+#define PRINT_VALUE(v){(v);}
+
+const int MAX_N = 1e4+5;
+const int LEN = 4*MAX_N;
+int tree[LEN];
+
+void build(int t[],int a[],int s,int e,int n){
+    if(s==e){
+        // PRINT_VALUE(n)
+        t[n]=a[s];
+        return;
+    }
+    int m=s+((e-s)>>1);
+    build(t,a,s,m,n*2);
+    build(t,a,m+1,e,n*2+1);
+    t[n]=t[n*2]+t[n*2+1];
+}
+
+int query(int t[],int s,int e,int n,int l,int r){
+    if(l<=s&&e<=r){
+        return t[n];
+    }
+    if(e<l||r<s){
+        return 0;
+    }
+    int m=s+((e-s)>>1),sum=0;
+    sum+=query(t, s, m, n*2, l, r);
+    sum+=query(t, m+1, e, n*2+1, l, r);
+    return sum;
+}
+
+int main(int argc,char *argv[]){
+    ASSERT(argc==3);
+    ifstream ifile(argv[1]);
+    ifstream afile(argv[2]);
+    ASSERT(ifile.is_open()==true)
+    ASSERT(afile.is_open()==true)
+    int n;
+    ifile>>n;
+    int a[n+1];
+    int t[n*4+1];
+    for(int i=1;i<=n;i++){
+        ifile>>a[i];
+    }
+    build(t,a,1,n,1);
+    // for(int i=1;i<=n*4;i++){
+    //     PRINT_VALUE(i);
+    //     PRINT_VALUE(t[i]);
+    // }
+    int m;
+    ifile>>m;
+    for(int i=1;i<=m;i++){
+        int cans;
+        afile>>cans;
+        int a,b;
+        ifile>>a>>b;
+        int myans;
+        // myans=query(t,1,n,1,a,b);
+        PRINT_VALUE((myans=query(t,1,n,1,a,b),myans));
+        ASSERT(cans==myans)
+    }
+}

day7/SegmentTree/SegmentTree.md

@@ -303,3 +303,217 @@ int main() {
 - 继续递归，`idx = 3` 可能表示 `[0, 1]`，`idx = 4` 表示 `[2, 2]` 等等。
 
 因此，`idx` 就是线段树中节点的唯一标识符，通过它可以在 `tree` 数组中找到相应节点的位置。
+
+为了更详细地解释如何构建线段树，我将使用从1开始的数组编号，并逐行解释代码的每一步。假设我们有一个数组 `arr = {2, 5, 1, 4, 9, 3}`，它的索引从1开始。
+
+### 线段树的构建
+
+我们将重点放在 `buildTree` 函数上，这个函数的作用是递归地构建线段树。下面是该函数的代码，以及每行代码的详细解释。
+
+```cpp
+void buildTree(const vector<int>& arr, int start, int end, int idx) {
+    if (start == end) {
+        tree[idx] = arr[start];
+    } else {
+        int mid = start + (end - start) / 2;
+        buildTree(arr, start, mid, 2 * idx + 1);
+        buildTree(arr, mid + 1, end, 2 * idx + 2);
+        tree[idx] = min(tree[2 * idx + 1], tree[2 * idx + 2]);
+    }
+}
+```
+
+### 参数说明
+
+- `arr`：原始数组，包含要构建线段树的数据。
+- `start`：当前处理的区间的起始索引（从1开始）。
+- `end`：当前处理的区间的结束索引（从1开始）。
+- `idx`：当前节点在线段树数组 `tree` 中的位置。
+
+### 例子
+
+假设我们有数组 `arr = {2, 5, 1, 4, 9, 3}`，我们将构建一个线段树来处理区间最小值查询。
+
+1. **初始调用**：`buildTree(arr, 1, 6, 0)` 对应处理区间 `[1, 6]`，即整个数组。
+   
+   这意味着根节点 `idx = 0` 管理整个数组 `[1, 6]` 的最小值。
+
+2. **叶子节点处理**：
+   ```cpp
+   if (start == end) {
+       tree[idx] = arr[start];
+   }
+   ```
+   - 如果 `start` 和 `end` 相等，表示当前区间只有一个元素，这是一个叶子节点。
+   - 直接将该元素存入 `tree` 数组的 `idx` 位置。
+
+   **示例**：当 `start = 3`，`end = 3` 时，调用 `buildTree(arr, 3, 3, 4)`，此时 `idx = 4`，这意味着我们处理的是区间 `[3, 3]`，即数组 `arr[3]`。我们将 `tree[4]` 设置为 `arr[3]` 的值 `1`。
+
+3. **递归构建左子树和右子树**：
+   ```cpp
+   int mid = start + (end - start) / 2;
+   buildTree(arr, start, mid, 2 * idx + 1);
+   buildTree(arr, mid + 1, end, 2 * idx + 2);
+   ```
+   - 我们首先计算当前区间的中点 `mid`，将区间分成左右两部分。
+   - `mid` 的计算方式是 `mid = start + (end - start) / 2`。例如，对于 `[1, 6]`，`mid = 1 + (6 - 1) / 2 = 3`，所以区间分为 `[1, 3]` 和 `[4, 6]`。
+   - 递归调用 `buildTree` 函数来构建左子树和右子树。
+   - 左子树的索引为 `2 * idx + 1`，右子树的索引为 `2 * idx + 2`。
+
+   **示例**：对于根节点（`idx = 0`），区间 `[1, 6]` 被分为 `[1, 3]` 和 `[4, 6]`，接着递归构建左子树 `buildTree(arr, 1, 3, 1)` 和右子树 `buildTree(arr, 4, 6, 2)`。
+
+4. **合并结果**：
+   ```cpp
+   tree[idx] = min(tree[2 * idx + 1], tree[2 * idx + 2]);
+   ```
+   - 当左子树和右子树构建完成后，将它们的最小值合并为当前节点的值。
+   - `tree[idx]` 保存的是左右子树中最小的值。
+
+   **示例**：假设 `buildTree(arr, 1, 3, 1)` 处理区间 `[1, 3]` 返回的左子树最小值为 `1`，`buildTree(arr, 4, 6, 2)` 处理区间 `[4, 6]` 返回的右子树最小值为 `3`，那么根节点 `tree[0]` 将被设为 `min(1, 3) = 1`。
+
+### 完整树的结构
+
+通过递归调用，最终我们将得到一棵线段树。假设 `arr = {2, 5, 1, 4, 9, 3}`，用1开始的索引来表示：
+
+- 根节点 `tree[0]` 管理整个数组 `[1, 6]`，存储最小值 `1`。
+- 左子树 `tree[1]` 管理 `[1, 3]`，存储最小值 `1`。
+- 右子树 `tree[2]` 管理 `[4, 6]`，存储最小值 `3`。
+
+逐渐递归下去，直到所有叶子节点都填满为止。
+
+### 总结
+
+每个节点的 `idx` 表示线段树中节点在数组 `tree` 中的位置。通过递归分治法，我们将整个区间分成若干子区间，逐步构建线段树的每个节点。最终，树的根节点（`tree[0]`）存储了整个数组的最小值，树的其他节点存储了各自子区间的最小值。
+
+在线段树中，搜索过程通常指的是查询某个区间内的最小值、最大值或其他聚合信息。为了更好地理解搜索过程，我们将详细讲解如何使用线段树来查询一个给定区间内的最小值，并通过逐步解析代码的方式说明每一步的具体操作。
+
+### 问题描述
+
+假设我们有一个从1开始编号的数组 `arr = {2, 5, 1, 4, 9, 3}`，我们希望使用线段树来查询任意给定区间 `[l, r]` 内的最小值。
+
+### 查询函数：`queryMin`
+
+我们使用如下函数来查询区间 `[l, r]` 内的最小值：
+
+```cpp
+int queryMin(int start, int end, int l, int r, int idx) {
+    if (l <= start && r >= end) {
+        return tree[idx];
+    }
+    if (end < l || start > r) {
+        return INT_MAX;
+    }
+    int mid = start + (end - start) / 2;
+    return min(queryMin(start, mid, l, r, 2 * idx + 1),
+               queryMin(mid + 1, end, l, r, 2 * idx + 2));
+}
+```
+
+### 参数说明
+
+- `start`：当前节点管理的区间起始索引。
+- `end`：当前节点管理的区间结束索引。
+- `l` 和 `r`：查询的目标区间 `[l, r]`。
+- `idx`：当前节点在 `tree` 数组中的位置。
+
+### 查询过程的详细解释
+
+假设我们要查询区间 `[2, 5]` 的最小值，初始调用 `queryMin(1, 6, 2, 5, 0)`，即从根节点开始搜索。
+
+1. **判断当前区间是否完全覆盖查询区间**：
+   ```cpp
+   if (l <= start && r >= end) {
+       return tree[idx];
+   }
+   ```
+   - 如果当前节点管理的区间 `[start, end]` 完全包含在查询区间 `[l, r]` 内（即 `l <= start` 且 `r >= end`），那么当前节点存储的值就是该区间的最小值，直接返回 `tree[idx]`。
+
+   **示例**：如果我们查询区间 `[2, 5]`，而当前节点管理的是 `[4, 6]`，此时 `start = 4, end = 6, l = 2, r = 5`，不完全覆盖，所以不返回。
+
+2. **判断当前区间与查询区间是否没有交集**：
+   ```cpp
+   if (end < l || start > r) {
+       return INT_MAX;
+   }
+   ```
+   - 如果当前区间与查询区间没有任何交集（即 `end < l` 或 `start > r`），这意味着当前节点不需要参与最小值的计算，返回一个极大值 `INT_MAX`（表示无效值）。
+
+   **示例**：如果当前节点管理的区间 `[1, 1]`，此时 `start = 1, end = 1, l = 2, r = 5`，显然没有交集，返回 `INT_MAX`。
+
+3. **部分覆盖：递归查询左右子区间**：
+   ```cpp
+   int mid = start + (end - start) / 2;
+   return min(queryMin(start, mid, l, r, 2 * idx + 1),
+              queryMin(mid + 1, end, l, r, 2 * idx + 2));
+   ```
+   - 如果当前区间 `[start, end]` 和查询区间 `[l, r]` 部分重叠，继续递归查询左右子树。
+   - 首先计算当前区间的中点 `mid`，将当前区间 `[start, end]` 分为 `[start, mid]` 和 `[mid + 1, end]` 两个子区间。
+   - 递归查询左子树和右子树的最小值，然后返回这两个子区间的最小值作为结果。
+
+   **示例**：查询区间 `[2, 5]`，当前节点管理区间 `[1, 6]`，将其分为 `[1, 3]` 和 `[4, 6]`，然后递归查询左右子区间，最后返回两个子区间的最小值。
+
+### 完整查询过程示例
+
+假设我们要查询 `arr` 中 `[2, 5]` 的最小值，调用 `queryMin(1, 6, 2, 5, 0)`。以下是递归查询的详细步骤：
+
+1. **根节点**：
+   - `start = 1, end = 6, l = 2, r = 5, idx = 0`。
+   - 当前区间 `[1, 6]` 与查询区间 `[2, 5]` 部分重叠，继续递归查询。
+   - 计算 `mid = 1 + (6 - 1) / 2 = 3`。
+   - 查询左子树 `[1, 3]` 和右子树 `[4, 6]`。
+
+2. **左子树 `[1, 3]`**：
+   - `start = 1, end = 3, l = 2, r = 5, idx = 1`。
+   - 当前区间 `[1, 3]` 与查询区间 `[2, 5]` 部分重叠，继续递归查询。
+   - 计算 `mid = 1 + (3 - 1) / 2 = 2`。
+   - 查询左子树 `[1, 2]` 和右子树 `[3, 3]`。
+
+3. **左子树的左子树 `[1, 2]`**：
+   - `start = 1, end = 2, l = 2, r = 5, idx = 3`。
+   - 当前区间 `[1, 2]` 与查询区间 `[2, 5]` 部分重叠，继续递归查询。
+   - 计算 `mid = 1 + (2 - 1) / 2 = 1`。
+   - 查询左子树 `[1, 1]` 和右子树 `[2, 2]`。
+
+4. **到达叶子节点 `[1, 1]`**：
+   - `start = 1, end = 1, l = 2, r = 5, idx = 7`。
+   - 当前区间 `[1, 1]` 与查询区间 `[2, 5]` 无交集，返回 `INT_MAX`。
+
+5. **叶子节点 `[2, 2]`**：
+   - `start = 2, end = 2, l = 2, r = 5, idx = 8`。
+   - 当前区间 `[2, 2]` 完全包含在查询区间 `[2, 5]` 内，返回 `tree[8] = 5`。
+
+6. **回到节点 `[1, 2]`**：
+   - 左子树返回 `INT_MAX`，右子树返回 `5`，取 `min(INT_MAX, 5) = 5`。
+
+7. **右子树 `[3, 3]`**：
+   - `start = 3, end = 3, l = 2, r = 5, idx = 4`。
+   - 当前区间 `[3, 3]` 完全包含在查询区间 `[2, 5]` 内，返回 `tree[4] = 1`。
+
+8. **回到节点 `[1, 3]`**：
+   - 左子树返回 `5`，右子树返回 `1`，取 `min(5, 1) = 1`。
+
+9. **右子树 `[4, 6]`**：
+   - `start = 4, end = 6, l = 2, r = 5, idx = 2`。
+   - 当前区间 `[4, 6]` 与查询区间 `[2, 5]` 部分重叠，继续递归查询。
+   - 计算 `mid = 4 + (6 - 4) / 2 = 5`。
+   - 查询左子树 `[4, 5]` 和右子树 `[6, 6]`。
+
+10. **左子树 `[4, 5]`**：
+    - `start = 4, end = 5, l = 2, r = 5, idx = 5`。
+    - 当前区间 `[4, 5]` 完全包含在查询区间 `[2, 5]` 内，返回 `tree[5] = 4`。
+
+11. **右子树 `[6, 6]`**：
+    - `start = 6, end = 6, l = 2, r = 5, idx = 6`。
+    - 当前区间 `[6, 6]` 与
+
+查询区间 `[2, 5]` 无交集，返回 `INT_MAX`。
+
+12. **回到节点 `[4, 6]`**：
+    - 左子树返回 `4`，右子树返回 `INT_MAX`，取 `min(4, INT_MAX) = 4`。
+
+13. **回到根节点 `[1, 6]`**：
+    - 左子树返回 `1`，右子树返回 `4`，最终结果为 `min(1, 4) = 1`。
+
+### 总结
+
+通过递归地将查询区间 `[l, r]` 与线段树节点管理的区间 `[start, end]` 比较，我们可以有效地找到查询区间内的最小值。这个过程利用了线段树的分治思想和区间重叠的特性，确保每次查询的时间复杂度为 `O(log n)`。

xmake.lua

@@ -59,4 +59,8 @@ target("P5431")
 target("segtree")
     set_rundir("./day7/SegmentTree")
     add_files("./day7/SegmentTree/*.cpp")
+    for v=1,1 do 
+        local s=tostring(v)
+        add_tests(s,{files="./day7/SegmentTree/*.cpp",runargs={s..".in",s..".out"},defines="OITEST"})
+    end