403格子取数问题

题目

有n*n个格子,每个格子里有正数或者0,从最左上角往最右下角走,只能向下和向右,一共走两次(即从左上角走到右下角走两趟),把所有经过的格子的数加起来,求最大值SUM,且两次如果经过同一个格子,则最后总和SUM中该格子的计数只加一次。

思路一:

一共需要搜索2n-2步,利用递归对所以可能进行枚举,两条路有四种走法,rr(右右),dd(下下),rd,dr,遇到边界就停止,同时记录最大的sum。

#define N 5
const int MAX = 1000000;
const int N2 = 102;

int map[N2][N2]={	
	{2,0,8,0,2},    
    {0,0,0,0,0},    
    {0,3,2,0,0},    
    {0,0,0,0,0},    
    {2,0,8,0,2}};

int sumMax = 0;
int p1x = 0;
int p1y = 0;
int p2x = 0;
int p2y = 0;
int curMax = 0;

void findGrid(int index)
{
	if(index == 2*N -2)
	{
		if(curMax>sumMax)
			sumMax = curMax;
		return ;
	}
	if(!(p1x==0 && p1y==0) && !(p2x==N-1 && p2y==N-1))
	{
		if(p1x>=p2x && p1y>=p2y)
			return ;
	}
	//rr
	if(p1x+1<N && p2x+1<N)
	{
		p1x++;p2x++;
		int sum = map[p1x][p1y] + map[p2x][p2y];
		curMax += sum;
		findGrid(index+1);
		curMax -= sum;
		p1x--;p2x--;
	}

	//dd
	if(p1y+1<N && p2y+1<N)
	{
		p1y++;p2y++;
		int sum = map[p1x][p1y] + map[p2x][p2y];
		curMax += sum;
		findGrid(index+1);
		curMax -= sum;
		p1y--;p2y--;
	}

	//rd
	if(p1x+1<N && p2y+1<N)
	{
		p1x++;p2y++;
		int sum = map[p1x][p1y] + map[p2x][p2y];
		curMax += sum;
		findGrid(index+1);
		curMax -= sum;
		p1x--;p2y--;
	}

	//dr
	if(p1y+1<N && p2x+1<N)
	{
		p1y++;p2x++;
		int sum = map[p1x][p1y] + map[p2x][p2y];
		curMax += sum;
		findGrid(index+1);
		curMax -= sum;
		p1y--;p2x--;
	}
}

int sumMax_2Paths()
{
	curMax = map[0][0];
	findGrid(0);
	return sumMax-map[N-1][N-1];
}

思路二:

动态规划

主要思路就是同时DP 2次所走的状态。

  1、先来分析一下这个问题,为了方便讨论,先对矩阵做一个编号,且以5*5的矩阵为例(给这个矩阵起个名字叫M1):
M1
0  1  2  3  4
1  2  3  4  5
2  3  4  5  6
3  4  5  6  7
4  5  6  7  8
  从左上(0)走到右下(8)共需要走8步(2*5-2)。我们设所走的步数为s。因为限定了只能向右和向下走,因此无论如何走,经过8步后(s = 8)都将走到右下。而DP的状态也是依据所走的步数来记录的。
  再来分析一下经过其他s步后所处的位置,根据上面的讨论,可以知道:

  • 经过8步后,一定处于右下角(8);
  • 那么经过5步后(s = 5),肯定会处于编号为5的位置;
  • 3步后肯定处于编号为3的位置;
  • s = 4的时候,处于编号为4的位置,此时对于方格中,共有5(相当于n)个不同的位置,也是所有编号中最多的。

  故推广来说,对于n*n的方格,总共需要走2n - 2步,且当s = n - 1时,编号为n个,也是编号数最多的
  如果用DP[s,i,j]来记录2次所走的状态获得的最大值,其中s表示走s步,i和j分别表示在s步后第1趟走的位置和第2趟走的位置。
  2、为了方便描述,再对矩阵做一个编号(给这个矩阵起个名字叫M2):
M2
0  0  0  0  0
1  1  1  1  1
2  2  2  2 2
3  3  3  3  3
4  4  4  4  4

    把之前定的M1矩阵也再贴下:
M1 
0  1  2  3  4
1  2  3  4  5
2  3  4  5  6
3  4  5  6  7
4  5  6  7  8
  我们先看M1,在经过6步后,肯定处于M1中编号为6的位置。而M1中共有3个编号为6的,它们分别对应M2中的2 3 4。故对于M2来说,假设第1次经过6步走到了M2中的2,第2次经过6步走到了M2中的4,DP[s,i,j] 则对应 DP[6,2,4]。由于s = 2n - 2,0 <= i<= <= j <= n,所以这个DP共有O(n^3)个状态。
