leetcode Ch2-Dynamic Programming [2014]

1. Triangle

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        int n=triangle.size();
        int* res=new int[n];
        for(int i=0;i<n;i++)
            res[i]=triangle[n-1][i];
        for(int i=n-2;i>=0;i--)    
        {
            for(int j=0;j<=i;j++)
            {
                res[j]=triangle[i][j]+std::min(res[j],res[j+1]);
            }
        }
        return res[0];
    }
}; 

之前用自顶向下做的，但是用自底向上会更简单些，因为 不用考虑列数是否是第一列或最后一列，行数是否是第一行，等等这一系列问题。而且最后的结果不用再通过遍历一遍最下面一行来找最小值。

 2. unique paths

首先是利用了滚动数组的解法：

 class Solution {//滚动数组
public:
    int uniquePaths(int m, int n) {
        vector<int> dp(n,0);
        dp[0]=1;
        for(int i=0;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[j]=dp[j-1]+dp[j];
            }
        }
        return dp[n-1];
    }
};

然后是普通二维dp数组的解法：

 class Solution {//二维dp数组
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
            dp[i][0]=1;
        for(int i=0;i<n;i++)
            dp[0][i]=1;
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
}; 

 3. unique paths II

 首先是使用滚动数组的解法。注意与上一题中的不同。j循环中变为从0开始，因为要确保当obstacleGrid[i][0]为0时，更新dp[j]为0.

class Solution {//滚动数组
public:
    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
        if(obstacleGrid.size()==0) return 0;
        int m=obstacleGrid.size(); int n=obstacleGrid[0].size();
        vector<int> dp(n,0);
        dp[0]=1;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(obstacleGrid[i][j]==1)
                    dp[j]=0;
                else if(j>0)//j==0时就不执行了。
                    dp[j]=dp[j]+dp[j-1];
            }
        }
        return dp[n-1];
    }
};

使用普通二维dp数组。易错点是两层for循环都是从1开始，因为涉及到dp[j-1]。

class Solution {//普通二维dp数组
public:
    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
        if(obstacleGrid.size()==0) return 0;
        int m=obstacleGrid.size(); int n=obstacleGrid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
        {
            if(obstacleGrid[i][0]==1) break;
            else dp[i][0]=1;
        }
        for(int i=0;i<n;i++)
        {
            if(obstacleGrid[0][i]==1) break;
            else dp[0][i]=1;
        }
        for(int i=1;i<m;i++)//注意：从1开始
        {
            for(int j=1;j<n;j++)//注意：从1开始
            {
                if(obstacleGrid[i][j]==1) dp[i][j]=0;
                else
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

 4. minimum path sum

如果不想判断临界条件，可以分配二维dp数组时多分配1行和1列，用dp[i][j]来表示从左上角到grid[i-1][j-1]的最小路径和。

下面的解法是判断临界条件的，未采用上述技巧。

二维dp数组：

class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        if(grid.size()==0) return 0;
        int m=grid.size();int n=grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        dp[0][0]=grid[0][0];
        for(int i=1;i<m;i++)
            dp[i][0]=dp[i-1][0]+grid[i][0];
        for(int i=1;i<n;i++)
            dp[0][i]=dp[0][i-1]+grid[0][i];
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=grid[i][j]+std::min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[m-1][n-1];
    }
};

 滚动数组：

class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        if(grid.size()==0) return 0;
        int m=grid.size();int n=grid[0].size();
        vector<int> dp(n,INT_MAX);//初始值需要设成INT_MAX，因为后面有min比较。
        dp[0]=0;
        for(int i=0;i<m;i++)
        {
            dp[0]+=grid[i][0];
            for(int j=1;j<n;j++)
            {
                dp[j]=grid[i][j]+std::min(dp[j],dp[j-1]);
            }
        }
        return dp[n-1];
    }
};

 5. climbing stairs

