✨ feat(dp优化): divide

Author: 981377660LMT

11_动态规划/acwingdp专项练习/环形与后效性处理/213. 打家劫舍 II-环形分类讨论.py

@@ -25,26 +25,19 @@ def dfs(index: int, hasPre: bool, root: bool) -> int:
 
     def rob2(self, nums: List[int]) -> int:
         """dp 考虑第一个选还是不选"""
-        n = len(nums)
-        if n == 1:
-            return nums[0]
-
-        dp = [[[0, 0] for _ in range(2)] for _ in range(n)]  # (index,pre,root) [不选 选]
-        dp[0][1][1] = nums[0]
-        for i in range(1, n):
-            for pre in range(2):
-                for cur in range(2):
-                    if pre == cur == 1:
-                        continue
-                    for root in range(2):
-                        dp[i][cur][root] = max(
-                            dp[i][cur][root], dp[i - 1][pre][root] + (cur and nums[i])
-                        )
-
-        res = -INF
-        for pre in range(2):
-            for root in range(2):
-                if pre == root == 1:
-                    continue
-                res = max(res, dp[n - 1][pre][root])
-        return res
+        if not nums:
+            return 0
+
+        def cal0() -> int:  # 不偷第一个(i的范围是[1, n-1])
+            dp0, dp1 = 0, 0
+            for i in range(1, len(nums)):
+                dp0, dp1 = max(dp0, dp1), max(dp0 + nums[i], dp1)
+            return max(dp0, dp1)
+
+        def cal1() -> int:  # 偷第一个(i的范围是[2, n-2])
+            dp0, dp1 = 0, 0
+            for i in range(2, len(nums) - 1):
+                dp0, dp1 = max(dp0, dp1), max(dp0 + nums[i], dp1)
+            return max(dp0, dp1)
+
+        return max(cal0(), cal1() + nums[0])

11_动态规划/dp优化/OfflineOnline.go

@@ -0,0 +1,115 @@
+// 単調最小値DP (aka. 分割統治DP) 优化 offlineDp
+// https://ei1333.github.io/library/dp/divide-and-conquer-optimization.hpp
+// !用于高速化 dp[k][j]=min(dp[k-1][j]+f(i,j)) (0<=i<j) 一般是dp[remain][index]
+//  如果f满足决策单调性 那么对转移的每一行，可以采用 monotoneminima 寻找最值点
+//  O(kn^2)优化到O(knlogn)
+
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+const INF int = 1e18
+
+//  !dist(i,j): 左闭右开区间[i,j)的代价(0<=i<j<=n)
+func divideAndConquerOptimization(k, n int, dist func(i, j int) int) [][]int {
+	dp := make([][]int, k+1)
+	for i := range dp {
+		dp[i] = make([]int, n+1)
+		for j := range dp[i] {
+			dp[i][j] = INF // !INF if get min
+		}
+	}
+	dp[0][0] = 0
+
+	for i := 1; i <= k; i++ {
+		getCost := func(y, x int) int {
+			if x >= y {
+				return INF
+			}
+			return dp[i-1][x] + dist(x, y)
+		}
+		res := monotoneminima(n+1, n+1, getCost)
+		for j := 0; j <= n; j++ {
+			dp[i][j] = res[j][1]
+		}
+	}
+
+	return dp
+}
+
+func monotoneminima(H, W int, dist func(i, j int) int) [][2]int {
+	dp := make([][2]int, H) // dp[i] 表示第i行取到`最小值`的(索引,值)
+
+	var dfs func(top, bottom, left, right int)
+	dfs = func(top, bottom, left, right int) {
+		if top > bottom {
+			return
+		}
+
+		mid := (top + bottom) / 2
+		index := -1
+		res := 0
+		for i := left; i <= right; i++ {
+			tmp := dist(mid, i)
+			if index == -1 || tmp < res { // !less if get min
+				index = i
+				res = tmp
+			}
+		}
+		dp[mid] = [2]int{index, res}
+		dfs(top, mid-1, left, index)
+		dfs(mid+1, bottom, index, right)
+	}
+
+	dfs(0, H-1, 0, W-1)
+	return dp
+}
+
+//
+//
+//
+// 给你一个房屋数组houses 和一个整数 k ，
+// 其中 houses[i] 是第 i 栋房子在一条街上的位置，
+// 现需要在这条街上安排 k 个邮筒。
+// 请你返回每栋房子与离它最近的邮筒之间的距离的 最小 总和。
+// !dp[k][n] 表示将[1,n]分成k段时的最优解
+// !dp[i][j]=min(dp[i-1][k]+f(k,j)) (k<j) f是一个Monotone函数
+func minDistance(houses []int, k int) int {
+	sort.Ints(houses)
+
+	// 求距离的函数
+	n := len(houses)
+	memo := make([][]int, n+1)
+	for i := range memo {
+		memo[i] = make([]int, n+1)
+		for j := range memo[i] {
+			memo[i][j] = -1
+		}
+	}
+	var dist func(i, j int) int
+	dist = func(i, j int) int {
+		if i >= j {
+			return 0
+		}
+		if memo[i][j] != -1 {
+			return memo[i][j]
+		}
+		res := houses[j] - houses[i] + dist(i+1, j-1)
+		memo[i][j] = res
+		return res
+	}
+
+	dist2 := func(i, j int) int {
+		return dist(i, j-1)
+	}
+	dp := divideAndConquerOptimization(k, n, dist2)
+	return dp[k][n]
+}
+
+func main() {
+	// houses = [7,4,6,1], k = 1
+	fmt.Println(minDistance([]int{7, 4, 6, 1}, 1))
+}

