动态规划（一）

一、知识点介绍

三个步骤：

1. 定义数组元素的含义
2. 找出数组元素之间的关系式
3. 找出初始值并定义

二、练习题目

        (1) 最长回文子串
        (2) 打家劫社
        (3) 打家劫社 II

三、算法思路

1. 最长回文子串

        (1) 先找出数组元素的含义：我们定义的d[i][j]的含义为，[i,j]之间的字符是回文字符串。
        (2) 判断回文字符串：如果是回文串，并且长度大于2，那么将首尾去除后，仍然是一个回文串
     bab ----> ababa
        状态转移方程为：
     P(i, j) = P(i+1, j-1) ^(si == sj)
        (3) 初始化：判断回文串的前提是长度要大于2，所以我们要在初始化的步骤中，先处理长度小于等于2的字符串是不是回文串。
      对于长度是1的字符串来说，一定是回文串；对于长度是2的字符串来说，只要两个字符相同就是回文。

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.size();
        if(len == 1) return s;
        vector<vector<int>> dp(len, vector<int>(len));
        int begin = 0;
        int maxLen = 1;
        for(int i = 0; i < len; ++i) {
            dp[i][i] = true;
        }
        for(int L = 2; L <= len; ++L) {//枚举长度
            for(int i = 0; i < len; ++i) {
                int j = i + L - 1;
                if(j >= len) break;

                if(s[i] != s[j]) {
                    dp[i][j] = false;
                }else{
                    //如果长度为1或者2，只要相等就是回文串
                    if(j - i <= 2) {
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }

                if(dp[i][j] && j - i + 1 > maxLen) {
                    begin = i;
                    maxLen = j - i + 1;
                }


            }
        }
        return s.substr(begin, maxLen);
    }
};

2. 打家劫社

        (1) 找出元素数组的含义：dp[i]表示第i天，能打劫的最大金额
        (2)找出状态方程：
     找规律，先把几天的打劫方式写出来：
     比如房屋存放金额为[1,2,3,1]
     第一天：dp[0] = nums[0]
     第二天：dp[1] = max(nums[0]/dp[i-1], nums[1])
     第三天：如果第二天仍然选择了打劫第一家店，那么第三天就一定是打劫第三家店；如果第二天选择打劫第二家店，那么第三天需要把第一家店和第三家店的金额加起来和第二家店进行比较，等于金额最高的金额。
     但是如何判断第二天到底选了哪家店呢，就要去比较dp[i-1]和dp[i-2]的值是否相等。
     所以转换方程就出来了
     如果（dp[i-1] == dp[i-2）dp[i] = dp[i-2] + nums[i];
     否则 dp[i] = max(dp[i-1], dp[i-2] + nums[i])
        (3) 初始化：就是前两天需要初始化：
     dp[0] = nums[0]
     dp[1] = max(nums[0]/dp[i-1], nums[1])

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

3.打家劫社 II

        (1) 跟上一道题比较类似，就是把原数组分成两个数组，一个是从0~n-1， 另一个是1~n。
        (2) 然后同样的方法求出两个队列的最大值

class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        int ans = 0;
        if(len == 1) return nums[0];
        if(len == 2) return max(nums[0], nums[1]);
        int maxn = 0;
        if(len == 3) {
            maxn = max(nums[0], max(nums[1], nums[2]));
            return maxn;
        }
        vector<int> arr1;
        vector<int> arr2;
        for(int i = 0; i < len-1; ++i) {
            arr1.push_back(nums[i]);
        }
        for(int i = 1; i < len; ++i) {
            arr2.push_back(nums[i]);
        }
        int ans1 = check(arr1);
        int ans2 = check(arr2);
        ans = max(ans1, ans2);
        return ans;
    }
    int check(vector<int>& arr) {
        int len = arr.size();
        vector<int> dp(len);
        dp[0] = arr[0];
        dp[1] = max(arr[0], arr[1]);
        for(int i = 2; i < len; ++i) {
            if(dp[i-1] == dp[i-2]) {
                dp[i] = dp[i-1] + arr[i];
            }else{
                dp[i] = max(dp[i-1], dp[i-2]+arr[i]);
            }
        }
        return dp[arr.size() - 1];
    }
};

四、 总结

多练。
一般定义dp的含义是，问什么定义什么