feat: upload

config.yml

@@ -461,6 +461,9 @@ notebook:
     - lis: 最长上升子序列
       code_ext: hpp
       test_ext: cpp
+    - lev_dis: Levenshtein 距离
+      code_ext: hpp
+      test_ext: cpp
     - hoverline: 悬线法
       code_ext: hpp
       test_ext: cpp
@@ -488,9 +491,15 @@ notebook:
     - simplex: 单纯形法
       code_ext: hpp
       test_ext: cpp
+    - knapsack_01: 01 背包
+      code_ext: hpp
+      test_ext: cpp
     - knapsack_mixed: 混合背包
       code_ext: hpp
       test_ext: cpp
+    - knapsack_mixed_huge: 混合背包(贪心)
+      code_ext: hpp
+      test_ext: cpp
     graph:
     - alist: 邻接表
       code_ext: hpp

notebook.bib

@@ -440,3 +440,22 @@ @article{karp1978characterization
   year      = {1978},
   publisher = {Elsevier}
 }
+
+@article{larmore1991line,
+  title     = {On-line dynamic programming with applications to the prediction of RNA secondary structure},
+  author    = {Larmore, Lawrence L and Schieber, Baruch},
+  journal   = {Journal of Algorithms},
+  volume    = {12},
+  number    = {3},
+  pages     = {490--515},
+  year      = {1991},
+  publisher = {Elsevier}
+}
+
+@inproceedings{aggarwal1986geometric,
+  title     = {Geometric applications of a matrix searching algorithm},
+  author    = {Aggarwal, Alok and Klawe, Maria and Moran, Shlomo and Shor, Peter and Wilber, Robert},
+  booktitle = {Proceedings of the second annual symposium on Computational geometry},
+  pages     = {285--292},
+  year      = {1986}
+}

src/code/ds/mono_stack.hpp

