格子取数问题 2013年搜狗的校招笔试题 专业程序代写

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

 

题目来源：此题是去年2013年搜狗的校招笔试题。

海外大学生留学生IT程序代写（擅长C语言C++JAVA等代编程源码代写代开发）

程序代写官网请进入--》》http://www.xmsydw.com
网上淘宝代写请进入--》》http://apenny.taobao.com

解法一、直接搜索

    @西芹_new，一共搜（2n-2）步，每一步有四种走法，考虑不相交等条件可以剪去很多枝，代码如下：

1. //copyright@西芹_new 2013  
2. #include "stdafx.h"    
3. #include <iostream>    
4. using namespace std;    
5.     
6. #define N 5    
7. int map[5][5]={    
8.     {2,0,8,0,2},    
9.     {0,0,0,0,0},    
10.     {0,3,2,0,0},    
11.     {0,0,0,0,0},    
12.     {2,0,8,0,2}};    
13. int sumMax=0;    
14. int p1x=0;    
15. int p1y=0;    
16. int p2x=0;    
17. int p2y=0;    
18. int curMax=0;    
19.     
20. void dfs( int index){    
21.     if( index == 2*N-2){    
22.         if( curMax>sumMax)    
23.             sumMax = curMax;    
24.         return;    
25.     }    
26.     
27.     if( !(p1x==0 && p1y==0) && !(p2x==N-1 && p2y==N-1))    
28.     {    
29.         if( p1x>= p2x && p1y >= p2y )    
30.             return;    
31.     }    
32.     
33.     //right right    
34.     if( p1x+1<N && p2x+1<N ){    
35.         p1x++;p2x++;    
36.         int sum = map[p1x][p1y]+map[p2x][p2y];    
37.         curMax += sum;    
38.         dfs(index+1);    
39.         curMax -= sum;    
40.         p1x--;p2x--;    
41.     }    
42.     
43.     //down down    
44.     if( p1y+1<N && p2y+1<N ){    
45.         p1y++;p2y++;    
46.         int sum = map[p1x][p1y]+map[p2x][p2y];    
47.         curMax += sum;    
48.         dfs(index+1);    
49.         curMax -= sum;    
50.         p1y--;p2y--;    
51.     }    
52.     
53.     //rd    
54.     if( p1x+1<N && p2y+1<N ) {    
55.         p1x++;p2y++;    
56.         int sum = map[p1x][p1y]+map[p2x][p2y];    
57.         curMax += sum;    
58.         dfs(index+1);    
59.         curMax -= sum;    
60.         p1x--;p2y--;    
61.     }    
62.     
63.     //dr    
64.     if( p1y+1<N && p2x+1<N ) {    
65.         p1y++;p2x++;    
66.         int sum = map[p1x][p1y]+map[p2x][p2y];    
67.         curMax += sum;    
68.         dfs(index+1);    
69.         curMax -= sum;    
70.         p1y--;p2x--;    
71.     }    
72. }    
73.     
74. int _tmain(int argc, _TCHAR* argv[])    
75. {    
76.     curMax = map[0][0];    
77.     dfs(0);    
78.     cout <<sumMax-map[N-1][N-1]<<endl;    
79.     return 0;    
80. }    

解法二、动态规划

    上述解法一的搜索解法是的时间复杂度是指数型的，如果是只走一次的话，是经典的dp。

2.1、DP思路详解

    故正如@绿色夹克衫所说：此题也可以用动态规划求解，大概思路就是同时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]

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

  复杂度分析：状态转移最多需要统计4个变量的情况，看做是O(1)的。共有O(n^3)个状态，所以总的时间复杂度是O(n^3)的。空间上可以利用滚动数组优化，由于每一步的递推只跟上1步的情况有关，因此可以循环利用数组，将空间复杂度降为O(n^2)。

2.2、DP方法实现

    OK，上述这个方法可能不算最优解法，但相对比较容易想一些。

    为了便于实现，我们认为所有不能达到的状态的得分都是负无穷，参考代码如下：

