Add enumerating Lyndon words (#115)

hitonanode · web-flow · web-flow · commit 36845d7afb9a · 2021-09-18T15:03:37.000+09:00
* Add lyndon enumeration * Rename lyndon files * [auto-verifier] verify commit f7d5554 * [auto-verifier] verify commit afea3a5 Co-authored-by: GitHub <noreply@github.com>
diff --git a/.verify-helper/timestamps.remote.json b/.verify-helper/timestamps.remote.json
@@ -169,8 +169,8 @@
 "string/test/rolling_hash.test.cpp": "2021-03-13 17:28:18 +0900",
 "string/test/rolling_hash_lcp.test.cpp": "2021-03-13 17:28:18 +0900",
 "string/test/rolling_hash_w_modint.test.cpp": "2021-06-06 14:54:00 +0900",
-"string/test/run_enumerate_lyndon_hash.test.cpp": "2021-03-14 17:31:33 +0900",
-"string/test/run_enumerate_lyndon_rmq.test.cpp": "2021-05-01 20:55:29 +0900",
+"string/test/run_enumerate_lyndon_hash.test.cpp": "2021-09-18 14:55:44 +0900",
+"string/test/run_enumerate_lyndon_rmq.test.cpp": "2021-09-18 14:55:44 +0900",
 "string/test/sa_count_keyword.reader.test.cpp": "2021-08-01 21:42:17 +0900",
 "string/test/sa_count_keyword.test.cpp": "2021-01-02 01:50:58 +0900",
 "string/test/suffix_array.test.cpp": "2021-01-02 00:51:41 +0900",
diff --git a/string/lyndon.hpp b/string/lyndon.hpp
@@ -1,5 +1,7 @@
 #pragma once
 #include <algorithm>
+#include <cassert>
+#include <functional>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -11,12 +13,13 @@
 // Reference:
 // [1] K. T. Chen, R. H. Fox, R. C. Lyndon,
 //     "Free Differential Calculus, IV. The Quotient Groups of the Lower Central Series,"
-//     Annals of Mathematics, 81-95, 1958.
+//     Annals of Mathematics, 68(1), 81-95, 1958.
 // [2] J. P. Duval, "Factorizing words over an ordered alphabet,"
 //     Journal of Algorithms, 4(4), 363-381, 1983.
 // - https://cp-algorithms.com/string/lyndon_factorization.html
 // - https://qiita.com/nakashi18/items/66882bd6e0127174267a
-template <typename T> std::vector<std::pair<int, int>> lyndon_factorization(const std::vector<T> &S) {
+template <typename T>
+std::vector<std::pair<int, int>> lyndon_factorization(const std::vector<T> &S) {
     const int N = S.size();
     std::vector<std::pair<int, int>> ret;
     for (int l = 0; l < N;) {
@@ -41,7 +44,7 @@ std::vector<std::pair<int, int>> lyndon_factorization(const std::string &s) {
 // - `teletelepathy` -> [1,4,1,2,1,4,1,2,1,4,1,2,1]
 // Reference:
 // [1] H. Bannai et al., "The "Runs" Theorem,"
-//     SIAM Journal on Computing, 46.5, 1501-1514, 2017.
+//     SIAM Journal on Computing, 46(5), 1501-1514, 2017.
 template <typename String, typename LCPLENCallable>
 std::vector<int> longest_lyndon_prefixes(const String &s, const LCPLENCallable &lcp) {
     const int N = s.size();
@@ -67,8 +70,9 @@ std::vector<int> longest_lyndon_prefixes(const String &s, const LCPLENCallable &
 // N = 2e5 -> ~120 ms
 // Reference:
 // [1] H. Bannai et al., "The "Runs" Theorem,"
-//     SIAM Journal on Computing, 46.5, 1501-1514, 2017.
-template <typename LCPLENCallable, typename String> std::vector<std::tuple<int, int, int>> run_enumerate(String s) {
+//     SIAM Journal on Computing, 46(5), 1501-1514, 2017.
+template <typename LCPLENCallable, typename String>
+std::vector<std::tuple<int, int, int>> run_enumerate(String s) {
     if (s.empty()) return {};
     LCPLENCallable lcp(s);
     std::reverse(s.begin(), s.end());
@@ -93,3 +97,30 @@ template <typename LCPLENCallable, typename String> std::vector<std::tuple<int,
     ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
     return ret;
 }
+
+// Enumerate Lyndon words up to length n in lexical order
+// https://github.com/bqi343/USACO/blob/master/Implementations/content/combinatorial%20(11.2)/DeBruijnSeq.h
+// Example: k=2, n=4 => [[0,],[0,0,0,1,],[0,0,1,],[0,0,1,1,],[0,1,],[0,1,1,],[0,1,1,1,],[1,],]
+// Verified: https://codeforces.com/gym/102001/problem/C / https://codeforces.com/gym/100162/problem/G
+std::vector<std::vector<int>> enumerate_lyndon_words(int k, int n) {
+    assert(k > 0);
+    assert(n > 0);
+    std::vector<std::vector<int>> ret;
+    std::vector<int> aux(n + 1);
+
+    std::function<void(int, int)> gen = [&](int t, int p) {
+        // t: current length
+        // p: current min cycle length
+        if (t == n) {
+            std::vector<int> tmp(aux.begin() + 1, aux.begin() + p + 1);
+            ret.push_back(std::move(tmp));
+        } else {
+            ++t;
+            aux[t] = aux[t - p];
+            gen(t, p);
+            while (++aux[t] < k) gen(t, t);
+        }
+    };
+    gen(0, 1);
+    return ret;
+}
diff --git a/string/lyndon.md b/string/lyndon.md
@@ -0,0 +1,76 @@
+---
+title: Lyndon words （Lyndon 文字列に関する各種関数）
+documentation_of: ./lyndon.hpp
+---
+
+文字列・数列などの比較可能なものの列に対して Lyndon 分解を行う関数や，Lyndon 列の列挙など．
+
+## Lyndon 文字列
+
+- $S$ が Lyndon 文字列であるとは，$S$ の（非空な）接尾辞の中で $S$ 自身が辞書順最小であること
+
+## Lyndon 分解
+
+- （定義）Lyndon 分解とは，文字列 $S$ の分割 $S = w_1 w_2 \dots w_M$ で，各 $w_i$ は Lyndon 文字列で，しかも $w_i$ たちが辞書順非増加であるもの．
+- （一意性）Lyndon 分解は一意．
+- （構成）$w_1$ は，$S$ の接頭辞で Lyndon であるような最長のもの．
+
+## 実装されている関数
+
+### lyndon_factorization
+
+```cpp
+vector<pair<int, int>> ret = lyndon_factorization(s);
+```
+
+- 文字列など比較可能な要素の列 `s` を Lyndon 分解した際の，（先頭位置，長さ）の組の列を出力
+- 計算量 $O(N)$
+
+### longest_lyndon_prefixes
+
+``` cpp
+vector<int> ret = longest_lyndon_prefixes(s, LCPLEN_Callable_obj);
+```
+
+- 各 suffix `s[i:N)` に関する最長な Lyndon prefix `s[i:i+len(i))` の長さ `len(i)` を格納した配列を出力
+- 計算量 $O(NL)$
+  - $L$ は `s[i:)` と `s[j:)` の longest common prefix 長の計算一回に要する計算量
+
+### run_enumerate
+
+``` cpp
+ret = run_enumerate<LCPLEN_Callable>(s);
+```
+
+- 各 run について `(c, l, r)` （`s[l:r)` が最小周期 `c`，2 周期以上）を全列挙
+- 計算量 $O(NL)$
+
+### enumerate_lyndon_words
+
+```cpp
+int k, n;
+vector<vector<int>> seqs = enumerate_lyndon_words(k, n);
+```
+
+- 各要素が $0, \dots, (k - 1)$ で長さ $n$ 以下の Lyndon 列を辞書順に全列挙する．
+- これを応用すると，「[de Bruijn sequence - Wikipedia](https://en.wikipedia.org/wiki/De_Bruijn_sequence)」 $B(k, n)$ が構築できる．
+  - de Bruijn sequence $B(k, n)$ とは，各要素が $0$ 以上 $k - 1$ 以下の整数からなる長さ $k^n$ の列で，その長さ $n$ の全ての連続部分列 $k^n$ 個（端は周期的に見る）が互いに相異なるもの．
+  - $B(k, n)$ のうち特に辞書順最小のものは，「各要素が $0$ 以上 $k - 1$ 以下の整数で長さが $n$ の約数であるような Lyndon 列」全てを辞書順に並べて結合することで構築できることが知られている．
+
+## 問題例
+
+- [Run Enumerate - Library Checker](https://judge.yosupo.jp/problem/runenumerate)
+- [2012-2013 Petrozavodsk Winter Training Camp, Saratov SU Contest G. Lyndon Words - Codeforces](https://codeforces.com/gym/100162/problem/G) Lyndon words を列挙する．
+- [2018 ICPC Asia Jakarta Regional Contest C. Smart Thief - Codeforces](https://codeforces.com/gym/102001/problem/C) de Bruijn sequence を構築する．
+
+## 参考文献・リンク
+
+- [1] K. T. Chen, R. H. Fox, R. C. Lyndon,
+  "Free Differential Calculus, IV. The Quotient Groups of the Lower Central Series,"
+  Annals of Mathematics, 68(1), 81-95, 1958.
+- [2] J. P. Duval, "Factorizing words over an ordered alphabet,"
+  Journal of Algorithms, 4(4), 363-381, 1983.
+- [3] H. Bannai et al., "The "Runs" Theorem,"
+  SIAM Journal on Computing, 46(5), 1501-1514, 2017.
+- [Lyndon factorization - Competitive Programming Algorithms](https://cp-algorithms.com/string/lyndon_factorization.html)
+- [Lyndon 文字列入門 - Qiita](https://qiita.com/nakashi18/items/66882bd6e0127174267a)
diff --git a/string/lyndon_factorization.md b/string/lyndon_factorization.md
diff --git a/string/test/run_enumerate_lyndon_hash.test.cpp b/string/test/run_enumerate_lyndon_hash.test.cpp
@@ -1,4 +1,4 @@
-#include "../lyndon_factorization.hpp"
+#include "../lyndon.hpp"
 #include "../rolling_hash_1d.hpp"
 #include <iostream>
 #include <string>
diff --git a/string/test/run_enumerate_lyndon_rmq.test.cpp b/string/test/run_enumerate_lyndon_rmq.test.cpp
@@ -1,5 +1,5 @@
 #include "../longest_common_prefix.hpp"
-#include "../lyndon_factorization.hpp"
+#include "../lyndon.hpp"
 #include <iostream>
 #include <string>
 #define PROBLEM "https://judge.yosupo.jp/problem/runenumerate"

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#include "../lyndon_factorization.hpp"`
	`1`	`+#include "../lyndon.hpp"`
`2`	`2`	`#include "../rolling_hash_1d.hpp"`
`3`	`3`	`#include <iostream>`
`4`	`4`	`#include <string>`