@@ -10,28 +10,15 @@ class mono_stack {
   static CEXP Comp compare{};
 
   vec<T> s;
-  template <bool use_bf = false>
-  CEXP auto find_(cT_(T) x) NE {
-    if CEXP (use_bf) {
-      auto it = s.rbegin();
-      while (it != s.rend() && compare(x, *it)) ++it;
-      return (--it).base();
-    } else return upper_bound(s, x, compare);
-  }
 
  public:
   CEXPE mono_stack() NE = default;
 
-  template <bool use_bf = false>
-  CEXP void pop_greater(cT_(T) x) NE { s.erase(find_<use_bf>(x), s.end()); }
-  CEXP void push_nocheck(cT_(T) x) NE { s.push_back(x); }
-  template <bool use_bf = false>
-  CEXP void push(cT_(T) x) NE { pop_greater<use_bf>(x), s.push_back(x); }
-  template <bool use_bf = false>
-  CEXP void insert(cT_(T) x) NE {
-    if (auto it = find_<use_bf>(x); it == s.end()) s.push_back(x);
-    else *it = x;
+  CEXP void pop_greater(cT_(T) x) NE {
+    while (!s.empty() && compare(x, s.back())) s.pop_back();
   }
+  CEXP void push_nocheck(cT_(T) x) NE { s.push_back(x); }
+  CEXP void push(cT_(T) x) NE { pop_greater(x), s.push_back(x); }
   CEXP T CR top() CNE { return s.back(); }
   CEXP u32 size() CNE { return (u32)s.size(); }
 };

src/code/opt/knapsack_01.hpp

@@ -0,0 +1,59 @@
+#ifndef TIFALIBS_OPT_KNAPSACK_01
+#define TIFALIBS_OPT_KNAPSACK_01
+
+#include "../util/traits.hpp"
+
+namespace tifa_libs::opt {
+
+//@param a a[i]={value, weight}
+//@param W max weight
+//@return max total value while total weight <= W
+template <int_c T>
+CEXP T knapsack_01(vecpt<T> CR a, T W) NE {
+  const T vs = [k = std::views::keys(a)] { return std::reduce(k.begin(), k.end(), T{}); }();
+  const T _1 = W, _2 = vs,
+          _3 = T(a.size() >= 128 ? -1_u64 : 1_u64 << ((a.size() + 1) / 2)),
+          _min = min({_1, _2, _3});
+  assert(0_isz <= (isz)_min && (usz)_min * a.size() < (usz)1e9);
+  if (_min == _1) {
+    vec<T> dp(W + 1);
+    for (auto [s, t] : a)
+      for (u32 j = u32(W - t); (i32)j >= 0; --j) dp[j + t] = max(dp[j + t], dp[j] + s);
+    return max(dp);
+  } else if (const T inf = to_uint_t<T>(-1) / 2 - 1; _min == _2) {
+    vec<T> dp(vs + 1, inf);
+    dp[0] = 0;
+    for (auto [s, t] : a)
+      for (u32 j = u32(vs - s); (i32)j >= 0; --j) dp[j + s] = min(dp[j + s], dp[j] + t);
+    T ans = 0;
+    flt_ (T, i, 0, T(vs + 1))
+      if (dp[i] <= W) ans = max(ans, i);
+    return ans;
+  } else {
+    auto f = [&](u32 l, u32 r) {
+      vecpt<T> res(1 << (r - l));
+      res[0] = {0, 0};
+      flt_ (u32, i, 0, r - l)
+        flt_ (u32, j, 0, 1 << i) {
+          auto&& [v, w] = a[l + i];
+          res[je + j] = {res[j].first + w, res[j].second + v};
+        }
+      sort(res);
+      flt_ (u32, i, 1, (u32)res.size()) res[i].second = max(res[i].second, res[i - 1].second);
+      return res;
+    };
+    auto l = f(0, (u32)a.size() / 2), r = f((u32)a.size() / 2, (u32)a.size());
+    reverse(l), r.emplace_back(inf, inf);
+    T ans = 0;
+    u32 id = -1_u32;
+    for (auto& [t, s] : l) {
+      while (t + r[id + 1].first <= W) ++id;
+      if (~id) ans = max(ans, s + r[id].second);
+    }
+    return ans;
+  }
+}
+
+}  // namespace tifa_libs::opt
+
+#endif

src/code/opt/knapsack_mixed_huge.hpp

@@ -0,0 +1,42 @@
+#ifndef TIFALIBS_OPT_KNAPSACK_MIXED_HUGE
+#define TIFALIBS_OPT_KNAPSACK_MIXED_HUGE
+
+#include "../util/traits.hpp"
+
+namespace tifa_libs::opt {
+
+//@param a a[i]={value, weight, count}
+//@param W max weight
+//@return max total value while total weight <= W
+template <int_c T>
+CEXP T knapsack_mixed_huge(vec<pt3<T>> a, T W) NE {
+  const u32 n = (u32)a.size();
+  assert(n < 500);
+  const u32 lim = [k = max(n, 50_u32)] { return k * k * k + 1; }();
+  vec<T> dp(lim + 1, to_uint_t<T>(-1) / 2 - 1);
+  dp[0] = 0;
+  for (auto& [v, w, num] : a) {
+    T have = min(num, (T)n);
+    num -= have;
+    for (T k = 1; k = min(have, k), have; have -= k, k <<= 1)
+      for (u32 j = lim - 1; (T)j >= v * k; --j) dp[j] = min(dp[j], dp[j - v * k] + w * k);
+  }
+  vecu id(n);
+  std::iota(id.begin(), id.end(), 0), sort(id, [&](auto x, auto y) { return a[x]._0 * a[y]._1 > a[y]._0 * a[x]._1; });
+  T ans = 0;
+  flt_ (u32, j, 0, lim + 1) {
+    if (W < dp[j]) continue;
+    T rest = W - dp[j], now = j;
+    for (auto i : id) {
+      auto [v, w, num] = a[i];
+      T div = min(num, rest / w);
+      rest -= div * w, now += div * v;
+    }
+    ans = max(ans, now);
+  }
+  return ans;
+}
+
+}  // namespace tifa_libs::opt
+
+#endif

src/code/opt/lev_dis.hpp

@@ -0,0 +1,22 @@
+#ifndef TIFALIBS_OPT_LEV_DIS
+#define TIFALIBS_OPT_LEV_DIS
+
+#include "../util/util.hpp"
+
+namespace tifa_libs::opt {
+
+//@return ans[i][j] = lev(a[0..i), b[0..j))
+template <common_range T>
+CEXP vvecu lev_dis(T CR a, T CR b) NE {
+  const u32 n = (u32)a.size(), m = (u32)b.size();
+  vvecu ans(n + 1, vecu(m + 1));
+  flt_ (u32, i, 0, n + 1) ans[i][0] = i;
+  flt_ (u32, i, 0, m + 1) ans[0][i] = i;
+  flt_ (u32, i, 1, n + 1)
+    flt_ (u32, j, 1, m + 1) ans[i][j] = min({ans[i - 1][j - 1] + !(a[i - 1] == b[j - 1]), ans[i][j - 1] + 1, ans[i - 1][j] + 1});
+  return ans;
+}
+
+}  // namespace tifa_libs::opt
+
+#endif

src/doc_md/opt/knapsack_01.md

@@ -0,0 +1,4 @@
+---
+title: knapsack_01
+documentation_of: //src/code/opt/knapsack_01.hpp
+---

src/doc_md/opt/knapsack_mixed_huge.md

@@ -0,0 +1,4 @@
+---
+title: knapsack_mixed_huge
+documentation_of: //src/code/opt/knapsack_mixed_huge.hpp
+---

src/doc_md/opt/lev_dis.md

@@ -0,0 +1,4 @@
+---
+title: lev_dis
+documentation_of: //src/code/opt/lev_dis.hpp
+---

src/doc_tex/opt/alpha_beta.tex

@@ -8,6 +8,4 @@
 
 最好 \(O\left(\sqrt{b^d}\right)\), 最坏 \(O\left(b^d\right)\), 其中 \(b\) 为结点的最大出度, \(d\) 为树的深度.
 
-\paragraph{参考文献}
-
-\cite{enwiki:1188156145}
+\paragraph{参考文献} \cite{enwiki:1188156145}

src/doc_tex/opt/knapsack_01.tex

@@ -0,0 +1 @@
+\paragraph{复杂度} \(O\left(N\min\left\{W , \sum_i v_i , 2^{\frac{N}{2}}\right\}\right)\)

src/doc_tex/opt/knapsack_mixed_huge.tex

@@ -0,0 +1 @@
+适用于物品个数和价值均较小 (\(\leq 50\)) 且总容量较大 (\(10^9\)) 的情况

src/doc_tex/opt/lev_dis.tex

@@ -0,0 +1,9 @@
+对两个序列 \(a\), \(b\), 其 Levenshtein 距离 \(\operatorname{lev}(a,b)\) 定义为通过对 \(a\) 进行 (插入, 删除, 修改) 单个元素使其变为 \(b\) 的最少操作次数. 令 \(a'\) 表示 \(a\) 删除第一个元素后的序列, 则
+
+\[
+    \operatorname{lev}(a,b)=\begin{cases}
+        \max\{|a|,|b|\},                                                                       & |a|=0 ~\text{or}~ |b|=0, \\
+        \operatorname{lev}(a',b'),                                                             & a_0=b_0,                 \\
+        1+\min\{\operatorname{lev}(a',b),\operatorname{lev}(a,b'),\operatorname{lev}(a',b')\}, & \text{otherwise}.
+    \end{cases}
+\]

src/doc_tex/opt/smawk.tex

@@ -1,13 +1,19 @@
-用于计算满足如下条件的矩阵 \(a\) 每行的 \(\operatorname{argmin}\):
+用于计算满足如下条件 (Monotone) 的矩阵 \(A\) 每行的 \(\operatorname{argmin}\):
 
 \begin{center}
-    令 \(h(r) = \operatorname{argmin}_i a_{r,i}\), 则 \(h\) 单调不降
+    令 \(h(r) = \max \operatorname{argmin}_i A_{r,i}\), 则 \(h\) 单调不降
 \end{center}
 
 不难发现可以分治: 对当前矩阵, 找到中间一行的 \(\operatorname{argmin}\), 然后就可根据这个将矩阵分为更小的两个矩阵
 
+如果 Monotone 矩阵 \(A\) 还满足任意 \(2\times 2\) 的子矩阵都是 Monotone 的, 则称 \(A\) 是 Totally monotone 的
+
+如果 Monotone 矩阵 \(A\) 还满足 \(\forall i,j,~A_{i,j}+A_{i+1,j+1}\leq A_{i+1,j}+A_{i,j+1}\), 则称 \(A\) 是 Monge 的
+
+显然若 \(A\) 是 Monge 的则一定是 Totally monotone 的
+
 \paragraph{复杂度} \(O(c(1+\log(r/c)))\), 其中 \(r\) 为矩阵行数, \(c\) 为矩阵列数
 
-\paragraph{参考文献}
+\paragraph{参考链接} \qrcode{https://www.itcsc.cuhk.edu.hk/Winter_School/Winter_School_2010/Title_Abstract/PPT_Mordecai.pdf} \qrcode{https://www.cse.ust.hk/faculty/golin/Talks/Revisiting_Monge.pdf}
 
-\cite{enwiki:1033199110}
+\paragraph{参考文献} \cite{aggarwal1986geometric} \cite{enwiki:1033199110}

src/test_cpverifier/aizu-dpl/dpl_1_b.knapsack_01.test.cpp

@@ -0,0 +1,13 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_B"
+
+#include "../../code/opt/knapsack_01.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  u32 n, w;
+  std::cin >> n >> w;
+  vecpt<u32> a(n);
+  for (auto& [v, w] : a) std::cin >> v >> w;
+  std::cout << tifa_libs::opt::knapsack_01(a, w) << '\n';
+  return 0;
+}

src/test_cpverifier/aizu-dpl/dpl_1_e.test.cpp

@@ -0,0 +1,11 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_E"
+
+#include "../../code/opt/lev_dis.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  strn a, b;
+  std::cin >> a >> b;
+  std::cout << tifa_libs::opt::lev_dis(a, b).back().back() << '\n';
+  return 0;
+}

src/test_cpverifier/aizu-dpl/dpl_1_f.test.cpp

@@ -0,0 +1,13 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_F"
+
+#include "../../code/opt/knapsack_01.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  u32 n, w;
+  std::cin >> n >> w;
+  vecpt<u32> a(n);
+  for (auto& [v, w] : a) std::cin >> v >> w;
+  std::cout << tifa_libs::opt::knapsack_01(a, w) << '\n';
+  return 0;
+}

