ac-library-rb 0.5.0

data/document_en/lazy_segtree.md

@@ -0,0 +1,141 @@
+# LazySegtree
+
+This is a lazy evaluation segment tree.
+
+## Class Methods.
+
+### new(v, e, id, op, mapping, composition)
+
+```ruby
+seg = LazySegtree.new(v, e, id, op, mapping, compositon)
+```
+
+The first argument can be an `Integer` or an `Array`.
+
+- If the first argument is an `Integer` of `n`, a segment tree of length `n` and initial value `e` will be created.
+- If the first argument is `a` of `Array` with length `n`, a segment tree will be created based on `a`.
+
+The second argument `e` is the unit source. We need to define the monoid by defining the binary operation `op(x, y)` in the block.
+
+**Complexity**
+
+- `O(n)`
+
+## Instance methods.
+
+## set(pos, x)
+
+```ruby
+seg.set(pos, x)
+```
+
+Assign `x` to `a[pos]`.
+
+**Complexity**
+
+-  `O(logn)`
+
+### get(pos) -> same class as unit source e
+
+```ruby
+seg.get(pos)
+```
+
+It returns `a[pos]`.
+
+**Complexity**
+
+- `O(1)`
+
+### prod(l, r) -> same class as unit source e
+
+```ruby
+seg.prod(l, r)
+```
+
+It returns `op(a[l], ... , a[r - 1])`.
+
+**Constraints**
+
+- `0 ≤ l ≤ r ≤ n`.
+
+**Complexity**
+
+- `O(logn)`
+
+### all_prod -> same class as unit source e
+
+```ruby
+seg.all_prod
+```
+
+It returns `op(a[0], ... , a[n - 1])`.
+
+**Complexity**
+
+- `O(1)`.
+
+### apply(pos, val)
+
+```ruby
+seg.apply(pos, val)
+```
+
+The implementation with three arguments in the original code is called `range_apply` in this library. If it looks OK after measuring the execution time, we can make the `apply` method support both 2 and 3 arguments.
+
+**Constraints**
+
+- `0 ≤ pos < n`.
+
+**Complexity**
+
+- `O(log n)`.
+
+### range_apply(l, r, val)
+
+```ruby
+seg.range_apply(l, r, val)
+```
+
+**Constraints**
+
+- `0 ≤ l ≤ r ≤ n`.
+
+**Complexity**
+
+- `O(log n)`
+
+### max_right.
+
+[TODO] Someone with some free time will write.
+
+### min_left
+
+[TODO] The code side is not implemented yet.
+
+## Verified
+
+This is the link in question. There is no code, but it has been Verified.
+- [AIZU ONLINE JUDGE DSL\_2\_F RMQ and RUQ](http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_F)
+- [AIZU ONLINE JUDGE DSL\_2\_G RSQ and RAQ](http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_G)
+
+The following problem is not AC in Ruby because the execution time is strictly TLE.
+- [ALPC: K \- Range Affine Range Sum](https://atcoder.jp/contests/practice2/tasks/practice2_k)
+- [ALPC: L \- Lazy Segment Tree](https://atcoder.jp/contests/practice2/tasks/practice2_l)
+
+## Reference links
+
+- ac-library-rb
+  - [Code: lazy_segtree.rb](https://github.com/universato/ac-library-rb/blob/master/lib/lazy_segtree.rb)
+  - [Test code: lazy_segtree_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/lazy_segtree_test.rb)
+- AtCoder Library
+  - [Document: lazysegtree.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_en/lazysegtree.md)
+  - [Documentat: appendix.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_en/appendix.md)
+  - [Code: lazysegtree.hpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp)
+  - [Test code: lazysegtree_test.cpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/test/unittest/lazysegtree_test.cpp )
+
+## Differences from the original library.
+
+### Not `ceil_pow2`, but `bit_length`.
+
+The original C++ library uses the original `internal::ceil_pow2` function, but this library uses the existing Ruby method `Integer#bit_length`. This library uses the existing Ruby method `Integer#bit_length`, which is faster than the original method.

data/document_en/math.md

@@ -0,0 +1,104 @@
+# Math
+
+It contains number-theoretic algorithms.
+
+- `pow_mod`
+- `inv_mod`
+- `crt`
+- `floor_sum`
+
+## pow_mod
+
+```ruby
+pow_mod(x, n, m)
+```
+
+It returns `(x**n) % m`.
+
+However, Ruby core has `Integer#pow`. Use it.
+
+**Constraints**
+
+- `n`, `m` are intergers.
+- `0 ≦ n`, `1 ≦ m`
+
+**Complexity**
+
+- `O(log n)`
+
+## inv_mod
+
+```ruby
+inv_mod(x, n, m)
+```
+
+It returns an integer `y` such that `0 ≦ y < m` and `xy ≡ 1 (mod m)`.
+
+If m is a prime number, Use `x.pow(m - 2, m)`。
+
+**Constraints**
+
+- `gcd(x, m) = 1`, `1 ≦ m`
+
+**Complexity**
+
+- `O(log m)`
+
+### Verified
+- [ABC186 E - Throne](https://atcoder.jp/contests/abc186/tasks/abc186_e)
+  - [AC Code(59ms) 2020/12/20](https://atcoder.jp/contests/abc186/submissions/18898186)
+
+## crt(r, m) -> [rem , mod] or [0, 0]
+
+Chinese remainder theorem
+
+
+Given two arrays `r`, `m` with length `n`, it solves the modular equation system
+
+`x ≡ r[i] (mod m[i]), ∀i ∈ {0, 1, …… n - 1}`
+
+If there is no solution, it returns `[0, 0]`.
+
+If there is a solution, all the solutions can be written as the form `x ≡ rem(mod)`. it returns `[rem ,mod]`
+
+
+## Verified
+
+Problems
+- [No\.187 中華風 \(Hard\) \- yukicoder](https://yukicoder.me/problems/no/187)
+
+## floor_sum(n, m, a, b)
+
+$\sum_{i = 0}^{n - 1} \mathrm{floor}(\frac{a \times i + b}{m})$
+
+It retrurns `Σ[k = 0 → n - 1] floor((a * i + b) / m)`
+
+**Complexity**
+
+- `O(log(n + m + a + b))`
+
+## Verified
+
+[ALPC: C \- Floor Sum](https://atcoder.jp/contests/practice2/tasks/practice2_c)
+ - [AC Code 426ms 2020/9/14](https://atcoder.jp/contests/practice2/submissions/16735215)
+
+## 参考リンク
+
+- ac-library-rb
+  - codes in ac-library-rb
+    - [Code pow_mod.rb](https://github.com/universato/ac-library-rb/blob/master/lib/pow_mod.rb)
+    - [Code inv_mod.rb](https://github.com/universato/ac-library-rb/blob/master/lib/inv_mod.rb)
+    - [Code crt.rb](https://github.com/universato/ac-library-rb/blob/master/lib/crt.rb)
+    - [Code floor_sum.rb](https://github.com/universato/ac-library-rb/blob/master/lib/floor_sum.rb)
+  - test in ac-library-rb
+    - [Test pow_mod_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/pow_mod.rb)
+    - [Test inv_mod_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/inv_mod.rb)
+    - [Test crt_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/crt.rb)
+    - [Test floor_sum_test.rb](https://github.com/universato/ac-library-rb/test/master/lib/floor_sum.rb)
+- AtCoder Library
+  - [Code math.hpp](https://github.com/atcoder/ac-library/blob/master/atcoder/math.hpp)
+  - [Code internal_math.hpp](https://github.com/atcoder/ac-library/blob/master/atcoder/internal_math.hpp)
+  - [Test math_test.cpp](https://github.com/atcoder/ac-library/blob/master/test/unittest/math_test.cpp)
+  - [Document math.md](https://github.com/atcoder/ac-library/blob/master/document_ja/math.md)
+  - [Document math.html](https://atcoder.github.io/ac-library/document_en/math.html)
+  - [Relax the constraints of floor\_sum? · Issue \#33 · atcoder/ac\-library](https://github.com/atcoder/ac-library/issues/33)

data/document_en/max_flow.md

@@ -0,0 +1,165 @@
+# MaxFlow
+
+Library for solving [Maximum flow problem](https://en.wikipedia.org/wiki/Maximum_flow_problem).
+
+
+## Class Methods.
+
+### new(n = 0) -> MaxFlow
+
+```ruby
+graph = Maxflow.new(10)
+```
+
+It creates a graph of `n` vertices and `0` edges.
+
+**Complexity**
+
+- `O(n)`
+
+## Instance Methods.
+
+### add_edge(from, to, cap) -> Integer
+
+```ruby
+graph.add_edge(0, 1, 5)
+```
+
+It adds an edge oriented from the vertex `from` to the vertex `to` with the capacity cap and the flow amount `0`.
+
+It returns an integer `k` such that this is the `k`-th edge that is added.
+
+**Complexity**
+
+- `O(1)` amortized
+
+
+
+
+### flow(start, to, flow_limit = 1 << 64) -> Integer
+
+```ruby
+(1) graph.flow(0, 3)
+(2) graph.flow(0, 3, flow_limit)
+```
+
+- It augments the flow from `s` to `t` as much as possible. It returns the amount of the flow augmented.
+
+**Aliases**
+
+- `max_flow`
+- `flow`
+
+**Constraints**
+
+- `start ≠ to`
+
+### min_cut(start) -> Array(boolean)
+
+```ruby
+graph.min_cut(start)
+```
+
+The return value is an array of length `n`.
+
+The `i`-th element of the return value is filled with `true` if the vertex `start` to `i` is reachable by the remainder graph, otherwise it is filled with `false`.
+
+**Complexity**
+
+- `O(n + m)`, where `m` is the number of added edges.
+
+### get_edge(i) -> [from, to, cap, flow].
+
+```ruby
+graph.get_edge(i)
+graph.edge(i)
+graph[i].
+```
+
+- It returns the current internal state of the `i`-th edge.
+- The edges are ordered in the same order as added by `add_edge`.
+
+**Complexity**
+
+- `O(1)`.
+
+**Aliases**
+
+- `get_edge`
+- `edge`
+- `[]`
+
+### edges -> Array([from, to, cap, flow])
+
+```ruby
+graph.edges
+```
+
+- It returns the current internal state of the all edges.
+- The edges are ordered in the same order as added by `add_edge`.
+
+**Complexity**
+
+- `O(m)`, where `m` is the number of added edges.
+
+#### Notes on the `edges` method
+
+The `edges` method is `O(m)` because it generates information for all edges.
+
+Because of the generation cost, consider using `get_edge(i)` or storing it in a separate variable once, `edges = graph.edges`.
+
+### change_edge(i, new_cap, new_flow)
+
+Change the capacity and flow rate of the `i`-th changed edge to `new_cap` and `new_flow`.
+
+**Constraints**
+
+- `0 ≤ new_fow ≤ new_cap`
+
+**Complexity**
+
+- `O(1)`
+
+## Verified.
+
+- [ALPC: D \- Maxflow](https://atcoder.jp/contests/practice2/tasks/practice2_d)
+  - [AC Code 211ms 2020/9/17](https://atcoder.jp/contests/practice2/submissions/16789801)
+  - [ALPC: D \fnDroid Sans Fallback - Qiita](https://qiita.com/magurofly/items/bfaf6724418bfde86bd0)
+
+## Reference links
+
+- ac-library-rb
+  - [Code max_flow.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/master/lib/max_flow.rb)
+  - [Test code: max_flow_test.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/master/test/max_flow_test.rb)
+- The original library AtCoder Library
+  - Code of the original library
+    - [Code: maxflow.hpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/maxflow.hpp)
+    - [Test code: maxflow_test.cpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/test/unittest/maxflow_test.cpp)
+  - Main family documentation
+    - [Documentat: maxflow.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_en/maxflow.md)
+    - [Documentat: maxflow.html](https://atcoder.github.io/ac-library/document_en/maxflow.html)
+    - [Document: appendix.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_en/appendix.md)
+
+## Questions and Answers.
+
+### Why does the `flow_limit` of the `flow` method default to `1 << 64`?
+
+I don't remember, and there is no deeper meaning.
+It looks like `Float::MAX` or `Float::INFINITY` might be OK, but won't it slow things down?
+
+### Don't use Struct for edges.
+
+Using Struct makes the code slimmer, more advanced, and better looking.
+
+However, as a result of measurements, Struc is slow, so we use arrays.
+
+### What is the purpose of a variable that starts with `_`?
+
+It's a bit confusing, but there are two separate intentions: 1.
+
+1. `_e` and `_re` are matching variable names to make them easier to read with the original ACL code. 2.
+2. `_rev` is spit out but not used for the convenience of running `each`, so it starts with `_` with the intention of "not using".
+
+````ruby
+@g[q].each do |(to, _rev, cap)|
+````

data/document_en/min_cost_flow.md

@@ -0,0 +1,132 @@
+# MinCostFlow
+
+It solves [Minimum\-cost flow problem](https://en.wikipedia.org/wiki/Minimum-cost_flow_problem).
+
+## Class Methods.
+
+### new(n = 0) -> MinCostFlow
+
+```ruby
+graph = MinCostFlow.new(10)
+```
+
+It creates a directed graph with `n` vertices and `0` edges.
+
+Verticle order is the 0-based index.
+
+**Constraints**
+
+- `0 ≦ n`
+
+**Complexity**
+
+- `O(n)`
+
+
+## Instance Methods.
+
+### add_edge(from, to, cap, cost) -> Integer
+
+```ruby
+graph.add_edge(0, 1, 5)
+```
+
+Adds an edge from vertex `from` to vertex `to` with maximum capacity `cap` and flow rate `0`.
+
+The return value is the number of edge added with 0-based index.
+
+### flow(start, to, flow_limit = Float::MAX) -> [flow, cost]
+### min_cost_max_flow(start, to, flow_limit = Float::MAX) -> [flow, cost]
+
+```ruby
+(1) graph.flow(0, 3)
+(2) graph.flow(0, 3, flow_limit)
+```
+
+The internals are mostly the `slope` method, just getting the last element of the return value of the `slop` method. The constraints and computational complexity are the same as for the `slope` method.
+
+**Aliases**
+
+- `flow`
+- `min_cost_max_flow`
+
+### slope(s, t, flow_limit = Float::MAX) -> [[flow, cost]]
+### min_cost_slop(s, t, flow_limit = Float::MAX) -> [[flow, cost]]
+
+```ruby
+graph.slop(0, 3)
+```
+
+**Complexity**
+
+- `O(F(n + m) log n)`, where `F` is the amount of the flow and `m` is the number of added edges.
+
+**Aliases**
+
+- `slope`
+- `min_cost_slope`
+
+### get_edge(i) -> [from, to, cap, flow, cost]
+### edge(i) -> [from, to, cap, flow, cost]
+### [](i) -> [from, to, cap, flow, cost]
+
+```ruby
+graph.get_edge(i)
+graph.edge(i)
+graph[i].
+```
+
+It returns the state of the `i`-th edge.
+
+**Constraints**
+
+- `0 ≤ i < m`.
+
+**Complexity**
+
+- `O(1)`
+
+### edges -> Array[from, to, cap, flow, cost]
+
+```ruby
+graph.edges
+```
+
+It returns an array containing information on all edges.
+
+**Complexity**
+
+- `O(m)`, where mm is the number of added edges.
+
+## Verified
+
+- [ALPC: E\- MinCostFlow](https://atcoder.jp/contests/practice2/tasks/practice2_e)
+  - [1213ms 2020/9/17](https://atcoder.jp/contests/practice2/submissions/16792967)
+
+## Reference links
+
+- Our library: ac-library-rb
+  - [Code: min_cost_flow.rb](https://github.com/universato/ac-library-rb/blob/master/lib/min_cost_flow.rb)
+  - [Test code: min_cost_flow_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/min_cost_flow_test.rb)
+- The original library: AtCoder Library(ACL)
+  - [Documentat: mincostflow.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_ja/mincostflow.md)
+  - [Code: mincostflow.hpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/mincostflow.hpp)
+  - [Test code: mincostflow_test.cpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/test/unittest/mincostflow_test.cpp )
+
+## Questions and Answers
+
+## The intent of the aliases is to
+
+The method name of the minimum cost flow of the original library is long, so I have an alias for it. The method name of the maximum cost stream in the original library is short, so it is strange.
+
+### What is the purpose of using `Float::MAX` instead of `Float::INFINITY`?
+
+I haven't tested it specifically, so I'd like to verify what number is good.
+
+I felt that the `Integer` class would be fine.
+
+### Don't use Struct on the edges.
+
+Using Struct makes the code slimmer and more advanced, and it looks better.
+
+However, I didn't use Struct because it was too slow as a result of measurement.