动态规划3 序列型动态规划

序列型动态规划

动态规划dp[i]中的下标i表示前i个元素a[0],a[1],...,a[i-1]的某种性质

初始化中，dp[0]表示空序列的性质

坐标型动态规划的初始条件dp[0]就是指以a[0]为结尾的自子序列的性质

题目1：LintCode 516 Paint House II

dp[i][1]....dp[i][k]  ：尤其前i栋房子 并且i-1是颜色1~k  的最小花费

dp[i][1] = min{dp[i-1][2]+cost[i-1][1],.....,dp[i-1][k]+cost[i-1][1]}

dp[i][2] = min{dp[i-1][1]+cost[i-1][2],.....,dp[i-1][k]+cost[i-1][2]}

...

dp[i][k] = min{dp[i-1][1]+cost[i-1][k],.....,dp[i-1][k-1]+cost[i-1][k]}

dp[i][j] = min k≠j {dp[i-1][k]} + cost[i-1][j];

i从0到N

j从1到k

k从1到k

算法的时间复杂度：O(NK^2)

加快计算：

dp[i][j] = min k≠j {dp[i-1][k]} + cost[i-1][j];

min k≠j {dp[i-1][k]} ：每次需要求f[i-1][1],...,f[i-1][k]中出了一个元素之外其他元素的最小值

重复计算

抽象：求出除了一个元素的之外的序列中的最小值

比如序列：95 88 75 98 90

75<88<90<95<95

最小值、最小值

在线维护最小值、次小值，就两个值。

假如最小值dp[i-1][a],次小值为dp[i-1][b]

则对于j=1,2,3,...,a-1,a+1,...,k   dp[i][j] = dp[i][a]+cost[i-1][j];

dp[i][a] = dp[i-1][b] + cost[i-1][a];

从此时间复杂度就降维O(NK)

class Solution {
public:
    /**
     * @param costs: n x k cost matrix
     * @return: an integer, the minimum cost to paint all houses
     */
    int minCostII(vector<vector<int>> &A) {
        // write your code here
        int n = A.size();
        if(n==0)
            return 0;
        
        const int INF = 0x3f3f3f3f;
        
        int k = A[0].size();
        
        int dp[n+1][k];  // 注意数组申请
        int min1, min2;
        int j1, j2;
        
        // 初始化
        for(int j=0; j<k; j++){  // dp数组第一列初始化为0
            dp[0][j] = 0;
        }
        
        // 从1开始 第一个房子 到 第n个房子
        for(int i=1; i<=n; i++){
            
            // 求最小值和次小值 每一次都要求
            min1 = min2 = INF;
            for(int j=0; j<k; j++){
                if(dp[i-1][j] < min1){
                    // 把最小值给次小值
                    min2 = min1;
                    j2 = j1;
                    min1 = dp[i-1][j];
                    j1 = j;
                }else{  // 这里也可以用else if
                    if(dp[i-1][j] < min2){
                        min2 = dp[i-1][j];
                        j2 = j;
                    }
                }
            }
            
            // dp计算
            for(int j=0; j<k; j++){
                if(j != j1){
                    dp[i][j] = dp[i-1][j1] + A[i-1][j];
                }else{
                    // j == j1
                    dp[i][j] = dp[i-1][j2] + A[i-1][j];
                }
            }
        }
        
        int res = INF;
        for(int j=0; j<k; j++){
            res = min(res, dp[n][j]);
        }
        
        return res;
        
    }
};

题目2：392 House Robber

https://www.lintcode.com/problem/house-robber/description

不能偷挨着的两家邻居

确定状态：

最后一个房子 偷 或者 不偷

偷n-1房子：需要知道前n-1栋房子中最大能偷多少金币

不偷n-1房子：前n-1房子的最优策略

（两种状态）

dp[i][0]  不偷

dp[i][1] 偷

• dp[i][0] = max {dp[i-1][0], dp[i-1][1]}
• dp[i][1] = dp[i-1][0] + A[i-1]   偷i，只能选择不偷i-1

---------------------------------------------------------------------------------------------

简化：在不偷房子i-1的前提下，前i栋房子中最大能偷度多少金币，其实就是前i-1栋房子能投多少金币

dp[i] 为窃贼在前i栋房子最多能投多少金币。

dp[i] = max {dp[i-1], dp[i-2]+A[i-1]}

初始条件：dp[0] = 0 没房子，偷0枚金币    序列性动态规划0就是空

dp[1] = A[0]

dp[2] = max{A[0],A[1]}

class Solution {
public:
    /**
     * @param A: An array of non-negative integers
     * @return: The maximum amount of money you can rob tonight
     */
    long long houseRobber(vector<int> &A) {
        // write your code here
        int n = A.size();
        if(n==0){
            return 0;
        }
        long dp[n+1];
        dp[0] = 0;
        dp[1] = A[0];
        for(int i=2; i<=n; i++){
            dp[i] = max(dp[i-1], dp[i-2]+A[i-1]);
        }
        
        return dp[n];
        
    }
};

题目3：LintCode 534 House Robber || 

