🦄 refactor(monge):

Author: liaomingtian

11_动态规划/dp优化/AlienDp(wqs二分)/AliensDp.go renamed to 11_动态规划/dp优化/四边形不等式Monge优化dp/monge/AlienDp(wqs二分)/AliensDp.go

@@ -10,10 +10,7 @@
  * @see
  * https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/solution/yi-chong-ji-yu-wqs-er-fen-de-you-xiu-zuo-x36r/
  */
-function aliensDp(
-  k: number,
-  getDp: (penalty: number) => [best: number, maxOperation: number]
-): number {
+function aliensDp(k: number, getDp: (penalty: number) => [best: number, maxOperation: number]): number {
   let left = 1
   let right = 2e15
   let penalty = 0

11_动态规划/dp优化/AlienDp(wqs二分)/AliensDp.ts renamed to 11_动态规划/dp优化/四边形不等式Monge优化dp/monge/AlienDp(wqs二分)/AliensDp.ts

@@ -1,8 +1,37 @@
 https://kmyk.github.io/monotone-matrix-visualizer/
-
+https://topcoder-g-hatena-ne-jp.jag-icpc.org/spaghetti_source/20120915/1347668163.html
 https://maspypy.github.io/library/convex/monge.hpp
 
 [monge グラフ上の d-辺最短路の d=1,...,N における列挙](https://nyaannyaan.github.io/library/dp/monge-d-edge-shortest-path-enumerate.hpp)
 [monge グラフ上の d-辺最短路](https://nyaannyaan.github.io/library/dp/monge-d-edge-shortest-path.hpp)
 [monge グラフ上の最短路](https://nyaannyaan.github.io/library/dp/monge-shortest-path.hpp)
 [monotone minima](https://nyaannyaan.github.io/library/dp/monotone-minima.hpp)
+
+---
+
+Monge 图：
+
+```
+给定一个n个顶点的DAG，图中的每个顶点i都有一条边指向编号j(i<j)，且边的权重满足Monge性质(也就是四边形不等式)，dist(a, b) + dist(c, d) ≤ dist(a, d) + dist(c, b)，这个图就是Monge图
+```
+
+---
+
+- **SMAWK（totally monotone minima; TM minima)**:
+  `O(ROW+COL)` 时间复杂度求出一个全单调矩阵的每行的最小值
+- **Monotone Minima**:
+  `O(ROW+COL*logROW)` 时间复杂度求出一个单调矩阵的每行的最小值
+- **Monge**:
+  `O(nlogmax)`求出 Monge 图的 d 边最短路
+
+---
+
+## Totally Monotone 和 Monotone 有什么区别？
+
+"Monotone"（单调）和"Totally Monotone"（全单调）是两种不同的数学性质，它们都可以用来描述函数或矩阵。
+
+1. "Monotone"（单调）：通常用来描述一个函数或序列，如果它的值随着输入的增加而单调增加或单调减少，那么我们就说这个函数或序列是单调的。例如，函数 f(x) = x^2 在 x >= 0 时就是单调的，因为当 x 增加时，f(x)的值也增加。
+
+2. "Totally Monotone"（全单调）：是一种更强的单调性质，通常用来描述矩阵或二元函数。对于一个矩阵或函数，如果它满足对于任意的 i < j 和 k < l，如果矩阵的[i][k]元素大于矩阵的[j][l]元素，那么矩阵的[i][l]元素也大于矩阵的[j][k]元素，那么我们就说这个矩阵或函数是全单调的。
+
+总的来说，全单调是一种更强的单调性质，它要求函数或矩阵在多个维度上都保持单调性。而单调只要求函数或序列在一个维度上保持单调性。

11_动态规划/dp优化/AlienDp(wqs二分)/ECR79F - New Year and Handle Change.go renamed to 11_动态规划/dp优化/四边形不等式Monge优化dp/monge/AlienDp(wqs二分)/ECR79F - New Year and Handle Change.go

@@ -1,10 +1,10 @@
-import { DefaultDict } from '../../5_map/DefaultDict'
-import { ACAutoMaton } from './ACAutoMaton'
+import { DefaultDict } from '../../../5_map/DefaultDict'
+import { ACAutoMatonLegacy } from './ACAutoMatonLegacy'
 
 // !因为字符串总长度太大(1e6),MLE了
 const INF = 2e15
 function longestValidSubstring(word: string, forbidden: string[]): number {
-  const acm = new ACAutoMaton()
+  const acm = new ACAutoMatonLegacy()
   const minLen = new DefaultDict(() => INF)
   forbidden.forEach((pattern, id) => {
     acm.insert(id, pattern, pos => {

11_动态规划/dp优化/AlienDp(wqs二分)/aliensDp.py renamed to 11_动态规划/dp优化/四边形不等式Monge优化dp/monge/AlienDp(wqs二分)/aliensDp.py

@@ -19,7 +19,7 @@
 
 from collections import defaultdict
 from typing import List
-from ACAutoMaton import ACAutoMaton
+from ACAutoMatonLegacy import ACAutoMatonLegacy
 
 INF = int(1e18)
 
@@ -33,7 +33,7 @@ def dp(pre: int, cur: int) -> None:
             minLen[cur] = min(minLen[cur], minLen[pre])
 
         minLen = defaultdict(lambda: INF)  # !ac自动机每个状态匹配到的模式串的最小长度
-        acm = ACAutoMaton()
+        acm = ACAutoMatonLegacy()
         for i, s in enumerate(forbidden):
             acm.insert(i, s, didInsert=didInsert)
         acm.build(dp=dp)

11_动态规划/dp优化/AlienDp(wqs二分)/note.md renamed to 11_动态规划/dp优化/四边形不等式Monge优化dp/monge/AlienDp(wqs二分)/note.md

@@ -3,7 +3,7 @@
 // !Trie由数组实现，比map实现的Trie快很多.
 //
 // API
-//  Insert(id int, s string, didInsert func(pos int)) *ACAutoMatonArray
+//  Insert(id int, s string, didInsert func(pos int)) *ACAutoMatonArrayLegacy
 //  Build(heavy bool, dp func(fail, next int))
 //  Match(state int, s string) map[int][]int
 //  Move(pos, char) int
@@ -18,12 +18,12 @@ package main
 // https://leetcode.cn/problems/stream-of-characters/
 
 type StreamChecker struct {
-	acm   *ACAutoMatonArray
+	acm   *ACAutoMatonArrayLegacy
 	state int
 }
 
 func Constructor(words []string) StreamChecker {
-	acm := NewACAutoMatonArray()
+	acm := NewACAutoMatonArrayLegacy()
 	for i, word := range words {
 		acm.Insert(i, word, nil)
 	}
@@ -44,22 +44,22 @@ const (
 	_MARGIN byte = 'a' // 字符集起始字符
 )
 
-type ACAutoMatonArray struct {
+type ACAutoMatonArrayLegacy struct {
 	*Trie // !继承自Trie
 	count []int
 	heavy bool
 }
 
-func NewACAutoMatonArray() *ACAutoMatonArray {
-	res := &ACAutoMatonArray{Trie: _newTrie()}
+func NewACAutoMatonArrayLegacy() *ACAutoMatonArrayLegacy {
+	res := &ACAutoMatonArrayLegacy{Trie: _newTrie()}
 	return res
 }
 
 // bfs为字典树的每个结点添加失配指针,结点要跳转到哪里.
 //
 //	heavy: 是否处理出每个结点匹配到的模式串id.
 //	dp: AC自动机构建过程中的回调函数,入参为`(next结点的fail指针, next结点)`.
-func (ac *ACAutoMatonArray) Build(heavy bool, dp func(fail, next int)) {
+func (ac *ACAutoMatonArrayLegacy) Build(heavy bool, dp func(fail, next int)) {
 	ac.count = make([]int, len(ac.states))
 	for i, v := range ac.states {
 		ac.count[i] = len(v.matching)
@@ -111,7 +111,7 @@ func (ac *ACAutoMatonArray) Build(heavy bool, dp func(fail, next int)) {
 //	state : ac自动机的状态.根节点状态为0.
 //	s : 待匹配的字符串.
 //	返回每个模式串在`s`中出现的下标.
-func (ac *ACAutoMatonArray) Match(state int, s string) map[int][]int {
+func (ac *ACAutoMatonArrayLegacy) Match(state int, s string) map[int][]int {
 	if !ac.heavy {
 		panic("需要调用build(heavy=True)构建AC自动机")
 	}
@@ -127,12 +127,12 @@ func (ac *ACAutoMatonArray) Match(state int, s string) map[int][]int {
 }
 
 // 当前节点匹配的完整的模式串的个数.
-func (ac *ACAutoMatonArray) Count(pos int) int {
+func (ac *ACAutoMatonArrayLegacy) Count(pos int) int {
 	return ac.count[pos]
 }
 
 // 当前节点状态是否为可接受(后缀匹配到了模式串).
-func (ac *ACAutoMatonArray) Accept(pos int) bool {
+func (ac *ACAutoMatonArrayLegacy) Accept(pos int) bool {
 	return ac.count[pos] > 0
 }
 

11_动态规划/dp优化/四边形不等式Monge优化dp/monge/note.md

@@ -4,7 +4,7 @@
 /**
  * @deprecated
  */
-class ACAutoMatonArray {
+class ACAutoMatonArrayLegacy {
   /**
    * 模式串列表.
    */
@@ -177,16 +177,16 @@ class ACAutoMatonArray {
   }
 }
 
-export { ACAutoMatonArray }
+export { ACAutoMatonArrayLegacy }
 
 if (require.main === module) {
   // 1032. 字符流
   // https://leetcode.cn/problems/stream-of-characters/
   class StreamChecker {
-    private readonly _acm: ACAutoMatonArray
+    private readonly _acm: ACAutoMatonArrayLegacy
     private _state = 0
     constructor(words: string[]) {
-      this._acm = new ACAutoMatonArray()
+      this._acm = new ACAutoMatonArrayLegacy()
       words.forEach((word, i) => this._acm.insert(i, word))
       this._acm.build()
     }
@@ -206,7 +206,7 @@ if (require.main === module) {
   // 面试题 17.17. 多次搜索
   // https://leetcode.cn/problems/multi-search-lcci/
   function multiSearch(big: string, smalls: string[]): number[][] {
-    const acm = new ACAutoMatonArray()
+    const acm = new ACAutoMatonArrayLegacy()
     smalls.forEach((small, i) => acm.insert(i, small))
     acm.build(true)
 

17_模式匹配/AC自动机(多模式匹配)/acwing1285.单词.py

@@ -7,12 +7,12 @@ package main
 // https://leetcode.cn/problems/stream-of-characters/
 
 type StreamChecker struct {
-	acm   *ACAutoMaton
+	acm   *ACAutoMatonLegacy
 	state int
 }
 
 func Constructor(words []string) StreamChecker {
-	acm := NewACAutoMaton()
+	acm := NewACAutoMatonLegacy()
 	for i, word := range words {
 		acm.Insert(i, word, nil)
 	}
@@ -32,7 +32,7 @@ func (this *StreamChecker) Query(letter byte) bool {
 // 面试题 17.17. 多次搜索
 // https://leetcode.cn/problems/multi-search-lcci/
 func multiSearch(big string, smalls []string) [][]int {
-	acm := NewACAutoMaton()
+	acm := NewACAutoMatonLegacy()
 	for i, word := range smalls {
 		acm.Insert(i, word, nil)
 	}
@@ -54,7 +54,7 @@ func multiSearch(big string, smalls []string) [][]int {
 // https://leetcode.cn/problems/length-of-the-longest-valid-substring/
 func longestValidSubstring(word string, forbidden []string) int {
 	const INF int = 1e18
-	acm := NewACAutoMaton()
+	acm := NewACAutoMatonLegacy()
 	minLen := make(map[int]int)
 
 	for i, word := range forbidden {
@@ -106,7 +106,7 @@ func max(a, b int) int {
 
 //###############################################################
 
-type ACAutoMaton struct {
+type ACAutoMatonLegacy struct {
 	patterns  []string       // 模式串列表
 	children  []map[byte]int // trie树,children[i]表示节点(状态)i的所有子节点,0表示虚拟根节点
 	wordCount []int          // trie树结点附带的信息.count[i]表示节点(状态)i的匹配个数
@@ -115,8 +115,8 @@ type ACAutoMaton struct {
 	heavy     bool           // 构建时是否在matching中处理出每个结点匹配到的模式串id
 }
 
-func NewACAutoMaton() *ACAutoMaton {
-	res := &ACAutoMaton{}
+func NewACAutoMatonLegacy() *ACAutoMatonLegacy {
+	res := &ACAutoMatonLegacy{}
 	res.children = append(res.children, make(map[byte]int))
 	res.matching = append(res.matching, make([]int, 0))
 	return res
@@ -127,7 +127,7 @@ func NewACAutoMaton() *ACAutoMaton {
 //	pid : 模式串的唯一标识id.
 //	pattern : 模式串.
 //	didInsert : 模式串插入后的回调函数,入参为结束字符所在的结点(状态).
-func (acm *ACAutoMaton) Insert(pid int, pattern string, didInsert func(state int)) *ACAutoMaton {
+func (acm *ACAutoMatonLegacy) Insert(pid int, pattern string, didInsert func(state int)) *ACAutoMatonLegacy {
 	if len(pattern) == 0 {
 		return acm
 	}
@@ -159,7 +159,7 @@ func (acm *ACAutoMaton) Insert(pid int, pattern string, didInsert func(state int
 //
 //	heavy : 是否处理出每个结点匹配到的模式串id.
 //	dp : AC自动机构建过程中的回调函数,入参为`(next结点的fail指针, next结点)`.
-func (acm *ACAutoMaton) Build(heavy bool, dp func(move, next int)) {
+func (acm *ACAutoMatonLegacy) Build(heavy bool, dp func(move, next int)) {
 	acm.wordCount = make([]int, len(acm.children))
 	for i := 0; i < len(acm.children); i++ {
 		acm.wordCount[i] = len(acm.matching[i])
@@ -193,7 +193,7 @@ func (acm *ACAutoMaton) Build(heavy bool, dp func(move, next int)) {
 
 // 从当前状态`state`沿着字符`input`转移到的下一个状态.
 // 沿着失配链上跳,找到第一个可由char转移的节点.
-func (acm *ACAutoMaton) Move(state int, input byte) int {
+func (acm *ACAutoMatonLegacy) Move(state int, input byte) int {
 	for {
 		nexts := acm.children[state]
 		if _, ok := nexts[input]; ok {
@@ -211,7 +211,7 @@ func (acm *ACAutoMaton) Move(state int, input byte) int {
 //	state : ac自动机的状态.根节点状态为0.
 //	s : 待匹配的字符串.
 //	返回每个模式串在`s`中出现的下标.
-func (acm *ACAutoMaton) Match(state int, s string) map[int][]int {
+func (acm *ACAutoMatonLegacy) Match(state int, s string) map[int][]int {
 	if !acm.heavy {
 		panic("需要调用build(heavy=True)构建AC自动机")
 	}
@@ -227,11 +227,11 @@ func (acm *ACAutoMaton) Match(state int, s string) map[int][]int {
 }
 
 // 当前状态`state`匹配到的模式串个数.
-func (acm *ACAutoMaton) Count(state int) int {
+func (acm *ACAutoMatonLegacy) Count(state int) int {
 	return acm.wordCount[state]
 }
 
 // 当前状态`state`是否为匹配状态.
-func (acm *ACAutoMaton) Accept(state int) bool {
+func (acm *ACAutoMatonLegacy) Accept(state int) bool {
 	return acm.wordCount[state] > 0
 }

17_模式匹配/AC自动机(多模式匹配)/2781. 最长合法子字符串的长度-AC自动机-MLE.ts renamed to 17_模式匹配/AC自动机(多模式匹配)/legacy/2781. 最长合法子字符串的长度-AC自动机-MLE.ts

@@ -11,7 +11,7 @@
 from typing import Callable, DefaultDict, List, Optional
 
 
-class ACAutoMaton:
+class ACAutoMatonLegacy:
     """AC自动机,多模式串匹配."""
 
     __slots__ = ("_patterns", "_children", "_wordCount", "_matching", "_fail", "_heavy")
@@ -37,7 +37,7 @@ def __init__(self):
 
     def insert(
         self, pid: int, pattern: str, didInsert: Optional[Callable[[int], None]] = None
-    ) -> "ACAutoMaton":
+    ) -> "ACAutoMatonLegacy":
         """将模式串`pattern`插入到Trie树中.模式串一般是`被禁用的单词`.
 
         Args:
@@ -146,7 +146,7 @@ def accept(self, pos: int) -> bool:
 if __name__ == "__main__":
 
     def demo() -> None:
-        ac = ACAutoMaton()
+        ac = ACAutoMatonLegacy()
         ac.insert(0, "he")
         ac.insert(1, "she")
         ac.insert(2, "his")
@@ -168,7 +168,7 @@ def demo() -> None:
     class Solution:
         def multiSearch(self, big: str, smalls: List[str]) -> List[List[int]]:
             """多模式匹配indexOfAll"""
-            ac = ACAutoMaton()
+            ac = ACAutoMatonLegacy()
             for i, small in enumerate(smalls):
                 ac.insert(i, small)
             ac.build(heavy=True)
@@ -186,7 +186,7 @@ def multiSearch(self, big: str, smalls: List[str]) -> List[List[int]]:
     # https://leetcode.cn/problems/stream-of-characters/
     class StreamChecker:
         def __init__(self, words: List[str]):
-            self._ac = ACAutoMaton()
+            self._ac = ACAutoMatonLegacy()
             for i, word in enumerate(words):
                 self._ac.insert(i, word)
             self._ac.build()