leetcode动态规划--滚动数组

每次对于二维数组的动态规划，转变为滚动数组。

剑指 Offer 46. 把数字翻译成字符串

题目
给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

示例 1:

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", “bwfi”, “bczi”, “mcfi"和"mzi”

class Solution {
public:
    int translateNum(int num) {
        if(num<10) return 1;
        string nums=to_string(num);
        int len=nums.length();
        int dp[len+1];
        dp[0]=1;dp[1]=1;
        for(int i=2;i<=len;i++){
            dp[i]=dp[i-1];
            if((nums[i-2]-'0')!=0&&(nums[i-2]-'0')*10+(nums[i-1]-'0')<=25){
                dp[i]+=dp[i-2];
            }
        }
        return dp[len];
    }
};

转化为滚动数组：对于一元数组，f[i]涉及到f[i-1]和f[i-2]，因此，用两个变量分别指代f[i-1]和f[i-2]，然后不断更替。

class Solution {
public:
    int translateNum(int num) {
        if(num<10) return 1;
        string nums=to_string(num);
        int len=nums.length();
        int a=1,b=1;
        for(int i=2;i<=len;i++){
            int res=b;
            if((nums[i-2]-'0')!=0&&(nums[i-2]-'0')*10+(nums[i-1]-'0')<=25){
                res=a+b;
            }
            a=b;
            b=res;
        }
        return b;
    }
};

97. 交错字符串

题目
给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

示例 1:

输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出: true
示例 2:

输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出: false

动态规划。（这道题用动态规划确实是没有想到的）
f(i,j)：s1的前i个元素和s2的前j个元素能否交错组成s3的前i+j个元素。
f(i,j) = ( f(i-1,j) & (s1[i-1]==s3[i+j-1]) ) | ( f(i,j-1) & (s2[j-1]==s3[i+j-1]) )

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        vector<vector<int>> f(s1.size()+1,vector<int>(s2.size()+1,false));
        int n1=s1.size(),n2=s2.size();
        f[0][0]=true;
        if(n1+n2 != s3.size()){
            return false;
        }
        for(int i=0;i<=n1;i++){
            for(int j=0;j<=n2;j++){
                if(i>0){
                    f[i][j] |= (f[i-1][j] & (s1[i-1]==s3[i+j-1]));
                }
                if(j>0){
                    f[i][j] |= (f[i][j-1] & (s2[j-1]==s3[i+j-1]));
                }
            }
        }
        return f[n1][n2];
    }
};

滚动数组：
这道题转化滚动数组较为容易，i和j之间没有什么联系，直接将第一维去掉即可。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        vector<int> f(s2.size()+1,false);
        int n1=s1.size(),n2=s2.size();
        f[0]=true;
        if(n1+n2 != s3.size()){
            return false;
        }
        for(int i=0;i<=n1;i++){
            for(int j=0;j<=n2;j++){
                if(i>0){
                    f[j] &= (s1[i-1]==s3[i+j-1]);
                }
                if(j>0){
                    f[j] |= (f[j-1] & (s2[j-1]==s3[i+j-1]));
                }
            }
        }
        return f[n2];
    }
};

63. 不同路径 II

题目

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

转化为滚动数组时，要注意是否在迭代中会有覆盖的情况，例如，原先由于是二维数组，因此，如果该处有障碍物，保持不变即可，dp[i][j]=0。但是在一维滚动数组中，如果该处有障碍物，那么必须手动将dp[j]清零，因为现在的滚动数组是始终有值的。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size(),n=obstacleGrid[0].size();
        vector<int> dp(n,0);
        if(obstacleGrid[0][0]==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;
                    continue;
                }
                if(j>=1&&obstacleGrid[i][j-1]==0)
                    dp[j]+=dp[j-1];
            }
        }
        return dp[n-1];
    }
};