Contest 2050 and Codeforces Round #718 (Div. 1 + Div. 2) - D (棋盘式DP)

D. Explorer Space

题意
给定一个 n*m 的棋盘，相邻两个位置之间移动有对应花费 $w_{i,j}$。
问，从每个位置出发，走 k 步回到该位置的最小花费？位置可以重复走。

$2\le n,m\le 500,1\le k\le 20,1\le w\le 10^6$

思路
走 k 步回到原位置有两种走法：
1，走到一个位置之后原路返回到起点；
2，绕一圈回到起点。

对于第二种走法，可以证明其一定不会比第一种走法更优：
假设第二种走法是最优解，那么从起点到路径中点的距离一定和从中点回到起点的距离（如果两段路程有一段较小的话，肯定会走两遍这个较小的路程，而不会走两段），那么总路程也就相当于走到中点原路返回到起点，就是第一种情况。

所以只需要看走到哪个位置之后原路返回即可。
也就是求，从起点 (x, y) 走 k/2 步到某个位置的最短距离，即从某个位置走 k/2 步到 (x, y) 点的最短距离。

考虑DP。
定义状态 f[i, j, k] 表示，到达 (i, j) 点时，走了 k 步的最短距离。
状态转移：从 (i, j) 点的四个相邻位置来转移，到达 (tx, ty) 点时走了 k-1 步的最短距离 + 当前边权 w。

for(int k=1;k<=sum/2;k++)
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			int up = f[i-1][j][k-1] + d[i-1][j];
			int down = f[i+1][j][k-1] + d[i][j];
			int left = f[i][j-1][k-1] + r[i][j-1];
			int right = f[i][j+1][k-1] + r[i][j];
			f[i][j][k] = min(f[i][j][k], up);
			f[i][j][k] = min(f[i][j][k], down);
			f[i][j][k] = min(f[i][j][k], left);
			f[i][j][k] = min(f[i][j][k], right);
		}
	}
}

同样可以用记忆化搜索来实现：

int dfs(int x, int y, int k)
{
	if(f[x][y][k] != 0x3f3f3f3f) return f[x][y][k];
	
	for(int i=0;i<4;i++)
	{
		int tx = x+dir[i][0], ty = y+dir[i][1];
		if(tx < 1 || tx > n || ty < 1 || ty > m) continue;
		
		int w;
		if(i==0) w = d[x][y];
		if(i==1) w = d[tx][ty];
		if(i==2) w = r[x][y];
		if(i==3) w = r[tx][ty];
		
		f[x][y][k] = min(f[x][y][k], dfs(tx, ty, k-1) + w);
	}
	return f[x][y][k];
}

Code
DP：

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)

const int N = 510, mod = 1e9+7;
int T, n, m;
int a[N], sum;
int f[N][N][21];
int r[N][N], d[N][N];

signed main(){
	Ios;
	cin >> n >> m >> sum;
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<m;j++)
			cin >> r[i][j];
	for(int i=1;i<n;i++)
		for(int j=1;j<=m;j++)
			cin >> d[i][j];
			
	if(sum%2){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				cout << -1 << " ";
			}
			cout << endl;
		}
		return 0;
	}
	
	mem(f, 0x3f);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			f[i][j][0] = 0;
	
	for(int k=1;k<=sum/2;k++)
	{
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				int up = f[i-1][j][k-1] + d[i-1][j];
				int down = f[i+1][j][k-1] + d[i][j];
				int left = f[i][j-1][k-1] + r[i][j-1];
				int right = f[i][j+1][k-1] + r[i][j];
				f[i][j][k] = min(f[i][j][k], up);
				f[i][j][k] = min(f[i][j][k], down);
				f[i][j][k] = min(f[i][j][k], left);
				f[i][j][k] = min(f[i][j][k], right);
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cout << f[i][j][sum/2]*2 << " ";
		}
		cout << endl;
	}
	
	return 0;
}

记忆化搜索：

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)

const int N = 510, mod = 1e9+7;
int T, n, m;
int a[N];
int f[N][N][21];
int r[N][N], d[N][N];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

int dfs(int x, int y, int k)
{
	if(f[x][y][k] != 0x3f3f3f3f) return f[x][y][k];
	
	for(int i=0;i<4;i++)
	{
		int tx = x+dir[i][0], ty = y+dir[i][1];
		if(tx < 1 || tx > n || ty < 1 || ty > m) continue;
		
		int w;
		if(i==0) w = d[x][y];
		if(i==1) w = d[tx][ty];
		if(i==2) w = r[x][y];
		if(i==3) w = r[tx][ty];
		
		f[x][y][k] = min(f[x][y][k], dfs(tx, ty, k-1) + w);
	}
	return f[x][y][k];
}

signed main(){
	Ios;
	int sum;
	cin >> n >> m >> sum;
	
	mem(f, 0x3f);
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<m;j++)
			cin >> r[i][j];
	for(int i=1;i<n;i++)
		for(int j=1;j<=m;j++)
			cin >> d[i][j];
	
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)		
			f[i][j][0] = 0;
			
	if(sum % 2){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				cout << -1 << " ";
			}
			cout << endl;
		}
		return 0;
	}
	
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cout << dfs(i, j, sum/2)*2 <<" ";
		}
		cout << endl;
	}
	
	return 0;
}

但有个问题不明白：
它的这个移动轨迹是不是从起点出发，走到一个点之后，和另一个点之间反复跳，跳完之后原路返回到起点？
如果是这样的话，那么照这个思路直接搜为什么不对呢？

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)
#define int long long
#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'
map<PII, int> mp;

/**/

const int N = 2010, mod = 1e9+7;
int T, n, m;
int a[N], k;
int r[N][N], d[N][N];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int ans;

struct node{
	int x, y, step, sum;
};

void bfs(int stx, int sty)
{
	queue<node> que;
	que.push({stx, sty, 0, 0});
	
	while(que.size())
	{
		int x = que.front().x, y = que.front().y, step = que.front().step, sum = que.front().sum;
		que.pop();
		
		if(2 * step > k) continue;
		
		for(int i=0;i<4;i++)
		{
			int tx = x+dir[i][0], ty = y+dir[i][1];
			if(tx < 1 || ty < 1 || tx > n || ty > m) continue;
			if(mp[{tx, ty}]) continue;
			mp[{tx, ty}] = 1;
			
			int w;
			if(i==0) w = d[x][y];
			if(i==1) w = d[tx][ty];
			if(i==2) w = r[x][y];
			if(i==3) w = r[tx][ty];
			
			if((k-step*2) % 2 == 0)
				ans = min(ans, sum*2 + (k-step*2)*w);
			
			que.push({tx, ty, step+1, sum+w});
		}
	}
}

signed main(){
	Ios;
	cin >> n >> m >> k;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<m;j++)
		{
			cin >> r[i][j];
		}
	}
	for(int i=1;i<n;i++)
	{
		for(int j=1;j<=m;j++){
			cin >> d[i][j];
		}
	}
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			ans = 1e9;
			mp.clear();
			mp[{i, j}] = 1;
			bfs(i, j);
			if(ans != 1e9) cout << ans << " ";
			else cout << -1 << " ";
		}
		cout << endl;
	}
	
	return 0;
}

场上做的时候根本没想到DP，棋盘式DP几乎没做过。。