算法训练 方格取数

题目链接: P1004 [NOIP2000 提高组] 方格取数

时间限制：C/C++ 1000MS，其他语言 2000MS
内存限制：C/C++ 512MB，其他语言 1024MB

题目背景

NOIP 2000 提高组 T4

题目描述

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

某人从图的左上角的 $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

提示

数据范围：$1\le N\le 9$。

---

题目思路

目标

在一个 $N\times N$ 的方格图中，有些方格填入正整数，其他方格为 0。我们需要找到两条从左上角 (1,1) 到右下角 (N,N) 的路径，使得两条路径上取得的数之和最大。

思路

1. 状态定义:

   • 定义四维数组 f[i][j][k][l]，表示第一个人走到 (i, j)，第二个人走到 (k, l) 时，取得的最大和。

2. 初始化:

   • 初始化 f 数组为 0，表示起始状态。

3. 状态转移:

   • 对于每个位置 (i, j) 和 (k, l)，使用以下转移方程：
   • $f[i][j][k][l]=\max \left(\max (f[i-1][j][k-1][l],f[i-1][j][k][l-1]),\max (f[i][j-1][k-1][l],f[i][j-1][k][l-1])\right)+a[i][j]$
   • 如果 (i, j) 和 (k, l) 不重合，额外加上 a[k][l]：$f[i][j][k][l]+=a[k][l]\text{(如果 }i\ne k\text{ 且 }j\ne l\text{)}$

4. 边界条件:

   • 处理边界情况，确保不越界访问数组。

5. 结果输出:

   • 最终结果为 f[n][n][n][n]，表示两人都到达右下角时的最大和。

算法复杂度

• 时间复杂度为 $O(N^4)$，由于需要遍历四个维度的数组。
• 空间复杂度为 $O(N^4)$，用于存储状态。

通过这种方式，我们能够有效地计算出两条路径上取得的最大和。

---

AC代码：

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

int a[15][15];
int f[15][15][15][15];  //存储由i,j到k,l 的最大和。

int main()
{
	int n;
	cin >> n;
	int x, y, v;
	while (cin >> x >> y >> v && (x != 0 && y != 0 && v != 0))
	{
		a[x][y] = v;
	}
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			for (int k = 1; k <= n; k++)
			{
				for (int l = 1; l <= n; l++)
				{
					f[i][j][k][l] = max(max(f[i - 1][j][k - 1][l], f[i - 1][j][k][l - 1]), max(f[i][j - 1][k - 1][l], f[i][j - 1][k][l - 1])) + a[i][j];
					if (i != k && j != l)
						f[i][j][k][l] += a[k][l]; //如果位置 (i, j) 和 (k, l) 不重合（即 i != k && j != l），则还需要加上两个位置的值，即 f[i][j][k][l] += a[k][l]。
					//走到位置 (i, j)，走到位置 (k, l) 时，取得的最大和。
				}
			}
		}
	}
	cout << f[n][n][n][n] << endl;
	return 0;
}

/**
* @runId: 20217
* @language: C++
* @author: Samuel777
* @submitTime: 2024-08-14 21:23:07
*/

二维数组解法：

#include<cstdio>
#include<iostream>
using namespace std;
const int N=11;
int dp1[N][N],dp2[N][N],n,o;
struct point
{
	int x;
	int y;
	int num;
}poi[N*N];
void find(int k,int l)//判断第一遍走过哪些点 
{
	if(k==0&&l==0)
	{
		return;
	}
	else
	{
		if(dp1[k][l]-dp2[k][l]==dp1[k-1][l])
	    {  
		    dp2[k][l]=0;
		    find(k-1,l); 
	    }
	    else if(dp1[k][l]-dp2[k][l]==dp1[k][l-1])
	    {
		    dp2[k][l]=0;
		    find(k,l-1);
	    }
	}
}
int main()
{
	scanf("%d",&n);
	for(;;)
	{
		o++;
		scanf("%d%d%d",&poi[o].x,&poi[o].y,&poi[o].num);
		if(poi[o].x==poi[o].y&&poi[o].y==poi[o].num&&poi[o].num==0)
		{
			break;
		}
		else
		{
			dp1[poi[o].x][poi[o].y]=poi[o].num;
			dp2[poi[o].x][poi[o].y]=poi[o].num;
		}
	}
	for(int i=1;i<=n;i++)//第一遍的最优解 
	{
		for(int j=1;j<=n;j++)
		{
			dp1[i][j]+=max(dp1[i-1][j],dp1[i][j-1]);
		}
	}
	find(n,n);
	for(int i=1;i<=n;i++)//第二遍的最优解 
	{
		for(int j=1;j<=n;j++)
		{
			dp2[i][j]+=max(dp2[i-1][j],dp2[i][j-1]);
		}
	}
	printf("%d",dp1[n][n]+dp2[n][n]);//输出答案 
	return 0;
}