动态规划2

Dynamic Programming

第一题 三角形问题

链接

给出一个三角形，计算从三角形顶部到底部的最小路径和，每一步都可以移动到下面一行相邻的数字，

例如，给出的三角形如下：

[[20],
[30,40],
[60,50,70],
[40,10,80,30]]

最小的从顶部到底部的路径和是20 + 30 + 50 + 10 = 110。

注意如果你能只用O（N）的额外的空间来完成这项工作的话，就可以得到附加分，其中N是三角形中的行总数。

问题：从（0,0）到达最后一行（i, j）最小路径

F(i,j)：min{F(i-1,j) F(i-1,j-1)}+a[i] [j];

每一行的第一列和最后一列只有一条路径到达。行数和列数相同

F(i,0)：F(i-1，0)+a[i] [0];

F(i,i)：F(i-1，i-1)+a[i] [i];

初始状态：F（0,0）=a[0] [0];

返回结果min{ F(row-1,j)}

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        if(triangle.empty()){
            return 0;
        }
        int row =triangle.size();
        int col=triangle[0].size();
        vector<vector<int>>minSum(triangle);
        for(int i=1;i<row;++i){
            for(int j=0;j<=i;++j){
                if(j==0)
                    minSum[i][j]=minSum[i-1][j]+triangle[i][j];
                else if(j==i){
                    minSum[i][j]=minSum[i-1][j-1]+triangle[i][j];
                }
                    else{
                        minSum[i][j]=min(minSum[i-1][j],minSum[i-1][j-1])+triangle[i][j];
                    }
                    
                }
            }
        int ret=minSum[row-1][0];
        for(int j=1;j<row;++j){
            ret=min(ret,minSum[row-1][j]);
        }
        return ret;
        }
        
    };
//该方法考虑边界

状态：从（i，j）到达最后一行最小路径和

F(i,j)：min{F(i+1,j) F(i+1,j+1)}+a[i] [j];

初始状态 F（row-1，j）=a[row-1] [j]

返回结果F（0,0）

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        if(triangle.empty()){
            return 0;
        }
        int row =triangle.size();
        int col=triangle[0].size();
         vector<vector<int>>minSum(triangle);
        for(int i=row-2;i>=0;--i){
            for(int j=0;j<=i;++j){ 
                 minSum[i][j]=min(minSum[i+1][j],minSum[i+1][j+1])+triangle[i][j]; 
                    
                }
            }        
        return minSum[0][0];
        }
        
    };

第二题 路径问题

链接

一个机器人在m×n大小的地图的左上角（起点）。

机器人每次向下或向右移动。机器人要到达地图的右下角（终点）。

可以有多少种不同的路径从起点走到终点？

问题：从（0,0）到达（row-1，col-1）路径个数

状态：（i，j）：从（0,0）到（i，j）路径个数

F(i,j)：F(i,j-1)+F(i-1,j)

初始状态：F(i,0)=F(0,j)=1；

返回结果F(row-1,col-1)

import java.util.*;
public class Solution {
    /**
     * 
     * @param m int整型 
     * @param n int整型 
     * @return int整型
     */
    public int uniquePaths (int m, int n) {
        int[ ][ ] pathnum=new int[m][n];
        for(int i=0;i<n;++i){
            pathnum[0][i]=1;
        }
        for(int i=0;i<m;++i){
            pathnum[i][0]=1;
        }
       for(int i=1;i<m;++i){
           for(int j=1;j<n;++j){
            pathnum[i][j]=pathnum[i][j-1]+pathnum[i-1][j];
        }
        }
        return pathnum[m-1][n-1];
  // write code here
    }
}

第三题 求路径II

链接

给定一个m*n的地图，其中加入了一些障碍。每次只能向下或者向右走，问从左上角走到右下角有多少不同的路径？

分别用0和1代表空区域和障碍

例如

下图表示有一个障碍在3*3的图中央。

[
    [0,0,0],
    [0,1,0],
    [0,0,0]
]