M1
0  1  2  3  4
1  2  3  4  5
2  3  4  5  6
3  4  5  6  7
4  5  6  7  8
  再来分析一下状态转移,以DP[6,2,3]为例(就是上面M1中加粗的部分),可以到达DP[6,2,3]的状态包括DP[5,1,2],DP[5,1,3],DP[5,2,2],DP[5,2,3]。

  3、下面,我们就来看看这几个状态:DP[5,1,2],DP[5,1,3],DP[5,2,2],DP[5,2,3],用加粗表示位置DP[5,1,2]    DP[5,1,3]    DP[5,2,2]    DP[5,2,3] (加红表示要达到的状态DP[6,2,3]
0 1 2 3 4    0 1 2 3 4    0 1 2 3 4    0 1 2 3 4
1 2 3 4 5    1 2 3 4 5    1 2 3 4 5    1 2 3 4 5
2 3 4 6    2 3 4 5 6    2 3 4 6    2 3 4 6
3 4 5 6 7    3 4 6 7    3 4 5 6 7    3 4 6 7
4 5 6 7 8    4 5 6 7 8    4 5 6 7 8    4 5 6 7 8
  因此:

DP[6,2,3] = Max(DP[5,1,2] ,DP[5,1,3],DP[5,2,2],DP[5,2,3]) + 6,2和6,3格子中对应的数值    (式一) 

  上面(式一)所示的这个递推看起来没有涉及:“如果两次经过同一个格子,那么该数只加一次的这个条件”,讨论这个条件需要换一个例子,以DP[6,2,2]为例:DP[6,2,2]可以由DP[5,1,1],DP[5,1,2],DP[5,2,2]到达,但由于i = j,也就是2次走到同一个格子,那么数值只能加1次。
  所以当i = j时,

DP[6,2,2] = Max(DP[5,1,1],DP[5,1,2],DP[5,2,2]) + 6,2格子中对应的数值                          (式二

  4、故,综合上述的(式一),(式二)最后的递推式就是
if(i != j)
DP[s, i ,j] = Max(DP[s - 1, i - 1, j - 1], DP[s - 1, i - 1, j], DP[s - 1, i, j - 1], DP[s - 1, i, j]) + W[s,i] + W[s,j]
else
DP[s, i ,j] = Max(DP[s - 1, i - 1, j - 1], DP[s - 1, i - 1, j], DP[s - 1, i, j]) + W[s,i]

    其中W[s,i]表示经过s步后,处于i位置,位置i对应的方格中的数字。

int dp[N2*2][N2][N2];

bool isValid(int step, int x1, int x2, int n)//判断状态是否合法
{
	int y1=step-x1, y2=step-x2;
	bool flag = x1>=0 && x1<n && x2>=0 && x2<n && y1>=0 && y1<n && y2>=0 && y2<n ;
	return flag;
}

int getValue(int step, int x1, int x2, int n)//取值,如果越界取值为负无穷大数
{
	return isValid(step,x1,x2,n) ? dp[step][x1][x2]:(-MAX);
}

int findGrid(int a[N2][N2], int n)
{
	int P = n*2 -2;//步数
	int i,j,step;
	for(i=0;i<n;i++)//确立边界
	{
		for(j=0;j<n;j++)
		{
			dp[0][i][j] = -MAX;
		}
	}
	dp[0][0][0] = a[0][0];

	for(step=1;step<=P;++step)
	{
		for(i=0;i<n;i++)
		{
			for(j=i;j<n;j++)
			{
				dp[step][i][j] = -MAX;
				if(!isValid(step,i,j,n))
				{
					continue;//位置非法
				}
				if(i!=j)
				{
					int r1 = getValue(step-1,i-1,j-1,n);
					int r2 = getValue(step-1,i-1,j,n);
					int r3 = getValue(step-1,i,j-1,n);
					int r4 = getValue(step-1,i,j,n);

					int max_ = max(max(max(r1,r2),r3),r4);
					dp[step][i][j] = max_ + a[i][step-i] + a[j][step-j];
				}
				else
				{
					int r1 = getValue(step-1,i-1,j-1,n);
					int r2 = getValue(step-1,i-1,j,n);
					
					int r4 = getValue(step-1,i,j,n);

					int max_ = max(max(r1,r2),r4);
					dp[step][i][j] = max_ + a[i][step-i];
				}

			}

		}
	}
	return dp[P][n-1][n-1];

}

int sumMax_2Paths2()
{
	return findGrid(map,N);
}

时间复杂度是O(n^3),空间复杂度O(n^3)。

可以优化空间,利用滚动数组。

举一反三

1、给定m*n的矩阵,每个位置是一个非负整数,从左上角开始,每次只能朝右和下走,走到右下角,但只走一次,求总和最小的路径。

提示:因为只走一次,所以相对来说比较简单,dp[0, 0]=a[0, 0],且dp[x, y] = min(dp[x-1, y] ,dp[x, y-1]) + a[x, y]。

2、给定m*n的矩阵,每个位置是一个整数,从左上角开始,每次只能朝右、上和下走,并且不允许两次进入同一个格子,走到右上角,最小和。

分析:我们按列dp,假设前一列的最优值已经算好了,一旦往右就回不去了。枚举我们从对固定的(y-1)列,我们已经算好了最优值,我们枚举行x,朝右走到(x,y),然后再从(x,y)朝上走到(x,0),再从(x,y)朝下走到(x,n-1),所有这些第y列的值,作为第y列的候选值,取最优。 实际上,我们枚举了进入第y列的位置和在最终停在第y列的位置。这样保证我们不重复经过一个格子,也能保证我们不会往“左”走。





评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值