题目
有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 5 6 2 3 4 5 6 2 3 4 5 6 2 3 4 5 6
3 4 5 6 7 3 4 5 6 7 3 4 5 6 7 3 4 5 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]
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列的位置。这样保证我们不重复经过一个格子,也能保证我们不会往“左”走。


被折叠的 条评论
为什么被折叠?



