HDU 5115 Dire Wolf（区间dp）

问题

HDU 5115 Dire Wolf - https://acm.hdu.edu.cn/showproblem.php?pid=5115

概述

• 方法：区间dp
• 对于一个区间 $[l，r]$，设最后打败的编号是 $k(l\le k\le r)$，则问题可以分解为两个子问题，即 $[l，k-1]$和$[k+1，r]$，因此遍历 $k$ 后即得区间 $[l，r]$ 的解

4维状态设计

分析

• $dp[L][l][r][R]$：当区间 $[l，r]$ 的左、右邻居是 $L$ 和 $R$ 时，打败这个区间内的狼需要的最小能量
• 为什么是 $4$ 维的状态空间？
• 因为区间 $[l，r]$ 需要的最小能量与 $L、R$ 有关，也就是说若只考虑 $l、r$ ，则不具有“无后效性”
• 当 $[l，k-1]$ 和 $[k+1，r]$ 区间内的狼被打败后，$L，k，R$ 相邻，此时要打败 $k$需要的能量为：

b[L] + a[k] + b[R] // 这里是dp[L][k][k][R]而不是dp[k][k]，也说明了不满足“无后效性”

• 状态转移方程为

dp[L][l][r][R] = min(dp[L][l][r][R], dp[L][l][k-1][k] + b[L] + a[k] + b[R] + dp[k][k+1][r][R]);

• 空间复杂度是：$O(n^4)$
• 时间复杂度是：$O(n^5)$。原因：dp数组的每一个值的确定复杂度是 $O(n)$

代码

/* HDU 5115 Dire Wolf, 4维dp */
#include<bits/stdc++.h>
using namespace std;
const int MXN = 55; // 210;
const int inf = 0x7f7f7f7f;
int n, a[MXN], b[MXN], dp[MXN][MXN][MXN][MXN];
int dfs(int L, int l, int r, int R){
	int &DP = dp[L][l][r][R];
	if(DP < inf) return DP;
	int x, y;
	for(int i = l; i <= r; ++i){
		x = l <= i-1 ? dfs(L, l, i-1, i) : 0;
		y = i+1 <= r ? dfs(i, i+1, r, R) : 0;
		DP = min(DP, x + b[L] + a[i] + b[R] + y);
	}
	return DP;
}
int main(){
	int t;
	scanf("%d", &t);
	while(t--){
		scanf("%d", &n);
		memset(dp, 0x7f, sizeof dp);
		for(int i = 1; i <= n; ++i) scanf("%d", a+i);
		for(int i = 1; i <= n; ++i) scanf("%d", b+i);
		b[0] = b[n+1] = 0;
		printf("%d\n", dfs(0, 1, n, n+1));
	}	
    return 0;
}

2维状态设计

分析

• 对于区间 $[l，r]$，它的左邻居 $L$ 总有 $L=l-1$，右邻居 $R$ 总有 $R=r+1$，在4维状态设计的代码中清晰的体现了这一点
• 首先，在 dfs 调用入口，满足 $L=l-1，R=r+1$

dfs(0, 1, n, n+1)

• 其次，在 dfs 的递归定义中，因调用入口满足 $L=l-1，R=r+1$，所以递归调用时也满足

int dfs(int L, int l, int r, int R){ // 调用入口满足：L = l -1， R = r + 1
	int &DP = dp[L][l][r][R];
	if(DP < inf) return DP;
	int x, y;
	for(int i = l; i <= r; ++i){
		x = l <= i-1 ? dfs(L, l, i-1, i) : 0; // L = l - 1, i = (i - 1) + 1
		y = i+1 <= r ? dfs(i, i+1, r, R) : 0; // i = (i + 1) - 1, R = r + 1
		DP = min(DP, x + b[L] + a[i] + b[R] + y);
	}
	return DP;
}

• 因此，4维状态设计 $\stackrel{优化}{\Rightarrow }$ 2维状态设计

代码

/* HDU 5115 Dire Wolf, 2维dp */
#include<bits/stdc++.h>
using namespace std;
const int MXN = 210;
const int inf = 0x7f7f7f7f;
int n, a[MXN], b[MXN], dp[MXN][MXN];
int dfs(int l, int r){
	int &DP = dp[l][r];
	if(DP < inf) return DP;
	if(l > r) return DP = 0;
	for(int i = l; i <= r; ++i)
		DP = min(DP,dfs(l,i-1)+b[l-1]+a[i]+b[r+1]+dfs(i+1,r));
	return DP;
}
int main(){
	int t, T = 0;
	scanf("%d", &t);
	while(t--){
		scanf("%d", &n);
		memset(dp, 0x7f, sizeof dp);
		for(int i = 1; i <= n; ++i) scanf("%d", a+i);
		for(int i = 1; i <= n; ++i) scanf("%d", b+i);
		b[0] = b[n+1] = 0;
		printf("Case #%d: %d\n", ++T, dfs(1, n));
	}	
    return 0;
}

随机序 $\Rightarrow$ 区间序 $\Rightarrow$ dfs序

随机序

• 设有共有10只狼，有6只狼被打败，且先后序为：$274958$

区间序

• 交换不相邻的区间内的狼的序不影响结果
• 被打败的狼分布在 $3$ 个独立的连续的区间中，分别是$[2，2]、[4，5]、[7，9]$
  • 在$[2，2]$ 内，狼被打败的序为：$2$
  • 在$[4，5]$ 内，狼被打败的序为：$45$
  • 在$[7，9]$ 内，狼被打败的序为：$798$
  • 若按照区间优先的原则，将打狼次序调整为：$245798$，易证所需能量最小值不变

dfs序

• 一个区间的随机序对应了一个 dfs 序
• 上述例子中，在$[7，9]$ 内的打狼 $798$，对应了dfs后序遍历
• 再如： 设有共有10只狼，10只狼被打败的序为：$10274958136$
  • 首先：6 是根，$[1，5]$ 和 $[7，10]$ 是子树，因此根据区间调整打狼次序，调整后为$$[24513][10798]6$$
  • 其次：调整 $[1，5]$ 内的序，其中3是根，依次类推……
  • 然后：调整 $[7，10]$ 内的序，其中8是根，依次类推……
  • 最终调整为：$21453710986$