C++刷LeetCode（1463. 摘樱桃 II）【动态规划***】

糖逗

题目描述：

1. 给你一个 rows x cols 的矩阵 grid 来表示一块樱桃地。 grid 中每个格子的数字表示你能获得的樱桃数目。
   
2. 
   
3. 你有两个机器人帮你收集樱桃，机器人 1 从左上角格子 (0,0) 出发，机器人 2 从右上角格子 (0, cols-1) 出发。
   
4. 
   
5. 请你按照如下规则，返回两个机器人能收集的最多樱桃数目：
   
6. 
   
7. 从格子 (i,j) 出发，机器人可以移动到格子 (i+1, j-1)，(i+1, j) 或者 (i+1, j+1) 。
   
8. 当一个机器人经过某个格子时，它会把该格子内所有的樱桃都摘走，然后这个位置会变成空格子，即没有樱桃的格子。
   
9. 当两个机器人同时到达同一个格子时，它们中只有一个可以摘到樱桃。
   
10. 两个机器人在任意时刻都不能移动到 grid 外面。
    
11. 两个机器人最后都要到达 grid 最底下一行。
    
12.  
    
13. 
    
14. 示例 1：
    
15. 
    
16. 
    
17. 
    
18. 输入：grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
    
19. 输出：24
    
20. 解释：机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
    
21. 机器人 1 摘的樱桃数目为 (3 + 2 + 5 + 2) = 12 。
    
22. 机器人 2 摘的樱桃数目为 (1 + 5 + 5 + 1) = 12 。
    
23. 樱桃总数为： 12 + 12 = 24 。
    
24. 示例 2：
    
25. 
    
26. 
    
27. 
    
28. 输入：grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]
    
29. 输出：28
    
30. 解释：机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
    
31. 机器人 1 摘的樱桃数目为 (1 + 9 + 5 + 2) = 17 。
    
32. 机器人 2 摘的樱桃数目为 (1 + 3 + 4 + 3) = 11 。
    
33. 樱桃总数为： 17 + 11 = 28 。
    
34. 示例 3：
    
35. 
    
36. 输入：grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]
    
37. 输出：22
    
38. 示例 4：
    
39. 
    
40. 输入：grid = [[1,1],[1,1]]
    
41. 输出：4
    
42.  
    
43. 
    
44. 提示：
    
45. 
    
46. rows == grid.length
    
47. cols == grid[i].length
    
48. 2 <= rows, cols <= 70
    
49. 0 <= grid[i][j] <= 100&#160;
    
50. 
    
51. 来源：力扣（LeetCode）
    
52. 链接：https://leetcode-cn.com/problems/cherry-pickup-ii
    
53. 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

复制代码

1.自底向上的动态规划

1. class Solution {
   
2. public:
   
3.     int cherryPickup(vector<vector<int>>& grid) {
   
4.         int len1 = grid.size(), len2 = grid[0].size();
   
5.         vector<vector<vector<int> > > dp(len1, vector<vector<int> >(len2,vector<int>(len2, INT_MIN)));
   
6.         dp[0][0][len2-1] = grid[0][0] + grid[0][len2-1];
   
7.         int res = INT_MIN;
   
8.         for(int i = 1; i < len1; i++){
   
9.             for(int j = 0; j < len2-1; j++){
   
10.                 for(int k = j+1; k < len2; k++){
    
11.                     for(int p = max(j-1, 0); p <= min(j+1, len2-2); p++){
    
12.                         for(int q = max(k-1, 1);q <= min(k+1, len2-1); q++){
    
13.                             if(p >= q)continue;
    
14.                             dp[i][j][k] = max(dp[i][j][k],dp[i-1][p][q] + grid[i][j] + grid[i][k]);
    
15.                         }
    
16.                     }
    
17.                     res = max(res, dp[i][j][k]);
    
18.                 }
    
19.             }
    
20.         }
    
21.         return res;
    
22.     }
    
23. };

复制代码

代码参考链接：https://leetcode-cn.com/problems ... hua-by-hust_dhc-26/



2.自顶向下的动态规划（超时）

1. class Solution {
   
2. private:
   
3.     int len1, len2;
   
4.     //下一层col1和col2的取值
   
5.     vector<int>direct = {-1, 0, 1};
   
6. public:
   
7.     int get_value(int row, int col1, int col2, vector<vector<int>> grid){
   
8.         if(col1 == col2)return grid[row][col1];
   
9.         return grid[row][col1] + grid[row][col2];
   
10.     }
    
11.     int dfs(int row, int col1, int col2, vector<vector<int>> grid){
    
12.         if(row == len1 - 1)return get_value(row, col1, col2, grid);
    
13.         //下一层的最优解
    
14.         int temp = 0;
    
15.         for(auto temp1 : direct){
    
16.             for(auto temp2 : direct){
    
17.                 int store1 = temp1 + col1, store2 = temp2 + col2;
    
18.                 //确保没有越界
    
19.                 if(store1 >= 0 && store1 < len2 && store2 >= 0 && store2 < len2){
    
20.                     temp = max(temp, dfs(row+1, store1, store2, grid));
    
21.                 }
    
22.             }
    
23.         }
    
24.         return temp + get_value(row, col1, col2, grid);
    
25.     }
    
26.     int cherryPickup(vector<vector<int>>& grid) {
    
27.         //自顶向下的动态规划
    
28.         len1 = grid.size(), len2 = grid[0].size();
    
29.         return dfs(0, 0, len2 - 1, grid);
    
30.     }
    
31. };

复制代码

参考链接：https://leetcode-cn.com/problems ... code-solution-v2k5/

糖逗

这道题对我来说有点难度，现在还没完全想明白为什么1.自底向上的动态规划中j和k不能相等？