Fix test for typical_segment_tree_min; fix iterator issue of typical_segment_tree; add find_first_right method for typical_segment_tree

Author: Mr-Python-in-China

.vscode/launch.json

@@ -9,9 +9,38 @@
       "name": "Run Extension",
       "type": "extensionHost",
       "request": "launch",
-      "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
-      "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}"
+      ],
+      "outFiles": [
+        "${workspaceFolder}/dist/**/*.js"
+      ],
       "preLaunchTask": "${defaultBuildTask}"
-    }
+    },
+    {
+      "name": "(gdb) 启动",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${fileDirname}/${fileBasenameNoExtension}.exe",
+      "args": [],
+      "stopAtEntry": false,
+      "cwd": "${fileDirname}",
+      "environment": [],
+      "externalConsole": false,
+      "MIMode": "gdb",
+      "preLaunchTask": "C/C++: g++ 生成活动文件",
+      "setupCommands": [
+        {
+          "description": "为 gdb 启用整齐打印",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        },
+        {
+          "description": "将反汇编风格设置为 Intel",
+          "text": "-gdb-set disassembly-flavor intel",
+          "ignoreFailures": true
+        },
+      ]
+    },
   ]
-}
+}

.vscode/tasks.json

@@ -16,6 +16,38 @@
         "kind": "build",
         "isDefault": true
       }
+    },
+    {
+      "type": "cppbuild",
+      "label": "C/C++: g++ 生成活动文件",
+      "command": "g++-9",
+      "args": [
+        "-fdiagnostics-color=always",
+        "-g",
+        "${file}",
+        "-o",
+        "${fileDirname}/${fileBasenameNoExtension}.exe",
+        "-I${workspaceFolder}/library/",
+        "-Ddebug",
+        "-std=c++14",
+        "-Wall",
+        "-Wextra",
+        "-pedantic",
+        "-Wshadow",
+        "-Wno-unused-parameter",
+        "-D_GLIBCXX_DEBUG",
+        "-D_GLIBCXX_DEBUG_PEDANTIC"
+      ],
+      "options": {
+        "cwd": "${fileDirname}"
+      },
+      "problemMatcher": [
+        "$gcc"
+      ],
+      "group": {
+        "kind": "build"
+      },
+      "detail": "调试器生成的任务。"
     }
   ]
 }

library/mrpython/sparse_table.hpp

@@ -29,10 +29,10 @@ template <typename T, typename MergeFunction> class sparse_table {
     size_t n = table[0].size();
     for (size_t i = 1; ((size_t)1 << i) <= n; ++i) {
       table.emplace_back();
-      table[i].reserve(n - (1 << i) + 1);
-      for (size_t j = 0; j < n - (1 << i) + 1; ++j)
+      table[i].reserve(n - ((size_t)1 << i) + 1);
+      for (size_t j = 0; j < n - ((size_t)1 << i) + 1; ++j)
         table[i].emplace_back(
-            merge(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]));
+            merge(table[i - 1][j], table[i - 1][j + ((size_t)1 << (i - 1))]));
     }
     table.shrink_to_fit();
   }

library/mrpython/typical_segment_tree.hpp

@@ -1,3 +1,5 @@
+#include <cstddef>
+
 #include "mrpython/bits.hpp"
 #include "mrpython/utility.hpp"
 
@@ -56,6 +58,18 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
     else
       __builtin_unreachable();
   }
+  size_t data_id_to_node_id(size_t x) {
+    x += n - ((2 * n - 1) - (highbit(2 * n - 1) - 1));
+    if (x >= n) x -= n;
+    x += n - 1;
+    return x;
+  }
+  size_t node_id_to_data_id(size_t x) {
+    x -= n - 1;
+    x += ((2 * n - 1) - (highbit(2 * n - 1) - 1));
+    if (x >= n) x -= n;
+    return x;
+  }
 
  public:
   template <typename InputIterator>
