方格取数(动规)

题目描述

设有 $N\times N$ 的方格图 $(N\le 9)$，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 $0$。如下图所示（见样例）:

A
 0  0  0  0  0  0  0  0
 0  0 13  0  0  6  0  0
 0  0  0  0  7  0  0  0
 0  0  0 14  0  0  0  0
 0 21  0  0  0  4  0  0
 0  0 15  0  0  0  0  0
 0 14  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
                         B

某人从图的左上角的 $A$ 点出发，可以向下行走，也可以向右走，直到到达右下角的 $B$ 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 $0$）。
此人从 $A$ 点到 $B$ 点共走两次，试找出 $2$ 条这样的路径，使得取得的数之和为最大。

输入格式

输入的第一行为一个整数 $N$（表示 $N\times N$ 的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的 $0$ 表示输入结束。

输出格式

只需输出一个整数，表示 $2$ 条路径上取得的最大的和。

样例 #$1$

样例输入 #$1$

8
2 3 13
2 6  6
3 5  7
4 4 14
5 2 21
5 6  4
6 3 15
7 2 14
0 0  0

样例输出 #$1$

67

提示

也可以枚举，用上滚动数组。

$90$ pts

#include<bits/stdc++.h>
using namespace std;
int n;
bool b;
int a[20][20];
int f1[20][20];
int f2[20][20];
int ans,ans2;
int x,y,z;
int main() {
	cin>>n;
	while(cin>>x>>y>>z) {
		if(!x&&!y&&!z) {
			break;
		}
		f1[x][y]=z;
		f2[x][y]=z;
	}
	for(int i=1; i<=n; i++) {
		for(int j=1; j<=n; j++) {
			f1[i][j]+=max(f1[i-1][j],f1[i][j-1]);
		}
	}
	ans+=f1[n][n];
	ans2=ans;
	while(ans2>0) {
		for(int i=1; i<=n; i++) {
			for(int j=1; j<=n; j++) {
				if(f1[i][j]==ans2) {
					ans2-=f2[i][j];
					f2[i][j]=0;
					b=1;
					break;
				}
			}
			if(b==1) {
				b=0;
				break;
			}
		}
	}
	for(int i=1; i<=n; i++) {
		for(int j=1; j<=n; j++) {
			f2[i][j]+=max(f2[i-1][j],f2[i][j-1]);
		}
	}
	ans+=f2[n][n];
	cout<<ans;
	return 0;
}

作者开始时连续交了好几次，都是$80$&$90$分，看了几篇巨佬的题解，重写了一遍，这才$AC$.

AC Code

include<bits/stdc++.h>
using namespace std;
int n,i=0,ans=0;
struct P {
	int x,y;
	int t;
} p[128];
bool used[128]= {0};
vector<int> v[128];
bool judge(int a,int b) {
	if(a!=b&&p[b].x>=p[a].x&&p[b].y>=p[a].y) return 1;
	return 0;
}
void dfs(int a,int b,int s) {
	for(int j=0; j<v[a].size(); j++) {
		if(!used[v[a][j]]) {
			used[v[a][j]]=1;
			dfs(v[a][j],b,s+p[v[a][j]].t);
			used[v[a][j]]=0;
		}
	}
	for(int j=0; j<v[b].size(); j++) {
		if(!used[v[b][j]]) {
			used[v[b][j]]=1;
			dfs(a,v[b][j],s+p[v[b][j]].t);
			used[v[b][j]]=0;
		}
	}
	ans=max(ans,s);
}
int main() {
	cin>>n;
	while(1) {
		scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].t);
		if(p[i].x==0&&p[i].y==0&&p[i].t==0) break;
		i++;
	}
	for(int a=0; a<i; a++) {
		for(int b=0; b<i; b++) {
			if(judge(a,b)) v[a].push_back(b);
		}
	}
	for(int a=0; a<i-1; a++) {
		for(int b=a+1; b<i; b++) {
			used[a]=1;
			used[b]=1;
			dfs(a,b,p[a].t+p[b].t);
			used[a]=0;
			used[b]=0;
		}
	}
	cout<<ans;
	return 0;
}

说实话，此题看懂题意，再注意点就能做出来，还是较水的，主要是有些易错点有点难看出来，别忘了 ∽ 初始化 ∽ ！

对了，此题还可以用贪心搜索（greedy search）来做，因为此题的时间限制为$1.00s$，所以各位要记得剪枝。

此题的集束宽度需要限制的是对于每个点的每个估价值的路径状态个数，因为状态涉及到不同估价值和不同位置，所以用map离散化来维护。