11_动态规划/dp优化/分治/divideAndConquerOptimization.go

@@ -0,0 +1,73 @@
+// 决策单调性(Monotone)
+// Monge(四边形不等式) ⇒ Totally Monotone(TM) ⇒ Monotone なので、Monotone は弱い条件である。
+// https://ei1333.github.io/luzhiled/snippets/dp/monotone-minima.html
+// https://beet-aizu.github.io/library/algorithm/monotoneminima.cpp
+
+// 对于一个二元函数f(i,j) (0<=i<H, 0<=j<W),
+// !如果对任意 p<q 满足 argmin(f(p,*))<=argmin(f(q,*)),
+// !即f(i,j)取到最小值时,j如果变大,i也变大,则称f(i,j)是关于i Monotone 的.
+// !例如 f(i,j)=nums[j]+(j-i)^2 是关于i的Monotone函数(一次函数)
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// !dist(i,j): 闭区间[i,j]的代价(0<=i<=j<=W-1)
+func monotoneminima(H, W int, dist func(i, j int) int) [][2]int {
+	dp := make([][2]int, H) // dp[i] 表示第i行取到`最小值`的(索引,值)
+
+	var dfs func(top, bottom, left, right int)
+	dfs = func(top, bottom, left, right int) {
+		if top > bottom {
+			return
+		}
+
+		mid := (top + bottom) / 2
+		index := -1
+		res := 0
+		for i := left; i <= right; i++ {
+			tmp := dist(mid, i)
+			if index == -1 || tmp < res { // less
+				index = i
+				res = tmp
+			}
+		}
+		dp[mid] = [2]int{index, res}
+		dfs(top, mid-1, left, index)
+		dfs(mid+1, bottom, index, right)
+	}
+
+	dfs(0, H-1, 0, W-1)
+	return dp
+}
+
+func main() {
+	// AtCoder COLOCON -Colopl programming contest 2018- Final C - スペースエクスプローラー高橋君
+	// https://blog.hamayanhamayan.com/entry/2018/01/21/161336
+	// 给定长为n的数组a (n<=2e5)
+	// !对每个i 求 a[j]+(j-i)^2 的最小值
+	// 也可以用Convex Hull Trick 求出
+
+	in := bufio.NewReader(os.Stdin)
+	out := bufio.NewWriter(os.Stdout)
+	defer out.Flush()
+
+	var n int
+	fmt.Fscan(in, &n)
+	nums := make([]int, n)
+	for i := 0; i < n; i++ {
+		fmt.Fscan(in, &nums[i])
+	}
+
+	dist := func(i, j int) int {
+		return nums[j] + (j-i)*(j-i)
+	}
+	res := monotoneminima(n, n, dist)
+	for i := 0; i < n; i++ {
+		fmt.Fprintln(out, res[i][1])
+	}
+}

11_动态规划/dp优化/分治/monotoneminima.go

@@ -0,0 +1,12 @@
+offlineDp -> onlineDp (オフライン・オンライン変換)
+
+- offlineDp 可以理解为区间分 k 组的这种 dp
+  dp[k][j]=min(dp[k-1][j]+f(i,j)) (i<j)
+
+  - 如果代价函数 f(i,j) 是决策单调(Monotone)的，那么可以用分治 dp 优化，时间复杂度从 `O(n^2*k)` 降到 `O(n*logn*k)`
+    > 备注: Monge ⇒ Totally Monotone(TM) ⇒ Monotones，即满足四边形不等式的函数一定满足决策单调性
+
+- onlineDp 可以理解为不分组的这种 dp
+  dp[j]=min(dp[i]+f(i,j)) (i<j)
+  - 如果 offline 问题存在复杂度 O(M(n))的解,那么 online 问题存在复杂度 O(M(n)logn)的解
+  - 如果 f 可以拆成 i 的一次函数,那么可以用 CHT(ConvexHullTrick) 优化 dp