@@ -65,8 +79,8 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
         size(data.size(), 1),
         n(data.size()),
         merge(mergeFun) {
-    rotate(data.begin(), data.begin() + (2 * n - 1) - (highbit(2 * n - 1) - 1),
-           data.end());
+    rotate(data.begin(),
+           data.begin() + ((2 * n - 1) - (highbit(2 * n - 1) - 1)), data.end());
     reverse(data.begin(), data.end());
     build();
   }
@@ -84,6 +98,28 @@ template <typename T, typename MergeFunction> class typical_segment_tree {
     set_impl(target, operate, 0);
   }
   T get(size_t l, size_t r) { return get_impl(l, r, 0); }
+  T getd(size_t l, size_t r, T const& e = {}) { return l == r ? e : get(l, r); }
+  template <typename Check>
+  size_t find_first_right(size_t l, Check const& check) {
+    l = data_id_to_node_id(l);
+    while (l % 2 == 1) l /= 2;
+    while (l < 2 * n - 1 && check(data[l])) l = l * 2 + 1;
+    if (l >= 2 * n - 1) return node_id_to_data_id(l / 2);
+    T v = data[l];
+    do {
+      ++l;
+      if (!(l & (l + 1))) return n;
+      while (l % 2 == 1) l /= 2;
+    } while (!check(data[l]));
+    while (l < n - 1) {
+      T vl = merge(v, data[l * 2 + 1]);
+      if (!check(vl))
+        l = l * 2 + 2, v = vl;
+      else
+        l = l * 2 + 1;
+    }
+    return node_id_to_data_id(l);
+  }
 };
 template <typename T>
 using typical_segment_tree_add = typical_segment_tree<T, std::plus<T>>;

library/test/typical_segment_tree/typical_segment_tree_min.cpp

@@ -10,7 +10,7 @@ TEST(typical_segment_tree, min) {
               q = std::uniform_int_distribution<std::size_t>{1, 5000}(gen);
   std::vector<int> a(n);
   std::uniform_int_distribution<int> val_dist(std::numeric_limits<int>::min(),
-                                              std::numeric_limits<int>::min());
+                                              std::numeric_limits<int>::max());
   std::uniform_int_distribution<std::size_t> size_dist(0, n - 1),
       operator_dist(0, 1);
   std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
@@ -19,7 +19,6 @@ TEST(typical_segment_tree, min) {
     if (operator_dist(gen)) {
       std::size_t l = size_dist(gen), r = size_dist(gen);
       if (l > r) std::swap(l, r);
-      assert(l < r + 1);
       int ans = *std::min_element(a.begin() + l, a.begin() + r + 1);
       EXPECT_EQ(tree.get(l, r + 1), ans);
     } else {
@@ -29,4 +28,24 @@ TEST(typical_segment_tree, min) {
       tree.set(target, [value](int) { return value; });
     }
   }
-}
+}
+
+TEST(typicaL_segment_tree, fist_first_right) {
+  std::mt19937_64 gen(std::random_device{}());
+  std::size_t n = std::uniform_int_distribution<std::size_t>{1, 5000}(gen),
+              q = std::uniform_int_distribution<std::size_t>{1, 5000}(gen);
+  std::vector<int> a(n);
+  std::uniform_int_distribution<int> val_dist(std::numeric_limits<int>::min(),
+                                              std::numeric_limits<int>::max());
+  std::uniform_int_distribution<std::size_t> size_dist(0, n - 1),
+      operator_dist(0, 1);
+  std::generate(a.begin(), a.end(), [&] { return val_dist(gen); });
+  mrpython::typical_segment_tree_min<int> tree(a.begin(), a.end());
+  while (q--) {
+    std::size_t l = size_dist(gen);
+    int tv = val_dist(gen);
+    auto check = [tv](int x) { return x <= tv; };
+    size_t ans = std::find_if(a.begin() + l, a.end(), check) - a.begin();
+    EXPECT_EQ(tree.find_first_right(l, check), ans);
+  }
+}