class Solution {
public:
    int climbStairs(int n) {
        if(n==0||n==1||n==2) return n;
        vector<int> dp(n+1,0);
        dp[0]=0;dp[1]=1;dp[2]=2;
        for(int i=3;i<=n;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

用熟了之后只用3个变量就可以，不用开辟n个元素的数组。

 6. jump game

class Solution {
public:
    bool canJump(int A[], int n) {
        int reach=0;
        for(int i=0;i<=reach&&i<n;i++)
        {
            reach=std::max(reach,A[i]+i);
            if(reach>=n-1) return true;
        }
        return false;
    }
};

通过变量reach来记录当前能达到的最远位置。

7. jump game II

class Solution {
public:
    int jump(int A[], int n) {
        int start=0,end=0,count=0;
        int max=0;
        if(n==1) return 0;
        while(end<n)
        {
            count++;
            for(int i=start;i<=end;i++)
            {
                if(A[i]+i>=n-1) return count;
                if(A[i]+i>max)max=A[i]+i; //max表示下一轮while循环时能遍历到的最远的地方
            }
            start=end+1;
            end=max;
        }
        
    }
};

start和end表示每一轮while循环能遍历的元素区域。每下一轮的start都是这一轮的end+1，保证了无缝衔接；每下一轮的end是这一轮中计算出的max，即(在下一轮while循环时)能遍历到的最远的地方。每个元素只被遍历一次，故复杂度为O(n)。最后能覆盖到下标为n-1的元素时所经历的while轮数即为最终答案（最少jump次数）。

想不通时就代入实例跑一下，立马就清晰了。

 8. palindrome partitioning II

class Solution {
public:
    int minCut(string s) {
        const int n=s.size();
        vector<int> f(n+1,0);
        vector<vector<bool>> dp(n,vector<bool>(n,0));
        for(int i=0;i<n+1;i++)
        {
            f[i]=n-1-i;
        }
        for(int i=n-1;i>=0;i--)
        {
            for(int j=i;j<n;j++)
            {
                if((i==j)||(s[i]==s[j]&&j==i+1)||(s[i]==s[j]&&dp[i+1][j-1]))//注意判断顺序
                {
                    dp[i][j]=1;
                    f[i]=std::min(f[i],f[j+1]+1);
                }
            }
        }
        return f[0];       
    }
};

 9. word break

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        int n=s.size();
        if(n==0) return 0;
        vector<bool> dp(n+1,0);
        dp[0]=1;
        for(int i=1;i<=n;i++)//i表示当前长度(从下标0算起)
        {
            for(int k=0;k<i;k++)//k表示左半子串的长度
            {//通过k的变化，尝试每种分隔方式
                if(dp[k]&&dict.find(s.substr(k,i-k))!=dict.end())//dp[i]表示从下标0开始的长度为i的子串是否满足word break.
                {
                    dp[i]=1;
                    break;
                }
            }
        }
        return dp[n];
    }
};

可参考以前写的。http://www.cnblogs.com/forcheryl/p/3997304.html

10.  decode ways

class Solution {
public:
    int numDecodings(string s) {
        int n=s.size();
        if(n==0) return 0;
        vector<int> dp(n+1,0);
        dp[0]=1;
        if(isValid(s.substr(0,1)))
            dp[1]=1;
        for(int i=2;i<=n;i++)
        {
            if(isValid(s.substr(i-1,1)))
                dp[i]+=dp[i-1];
            if(isValid(s.substr(i-2,2)))
                dp[i]+=dp[i-2];
        }
        return dp[n];
    }
private:
    int isValid(string s)
    {
        if(s[0]=='0') return 0;
        int tmp=stoi(s);
        return tmp>=1&&tmp<=26;
    }
};

关键的是先写出递推式。dp[n]=dp[n-1]*if(condition1)+dp[n-2]*if(condition2)

 这里的condition1和condition2分别是判断两个对应的子串（s[i-1]、s[i-2...i-1]）是否为valid。为valid时才可以累加上。

 注意：dp[n]表示从下标0起的长度为n的子串的decode ways。

http://okckd.github.io/blog/2014/06/24/NineChap-Dynamic-Programming/

http://blog.csdn.net/linhuanmars/article/details/38468361