2. 动态规划

标签：++   find   return   记录   初始   load   题目   ring   相同   

动态规划模板步骤：

• 确定动态规划状态
• 写出状态转移方程（画出状态转移表）
• 考虑初始化条件
• 考虑输出状态
• 考虑对时间，空间复杂度的优化（Bonus）

674. 最长连续递增序列

题目分析

先区分两个概念。子序列：不一定连续；子串：一定连续。
题目中说到的是要连续的序列，所以该最长序列在原序列中一定是连续的。
一旦发生nums[i]<nums[i-1]的情况，就将ans[i]重置为1，重新计数。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int len = nums.size();
        if(len == 0) return 0;
        int ans[len];   
        ans[0] = 1;
        int max = 1;
        for(int i = 1; i < len; i++){
            if(nums[i] > nums[i-1])
                ans[i] = ans[i-1] + 1;
            else
                ans[i] = 1;
            if (ans[i] > max)
                max =  ans[i];
        }
        return max;
    }
};

5. 最长回文子串

题目分析

填表，对角线均为true。设定一个数组记录判断结果。

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.length();
        if(n == 0 || n == 1 )
            return s;
        bool ct[n][n];
        int start = 0, end = 0;
        for (int i = 0; i < n; i++)
            ct[i][i] = true;
        for (int r = 1; r < n; r++)
            for (int l = 0; l < r; l++)
                if (s[r]==s[l] && (r-l==1 || ct[l+1][r-1])) {
                    ct[l][r] = true;
                    if (r-l > end-start) {
                        start = l; end = r;
                    }
                    continue;
                }else
                    ct[l][r] = false;
        return s.substr(start, end-start+1);
    }
};

72. 编辑距离

题目分析

二维数组dp[i][j]表示word1的第i个字母转换成word2的前j个字母所使用的最少操作。
i指向word1，j指向word2，若当前字母相同，则dp[i][j]=dp[i-1][j-1]，否则取增删改的最小值+1。

class Solution {
    public int minDistance(String word1, String word2) {
        int len1 = word1.length(), len2 = word2.length();
        int[][] dp = new int[len1 + 1][len2 + 1];
        for (int i = 0; i <= len1; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= len2; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = 1 + Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
                }
            }
        }
        return dp[len1][len2];
    }
}

198. 打家劫舍

题目分析

由题，不可以闯入相邻的房屋，所以在当前位置 n 房屋可盗窃的最大值，是 n-1 房屋可盗窃的最大值，或者是 n-2 房屋可盗窃的最大值加上当前房屋的值，取最大值。
dp[n] = max( dp[n-1], dp[n-2] + num)

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;
        int n = nums.size();
        int dp[n] ;
        dp[0] = nums[0];
        for(int i = 1;i  < n;i++){
            if(i == 1) dp[i] = max(nums[0],nums[1]);
            else{
                dp[i] = max(dp[i - 2] + nums[i],dp[i - 1 ]);
            }
        }
        return dp[n - 1];
    }
};

213. 打家劫舍II

题目分析

不能闯入相邻房间，房子排列为环，所以第一间房和最后一间房也是相邻房间，所以偷了第一家就不能偷最后一间房，反之亦然。所以考虑偷第一家放弃最后一家和不偷第一家两种情况。

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        if(nums.size()==2) return max(nums[0],nums[1]);
        if(nums.size()==3) return max(max(nums[0],nums[1]),nums[2]);
        int temp1=nums[0];
        int temp2=max(nums[0],nums[1]);
        int temp3=nums[1];
        int temp4=max(nums[1],nums[2]);
        int max1=0;
        int max2=0;
        for(int i=2;i<nums.size()-1;i++){
            max1=max(temp1+nums[i],temp2);
            temp1=temp2;
            temp2=max1;
        }
        for(int i=3;i<nums.size();i++){
            max2=max(temp3+nums[i],temp4);
            temp3=temp4;
            temp4=max2;
        }
        return max(max1,max2);
    }
};

2. 动态规划

标签：++   find   return   记录   初始   load   题目   ring   相同   

原文地址：https://www.cnblogs.com/Just-Rejoice/p/13551373.html