FatMouse and Cheese——记忆化搜索、DAG+dp

FatMouse and Cheese

---

题意：
给定 $n\ast n$ 的矩阵，每个格子有一个权值。
现在从格子 $(1,1)$ 出发，每次可以径直走 1~k 个格子，需要保证走到的格子的权值要大于当前格子的权值。
问，当走到不能走的时候，所走过的路径权值之和最大是多少？

方法1：记忆化搜索。
每个点存储从该点出发，走到不能走的时候，走过路径权值和的最大值。从起点开始 dfs，如果走到一个点有存储，说明之前走过，直接用；否则这个点之前没走过，走一遍记录最大值。
这样，每个点只会搜一次，时间复杂度为 $O(n\ast m)$。

//https://zoj.pintia.cn/problem-sets/91827364500/problems/91827364606
#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<int,int> mp;

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

int dfs(int x, int y)
{
	f[x][y] = 0;
	
	for(int i=1;i<=k;i++)
		for(int j=0;j<4;j++)
		{
			int tx = x+dir[j][0]*i, ty = y+dir[j][1]*i;
			if(tx < 1 || ty < 1 || tx > n || ty > n) continue;
			if(a[tx][ty] <= a[x][y]) continue;
			
			if(f[tx][ty]) f[x][y] = max(f[x][y], f[tx][ty]);
			else f[x][y] = max(f[x][y], dfs(tx, ty));
		}
		
	f[x][y] += a[x][y];
	return f[x][y];
}

signed main(){
	Ios;
	while(cin>>n>>k && n!=-1)
	{
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				cin>>a[i][j], f[i][j] = 0;
		
		dfs(1, 1);
		
		cout << f[1][1] << endl;
	}
	
	return 0;
}

---

方法2：DAG+dp，有向无环图上按照拓扑序dp。
从小权值的点始终向大权值的点走，有向并且不会出现环。有向无环图，存在拓扑序。按照拓扑序进行 dp，保证了 dp 的无后效性。

因为起点给定了，所以定义 f[i, j]：以 (i, j) 为起点的最大价值路径。
从较大价值的点向较小价值的点连边。

从起点到终点，点权递增。
所以起点是较小价值的点，这个题的最终状态在于较小价值的点，所以需要先把较大价值的点处理出来。
所以从较大价值的点向较小价值的点连边。

状态更新：由较大价值的点更新较小价值的点。

#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<int,int> mp;

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

void topsort()
{
	queue<PII> que;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			if(!ru[i][j]) que.push({i, j}), f[i][j]=a[i][j];

	while(que.size())
	{
		int x = que.front().fi, y = que.front().se;
		que.pop();
		
		for(int i=1;i<=k;i++)
		{
			for(int j=0;j<4;j++)
			{
				int tx = x+dir[j][0]*i, ty = y+dir[j][1]*i;
				if(tx < 1 || ty < 1 || tx > n || ty > n) continue;
				if(a[tx][ty] >= a[x][y]) continue;
				
				f[tx][ty] = max(f[tx][ty], f[x][y] + a[tx][ty]);
				ru[tx][ty]--;
				if(ru[tx][ty] == 0) que.push({tx, ty});
			}
		}
	}
}

signed main(){
	Ios;
	while(cin>>n>>k && n!=-1)
	{
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				cin>>a[i][j], ru[i][j]=0, f[i][j]=0;
		
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				for(int p=1;p<=k;p++)
				{
					for(int q=0;q<4;q++)
					{
						int tx = i+dir[q][0]*p, ty = j+dir[q][1]*p;
						if(tx < 1 || ty < 1 || tx > n || ty > n) continue;
						if(a[tx][ty] < a[i][j]) ru[tx][ty]++;
					}
				}
			}
		
		topsort();
		
		cout << f[1][1] << endl;
	}
	
	
	return 0;
}

---

经验：
可以发现，对于记忆化搜索的题目可以转化为DAG+dp来处理。而后者有时可以处理前者不能处理的问题。
比如这道题，如果加上一个条件，所经过路径长度不少于4，求路径的最大值。这样的话用记忆化搜索就不容易维护了，但是用 dp 却很简单，多开一维记录路径长度就行了。
所以以后遇到记忆化搜索的题目两种方法都要写一下。