HDU 5115 Dire Wolf（区间dp）

Posted 2021-09-03 jpphy0

目录

• 问题
• 概述
• 4维状态设计
• • 分析
  • 代码
• 2维状态设计
• • 分析
  • 代码
• 随机序 $\Rightarrow$ 区间序 $\Rightarrow$ dfs序
• • 随机序
  • 区间序
  • dfs序

问题

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][l][r][R] = min(dp[L][l][r][R], dp[L][l][k-1][R] + b[L] + a[k] + b[R] + dp[L][k+1][r][R]);

• 时间、空间复杂度是：$O(n^4)$

代码

/* 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维状态设计 可以优化为 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]$ 是子树，因此根据区间调整打狼次序，调整后为 [ 2 4 5 1 3 ] [ 10 7 9 8 ] 6 [2\\quad 4\\quad 5\\quad 1\\quad 3]\\quad [10 \\quad 7\\quad 9\\quad8] \\quad 6\\quad [24动态规划（区间DP）：HDU 5115 Dire Wolf

    hdu 5115 Dire Wolf 区间dp

    Dire Wolf——HDU5115（区间DP）

    HDU 5115 Dire Wolf

    HDU5115 Dire Wolf

    HDU 5115 Dire Wolf