1. //copyright@caopengcs 2013  
2. const int N = 202;  
3. const int inf = 1000000000;  //无穷大  
4. int dp[N * 2][N][N];    
5. bool isValid(int step,int x1,int x2,int n) { //判断状态是否合法  
6. int y1 = step - x1, y2 = step - x2;  
7.     return ((x1 >= 0) && (x1 < n) && (x2 >= 0) && (x2 < n) && (y1 >= 0) && (y1 < n) && (y2 >= 0) && (y2 < n));  
8. }  
9.   
10. int getValue(int step, int x1,int x2,int n) {  //处理越界 不存在的位置 给负无穷的值  
11.     return isValid(step, x1, x2, n)?dp[step][x1][x2]:(-inf);  
12. }  
13.   
14. //状态表示dp[step][i][j] 并且i <= j, 第step步  两个人分别在第i行和第j行的最大得分 时间复杂度O(n^3) 空间复杂度O(n^3)   
15. int getAnswer(int a[N][N],int n) {  
16. int P = n * 2 - 2; //最终的步数  
17. int i,j,step;  
18.       
19.     //不能到达的位置 设置为负无穷大  
20.     for (i = 0; i < n; ++i) {  
21.         for (j = i; j < n; ++j) {  
22.             dp[0][i][j] = -inf;  
23.         }  
24.       
25.     }  
26.     dp[0][0][0] = a[0][0];  
27.   
28.       for (step = 1; step <= P; ++step) {  
29.         for (i = 0; i < n; ++i) {  
30.             for (j = i; j < n; ++j) {  
31.                 dp[step][i][j] = -inf;  
32.                 if (!isValid(step, i, j, n)) { //非法位置  
33.                     continue;  
34.                 }  
35.                 //对于合法的位置进行dp  
36.                 if (i != j) {  
37.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i - 1, j - 1, n));  
38.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i - 1, j, n));  
39.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i, j - 1, n));  
40.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i, j,n));  
41.                     dp[step][i][j] += a[i][step - i] + a[j][step - j];  //不在同一个格子，加两个数  
42.                 }  
43.                 else {  
44.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i - 1, j - 1, n));  
45.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i - 1, j,  n));  
46.                     dp[step][i][j] = max(dp[step][i][j], getValue(step - 1, i, j,  n));  
47.                     dp[step][i][j] += a[i][step - i]; // 在同一个格子里，只能加一次  
48.                 }  
49.                   
50.             }  
51.         }  
52.     }  
53.     return dp[P][n - 1][n- 1];  
54. }  

2.3、DP实现优化版

    以上代码的复杂度空间复杂度是O(n^3)，稍微想一下可以知道我们在推算dp[step]的时候 只有到了dp[step - 1]，所以第一维，我们只开到2就可以了。就是step为奇数时，我们都用dp[1][i][j]表示状态，step为偶数我们都用dp[0][i][j]表示状态，这样我们只需要O(n^2)的空间，这就是滚动数组的方法。滚动数组写起来并不复杂，只需要对上面的代码稍作修改即可，优化后的代码如下：

1. //copyright@caopengcs 8/24/2013  
2. int dp[2][N][N];  
3.   
4. bool isValid(int step,int x1,int x2,int n) { //判断状态是否合法  
5. int y1 = step - x1, y2 = step - x2;  
6.     return ((x1 >= 0) && (x1 < n) && (x2 >= 0) && (x2 < n) && (y1 >= 0) && (y1 < n) && (y2 >= 0) && (y2 < n));  
7. }  
8.   
9. int getValue(int step, int x1,int x2,int n) {  //处理越界 不存在的位置 给负无穷的值  
10.     return isValid(step, x1, x2, n)?dp[step % 2][x1][x2]:(-inf);  
11. }  
12.   
13. //状态表示dp[step][i][j] 并且i <= j, 第step步  两个人分别在第i行和第j行的最大得分 时间复杂度O(n^3) 使用滚动数组 空间复杂度O(n^2)   
14. int getAnswer(int a[N][N],int n) {  
15. int P = n * 2 - 2; //最终的步数  
16. int i,j,step,s;  
17.       
18.     //不能到达的位置 设置为负无穷大  
19.     for (i = 0; i < n; ++i) {  
20.         for (j = i; j < n; ++j) {  
21.             dp[0][i][j] = -inf;  
22.         }  
23.       
24.     }  
25.     dp[0][0][0] = a[0][0];  
26.   
27.       for (step = 1; step <= P; ++step) {  
28.         for (i = 0; i < n; ++i) {  
29.             for (j = i; j < n; ++j) {  
30.                 dp[step][i][j] = -inf;  
31.                 if (!isValid(step, i, j, n)) { //非法位置  
32.                     continue;  
33.                 }  
34.                 s = step % 2;  //状态下表标  
35.                 //对于合法的位置进行dp  
36.                 if (i != j) {  
37.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i - 1, j - 1, n));  
38.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i - 1, j, n));  
39.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i, j - 1, n));  
40.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i, j,n));  
41.                     dp[s][i][j] += a[i][step - i] + a[j][step - j];  //不在同一个格子，加两个数  
42.                 }  
43.                 else {  
44.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i - 1, j - 1, n));  
45.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i - 1, j,  n));  
46.                     dp[s][i][j] = max(dp[s][i][j], getValue(step - 1, i, j,  n));  
47.                     dp[s][i][j] += a[i][step - i]; // 在同一个格子里，只能加一次  
48.                 }  
49.                   
50.             }  
51.         }  
52.     }  
53.     return dp[P % 2][n - 1][n- 1];  
54. }  

 

转载于:https://www.cnblogs.com/sourcecode2014/p/3279501.html