动态规划经典题目（一）——打家劫舍

动态规划经典问题

（1）线性打家劫舍——leetcode 剑指offerⅡ 089

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

（2）环形打家劫舍——leetcode 剑指offerⅡ 090

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

    int rob(vector<int>& nums) {
        //根据上一题房屋偷盗可以分析，这个问题可以分解为两个问题，
        //偷0，就不能偷n-1,偷n-1就不能偷0
        //所以f为1~n-1和0~n-2之间能够偷盗的最多的
        int n = nums.size();
        if(n==0||n<0){
            return 0;
        }
        else if(n==1){
            return nums[0];
        }
        else if(n==2){
            return max(nums[0],nums[1]);
        }
        vector<int> a = nums;
        vector<int> b = nums;
        a.erase(a.begin());
        b.pop_back();
        return max(rob_low(a),rob_low(b));
    }
};

粉刷房子——leetcode 剑指offerⅡ 091

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n = costs.size();
        if (n==0){
            return 0;
        }
        if(n==1){
            return *min_element(costs[0].begin(),costs[0].end());
        }
        vector<int> red(n,0);
        vector<int> blue(n,0);
        vector<int> green(n,0);
        red[0] = costs[0][0];
        blue[0] = costs[0][1];
        green[0] = costs[0][2];


        for(int i=1;i<n;i++){
            red[i] = costs[i][0]+min(blue[i-1],green[i-1]);
            blue[i] = costs[i][1]+min(red[i-1],green[i-1]);
            green[i] = costs[i][2]+min(red[i-1],blue[i-1]);
        }
        return min(min(red[n-1],blue[n-1]),green[n-1]);

    }
};