有2条不同的路径

状态：从（0,0）到（i，j）路径个数

F(i,j)：if（obstacle[i] [j]==1） F(i,j)=0

else F(i,j-1)+F(i-1,j)

初始状态：

if（obstacle[i] [0]==0&&obstacle[j] [0]==0 j<i） F(i,0)=1

if（obstacle[0] [i]==0&&obstacle[0] [j ]==0 j<i） F(i,0)=1

class Solution {
public:
    /**
     * 
     * @param obstacleGrid int整型vector<vector<>> 
     * @return int整型
     */
    int uniquePathsWithObstacles(vector<vector<int> >& obstacleGrid) {
        // write code here
        if(obstacleGrid.empty()){
            return 0;
        }
        int row=obstacleGrid.size();
        int col=obstacleGrid[0].size();
        vector<vector<int>> pathNum(row, vector<int>(col,0));
        for(int i=0;i<row;++i){
           if(obstacleGrid[i][0]==0){
               pathNum[i][0]=1;
           }else{
               break;
           }
        }
        for(int j=0;j<col;++j){
           if(obstacleGrid[0][j]==0){
               pathNum[0][j]=1;
           }else{
               break;
           }
        }
        for(int i=1;i<row;i++){
            for(int j=1;j<col;++j){
                if(obstacleGrid[i][j]==0){
                    pathNum[i][j]=pathNum[i][j-1]+pathNum[i-1][j];
                }
            }
        }
        return pathNum[row-1][col-1];
    }
};

第四题 带权值的最小路径和

链接

给定一个由非负整数填充的m x n的二维数组，现在要从二维数组的左上角走到右下角，请找出路径上的所有数字之和最小的路径。
注意：你每次只能向下或向右移动

import java.util.*;
public class Solution {
    /**
     * 
     * @param grid int整型二维数组 
     * @return int整型
     */
    public int minPathSum (int[][] grid) {
        // write code here
        if(grid.length==0){
            return 0;
        }
        int row=grid.length;
        int col=grid[0].length;
        for(int i=1;i<row;++i){
            grid[i][0]=grid[i-1][0]+grid[i][0];
        }
        for(int j=1;j<col;++j){
            grid[0][j]=grid[0][j-1]+grid[0][j];
        }
        for(int i=1;i<row;++i){
            for(int j=1;j<col;++j){
                grid[i][j]=Math.min(grid[i-1][j],grid[i][j-1])+grid[i][j];
            }
        }
        return grid[row-1][col-1];
        }
}

第五题 背包问题

有n个物品和一个大小为m的背包，给定数组A表示每个物品的大小和数组V表示每个物品的价值。问最多能装背包的总价值是多大。

问题：从n个商品中选择，当包的大小M是最大的价值

状态F（i,j）：从i个商品中选择，当包的大小j是最大的价值

A[i-1]<=j: F(i,j)=Max{F(i-1,j) ,F(i-1,j-A[i-1])+V[i-1]}

​ A[i-1]>j : F(i,j)=F(i-1,j)

新增第i个商品：选择放入i个商品：

1.不需要取出已有的商品；

2.需要取出已有的部分商品：

a。第i个商品价值小于取出的商品价值总和；

b。第i个商品价值大于取出的商品价值总和；

链接

class Solution {
public:
    /**
     * @param m: An integer m denotes the size of a backpack
     * @param A: Given n items with size A[i]
     * @param V: Given n items with value V[i]
     * @return: The maximum value
     */
    int backPackII(int m, vector<int> &A, vector<int> &V) {
        // write your code here
        int n=A.size();
        if(n==0||m==0)return 0;
        vector<vector<int>>maxV(n+1,vector<int>(m+1,0));
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++j){
                if(A[i-1]<=j){
                    maxV[i][j]=max(maxV[i-1][j],maxV[i-1][j-A[i-1]]+V[i-1]);
                }else{
                    maxV[i][j]=maxV[i-1][j];
                }
            }
        }
        return maxV[n][m];

    }
};