之前走过的点可以用一个数组记录，因为数据范围小，所以每个状态都包含一个这样的数组记录已经取过的值。

本题需要跑两遍集束搜索（ beam search），一次从$(1,1)$$(1,1)$ 走到 $(n,n)$$(n,n)$，保留下到 $(n,n)$$(n,n)$ 的方案，再从 $(n,n)$$(n,n)$ 走回 $(1,1)$$(1,1)$。

#include <bits/stdc++.h>
using namespace std;
const int MAXN=10,MAXB=50;
int N;
struct STATE {
	int x,y,val;
	bool Use[MAXN][MAXN];
	STATE(int x_,int y_,int val_,bool Use_[MAXN][MAXN]) {
		x=x_;
		y=y_;
		val=val_;
		for(int i=1; i<=N; i++) {
			for(int j=1; j<=N; j++) {
				Use[i][j]=Use_[i][j];
			}
		}
		Use[x][y]=true;
	}
};
bool operator < (STATE x,STATE y) {
	return x.val<y.val;
}
vector<STATE>BEAM;
int a[MAXN][MAXN];
int hash_table[MAXN*MAXN];
int BEAM_SEARCH(int step) {
	map<int,int>Mp[MAXN][MAXN];
	if(step==1) {
		bool Use[MAXN][MAXN];
		memset(Use,0,sizeof(Use));
		Use[1][1]=true; //初始化
		BEAM.push_back(STATE(1,1,a[1][1],Use));
	}
	int Max=0;
	while(BEAM.size()>0) {
		priority_queue<STATE>q;
		bool flag=false;
		for(register int i=0; i<BEAM.size(); ++i) {
			int x=BEAM[i].x,y=BEAM[i].y;
			if(x==1&&y==1&&step==2) {
				Max=max(Max,BEAM[i].val);
				continue;
			}
			if((x!=N||y!=N)&&step==1) { //当状态全是(N,N)时说明已经跑完一次Beam Search算法了
				flag=true;
			}
			//搜索下一步能到的点
			if(step==1) {
				if(y+1<=N&&Mp[x][y+1][BEAM[i].val+a[x][y+1]]<=MAXB) { //限制状态数量，下同
					q.push(STATE(x,y+1,BEAM[i].val+a[x][y+1],BEAM[i].Use));
					Mp[x][y+1][BEAM[i].val+a[x][y+1]]++;
				}
				if(x+1<=N&&Mp[x+1][y][BEAM[i].val+a[x+1][y]]<+MAXB) {
					q.push(STATE(x+1,y,BEAM[i].val+a[x+1][y],BEAM[i].Use));
					Mp[x+1][y][BEAM[i].val+a[x+1][y]]++;
				}
			}
			if(step==2) {
				if(y-1>=1&&Mp[x][y-1][BEAM[i].val+(BEAM[i].Use[x][y-1]==true?0:a[x][y-1])]<=MAXB) {
					q.push(STATE(x,y-1,BEAM[i].val+(BEAM[i].Use[x][y-1]==true?0:a[x][y-1]),BEAM[i].Use));//三元运算符处理当下一步节点被取过的情况，下同
					Mp[x][y-1][BEAM[i].val+(BEAM[i].Use[x][y-1]==true?0:a[x][y-1])]++;
				}
				if(x-1>=1&&Mp[x-1][y][BEAM[i].val+(BEAM[i].Use[x-1][y]==true?0:a[x-1][y])]<=MAXB) {
					q.push(STATE(x-1,y,BEAM[i].val+(BEAM[i].Use[x-1][y]==true?0:a[x-1][y]),BEAM[i].Use));
					Mp[x-1][y][BEAM[i].val+(BEAM[i].Use[x-1][y]==true?0:a[x-1][y])]++;
				}
			}
		}
		if(flag==false&&step==1)
			return 0;
		BEAM.clear();
		while((!q.empty())&&BEAM.size()<MAXB*MAXB) { //状态数限制为MAXB个，而每一个状态的个数也有MAXB个，所以BEAM的大小要小于MAXB*MAXB个
			BEAM.push_back(q.top());
			q.pop();
		}
	}
	return Max;
}
int main() {
	cin>>N;
	while(true) {
		int x,y,z;
		cin>>x>>y>>z;
		if(x==0&&y==0&&z==0)
			break;
		a[x][y]=z;
	}
	BEAM_SEARCH(1);
	cout<<BEAM_SEARCH(2);
}

下午和晚上继续肝，争取一天$2$~$3$篇题解。