11_动态规划/dp优化/分治/note.md

@@ -0,0 +1,127 @@
+// offline dp: 区间分成k等分 dp[k][j]=min(dp[k-1][i]+f(i,j)) (0<=i<j) (dfsIndexRemain)
+// online dp: 区间分成任意分 dp[j]=min(dp[i]+f(i,j)) (0<=i<j) (dfsIndex)
+
+// !https://qiita.com/tmaehara/items/0687af2cfb807cde7860 (深度好文)
+// https://beet-aizu.github.io/library/algorithm/offlineonline.cpp
+// https://ei1333.github.io/library/dp/online-offline-dp.hpp
+
+// オフライン・オンライン変換：
+// !如果offline问题存在复杂度O(M(n))的解,那么online问题存在复杂度O(M(n)logn)的解
+// dp[j]=min(dp[i]+f(i,j)) (0<=i<j)
+// O(n^2)优化到O(nlogn^2)
+// 例子:
+// !dp[j]=min(dp[i]+(x[j]-x[i]-a)^2)
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// !dist(i,j): 左闭右开区间[i,j)的代价(0<=i<j<=n)
+func offlineOnlineDp(n int, dist func(i, j int) int) int {
+	dp := make([]int, n+1)
+	used := make([]bool, n+1)
+	used[n] = true
+
+	update := func(k, val int) {
+		if !used[k] {
+			dp[k] = val
+		}
+		dp[k] = min(dp[k], val) // min if get min
+		used[k] = true
+	}
+
+	var dfs func(top, bottom, left, right int) // induce
+	dfs = func(top, bottom, left, right int) {
+		if top == bottom {
+			return
+		}
+		mid := (top + bottom) / 2
+		index := left
+		res := dist(mid, index) + dp[index]
+		for i := left; i <= right; i++ {
+			tmp := dist(mid, i) + dp[i]
+			if tmp < res { // !less if get min
+				res = tmp
+				index = i
+			}
+		}
+
+		update(mid, res)
+		dfs(top, mid, left, index)
+		dfs(mid+1, bottom, index, right)
+	}
+
+	var solve func(left, right int)
+	solve = func(left, right int) {
+		if left+1 == right {
+			update(left, dist(left, right)+dp[right])
+			return
+		}
+		mid := (left + right) / 2
+		solve(mid, right)
+		dfs(left, mid, mid, right)
+		solve(left, mid)
+	}
+
+	solve(0, n)
+	return dp[0]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func main() {
+	// 垃圾回收
+	// https://yukicoder.me/problems/no/705
+	// 公园里有n个垃圾
+	// n个人准备去回收垃圾,
+	// 每个人的起点在(startsi,0),沿x轴顺序递增排列
+	// 每个垃圾的位置在(xi,yi),沿x轴顺序递增排列
+	// !每个人只能回收他左边的垃圾
+	// 每个人i回收垃圾j,j+1,...,i(0<=j<=i)的时间花费为
+	// 1.曼哈顿距离的平方2.曼哈顿距离3.曼哈顿距离的三次方
+	// !求回收所有垃圾的最短时间之和
+	// dp[i]表示前i个人回收完前i个垃圾时的最短花费
+	// dp[i]=min(dp[j]+abs((xi-xj))^2+yj^2) (0<=j<=i)
+
+	in := bufio.NewReader(os.Stdin)
+	out := bufio.NewWriter(os.Stdout)
+	defer out.Flush()
+
+	var n int
+	fmt.Fscan(in, &n)
+	starts, xs, ys := make([]int, n), make([]int, n), make([]int, n)
+	for i := 0; i < n; i++ {
+		fmt.Fscan(in, &starts[i])
+	}
+	for i := 0; i < n; i++ {
+		fmt.Fscan(in, &xs[i])
+	}
+	for i := 0; i < n; i++ {
+		fmt.Fscan(in, &ys[i])
+	}
+
+	dist := func(i, j int) int {
+		// 0<=i<j<=n
+		a := abs(starts[j-1] - xs[i])
+		b := abs(ys[i])
+		return a + b
+	}
+	res := offlineOnlineDp(n, dist)
+	fmt.Fprintln(out, res)
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}