src/test_cpverifier/aizu-dpl/dpl_1_g.test.cpp

@@ -0,0 +1,18 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_G"
+
+#include "../../code/opt/knapsack_mixed.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  u32 n, w;
+  std::cin >> n >> w;
+  tifa_libs::opt::knapsack_mixed<i32> kn(w);
+  for (u32 i = 0; i < n; ++i) {
+    i32 v;
+    u32 w, m;
+    std::cin >> v >> w >> m;
+    kn.add(w, v, m);
+  }
+  std::cout << *std::ranges::max_element(kn.result()) << '\n';
+  return 0;
+}

src/test_cpverifier/aizu-dpl/dpl_1_h.test.cpp

@@ -0,0 +1,13 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_H"
+
+#include "../../code/opt/knapsack_01.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  u64 n, w;
+  std::cin >> n >> w;
+  vecpt<u64> a(n);
+  for (auto& [v, w] : a) std::cin >> v >> w;
+  std::cout << tifa_libs::opt::knapsack_01(a, w) << '\n';
+  return 0;
+}

src/test_cpverifier/aizu-dpl/dpl_1_i.test.cpp

@@ -0,0 +1,13 @@
+#define PROBLEM "https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_1_I"
+
+#include "../../code/opt/knapsack_mixed_huge.hpp"
+
+int main() {
+  std::cin.tie(nullptr)->std::ios::sync_with_stdio(false);
+  u64 n, w;
+  std::cin >> n >> w;
+  vec<pt3uu> a(n);
+  for (auto& [v, w, num] : a) std::cin >> v >> w >> num;
+  std::cout << tifa_libs::opt::knapsack_mixed_huge(a, w) << '\n';
+  return 0;
+}