https://www.lintcode.com/problem/house-robber-ii/description

上题的房子换成了圈，房子0和房子n-1变成邻居，不能同时偷盗。

分情况讨论

情况1：没偷档子0       最优策略就是窃贼对于房子1~N-1的最优策略->化为House Robber

情况2：没偷档子n-1    最优策略就是窃贼对于房子0~N-2的最优策略->化为House Robber

class Solution {
public:
    /**
     * @param nums: An array of non-negative integers.
     * @return: The maximum amount of money you can rob tonight
     */
    
    int dp_hr(int A[], int n){
        int dp[n+1];
        dp[0] = 0;
        dp[1] = A[0];
        for(int i=2; i<=n; i++){
            dp[i] = max(dp[i-1], dp[i-2]+A[i-1]);
        }
        return dp[n];
    }
    
    int houseRobber2(vector<int> &A) {
        // write your code here
        
        int n = A.size();
        if(n==0){
            return 0;
        }
        
        if(n==1){  // 注意下面切分数组的时候考虑当数组长度为1，是切分不到东西的。
            return A[0];
        }
        
        int A_0[n-1];
        for(int i=0; i<n-1; i++){
            A_0[i] = A[i];
        }
        
        int ans = dp_hr(A_0, n-1);
        
        
        
        int A_1[n-1];
        for(int i=1; i<n; i++){
            A_1[i-1] = A[i];  // 注意这边减一
        }
        ans = max(ans, dp_hr(A_1, n-1));
        
        return ans;
    }
};

题目4：LintCode 149 Best Time To Buy And Sell Stock

https://www.lintcode.com/problem/best-time-to-buy-and-sell-stock/description

[3，2，3，1，2]

2买入3卖出

先买后买

保底策略：

class Solution {
public:
    /**
     * @param prices: Given an integer array
     * @return: Maximum profit
     */
    int maxProfit(vector<int> &A) {
        // write your code here
        
        int min_a = A[0];
        int ans = 0;
        for(int i=0; i<A.size(); i++){
            int temp = A[i];
            if(temp-min_a > ans){
                ans = temp-min_a;
            }
            min_a = min(min_a, temp);
        }
        return ans;
    }
};

题目5：LintCode 150 Best Time To Buy And Sell Stock ||

任意多次买卖，但是任意时刻手中醉倒持有一股。

解法：贪心

买卖一个上升策略

class Solution {
public:
    /**
     * @param prices: Given an integer array
     * @return: Maximum profit
     */
    int maxProfit(vector<int> &a) {
        // write your code here
        
        int sum = 0;
        int per_satrt = 0, index =0;
        int per_end = 0;
        if(a.size()==0){
            return 0;
        }
        // 贪心策略
        // if(a.size() < 2){
        //     return 0;
        // }else if(a.size() == 2){
        //     if(a[0] < a[1]){
        //         return a[1]-a[0];
        //     }else{
        //         return 0;
        //     }
        // }
        for(int  i=1; i<a.size(); i++){
            if(a[i] >= a[i-1]){
                per_end = i;
            }else{
                sum = sum + (a[per_end] - a[per_satrt]);
                // 清空变量 要不然会多加
                per_satrt = i;
                per_end = i;
            }
        }
        sum = sum + (a[per_end] - a[per_satrt]);
        
        return sum;
    }
};

其实只要记录相邻两天的差值大于0就可，就可以得到上升子序列的所有和。

class Solution {
public:
    /**
     * @param prices: Given an integer array
     * @return: Maximum profit
     */
    int maxProfit(vector<int> &a) {
        // write your code here
        
        if(a.size() == 0){
            return 0;
        }
        
        int res = 0;
        
        for(int i=0; i<a.size()-1; i++){
            if(a[i+1]-a[i] > 0){
                res += a[i+1]-a[i];
            }
        }
        
        return res;
    }
};

题目5：LintCode 150 Best Time To Buy And Sell Stock |||

https://www.lintcode.com/problem/best-time-to-buy-and-sell-stock-iii/description

醉倒两次买了 两次卖，每次都是一只股

• 买过
• 没买过
• 买多少次

把买卖股票的过程划分：

阶段1   第一次买 阶段2  第一次卖  阶段3  第二次买 阶段4  第二次卖 阶段5

当股票在阶段5的时候就不能买了，阶段三是可以买卖依次，阶段四继续持有

dp[i][j]: 前i天结束后，在阶段j的最大获利。

阶段1，3，5 ---- 手中无股票

dp[i][j] = max{dp[i-1][j], dp[i-1][j-1]+p_i-1-p_i-2}

昨天没有持有股票             昨天持有股票，今天卖出清仓

阶段2，4   ---- 手中有股票

dp[i][j] = max{dp[i-1][j]+p_i-1-p_i-2, dp[i][j], dp[i-1][j-1]+p_i-1-p_i-2}

昨天就持有股票，继续持有并获利                昨天没有持有股票，今天买入              昨天持有上一次买的股票，今天买入并立即买入

模拟的过程：求序列的上升最大值，然后给每个子序列排序，选出2个值，这个过程的时间复杂度是O(NlongN)