动态规划的学习—从暴力递归到动态规划

写出完美递归，不看题目也可以改出动态规划了。写出好的递归才是写出动态规划的第一步，除非是大神一眼就知道状态转移方程。我是菜鸟。我还不行

lc343

题目链接

解题思路

我认为学习动态规划最好的办法就是从暴力递归到动态规划，上来就一个状态转移方程，我想绝对大多数人都是看不懂的。
这道题如何暴力递归呢？暴力递归如下，选择是当前这样的做法最大，还是递归去求解之后做法更大，然后进行比较。

代码

class Solution {
    int dfs(int n){
        if(n == 2){
            return 1;
        }
        int ans = -1;
        for(int i = 1;i < n;++i){
            ans = ::max({ans,i * (n-i),i * dfs(n-i)});
        }
        return ans;
    }
public:
    int integerBreak(int n) {
        return dfs(n);
    }
};

当我们发现有大量重复计算的时候，我们可以增加一层缓存来去判断，这个n有木有计算过，计算过直接返回即可

class Solution {
    vector<int> vis;
    int dfs(int n){
        if(n == 1){
            return 1;
        }
        if(vis[n] != -1)return vis[n];
        int ans = -1;
        for(int i = 1;i < n;++i){
            ans = ::max({ans,i * (n-i),i * dfs(n-i)});
        }
        vis[n] = ans;
        return vis[n];
    }
public:
    int integerBreak(int n) {
        vis = vector<int>(n+1,-1);
        return dfs(n);
    }
};

到动态规划这里，只要递归写出来了，题目都可以不看就能改出来了。递归返回的是n，所以我们的dp数组也要返回下标n，return dp[n],递归的终止条件是n==2,return的1，所以dp[2] = 1;再把递归中的循环cv下来，不就是动态规划的状态转移方程了嘛？

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1,0);
        dp[2] = 1;
        for(int i = 3;i <= n;++i){
            int maxNum = 0;
            for(int  j = 1;j <= i;++j){
                maxNum = ::max({maxNum,j * (i-j),j * dp[i-j]});
            }
            dp[i] = maxNum;
        }
        return dp[n];
    }
};

lc122买股票问题

题目链接

解题思路

写了三四版递归函数，最后终于写出了完美的递归函数了，看这个一页的红就知道真的是做过测试了。

递归代码如下，有三种情况，第一种我躺平心态，我不打算买我保持跟以前一样。第二种情况，我现在减去买下标index的钱，但是我日后一定是卖的，因为我现在是买了的所以要改变状态，日后有一天卖。第三种情况，我现在卖出去，我拿到了钱，我加上去，但日后我可能还会再买股票，我再改变我的状态。就是index和flag这俩变量一直再玩。看完这个就很好改动态规划了

class Solution {
    int dfs(const vector<int>& prices,int index,bool flag){// true就是买这个股票
        if(index == prices.size()){
            return 0;
        }
        // 继续观望的状态
        int ans = dfs(prices,index + 1,flag);
        int money = 0;
        if(flag){// 今天要是买的话，后面要有一天卖
            // 这行一定是先进入的
            money = 0 - prices[index] + dfs(prices,index + 1,false);
            
        }
        else{ // 今天卖了的话后面就可以买了
            money = 0 + prices[index] + dfs(prices,index+1,true);
        }
        ans = ::max(ans,money);
        return ans;
    }
public:
    int maxProfit(vector<int>& prices) {
        return dfs(prices,0,true);
    }
};

动态规划的代码如下,我们写个二维dp表，下标和买不买的状态是变化的，所以是个二维表。暴力递归返回的是dfs(prices,0,true);所以我们的dp表也是返回dp[0][1]这个位置，也是题意都不用看就可以写出下面的动态规划来了。暴力递归中dfs就是dp中的条件。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n + 1,vector<int>(2,0));
        // 1表示买了0表示卖了
        for(int i = n-1;i >= 0;--i){
            for(int j = 0;j < 2;++j){
                dp[i][j] = dp[i+1][j];
                if(j == 0){
                    dp[i][j] = ::max(dp[i][j],dp[i+1][1] + prices[i]);
                }
                else{
                    dp[i][j] = ::max(dp[i][j],dp[i+1][0]-prices[i]);
                }
            }
        }

        return dp[0][1];
    }
};

lc91题

2021年4月21的每日一题，看完左神算法的动态递归，这些题是真的简单。题目链接

递归版

class Solution {
    int dfs(const string& s,int index){
        if(index >= s.size()){
            return 1;
        }

        if(s[index] == '0')return -1;
        int ans = 0;
        int cur = dfs(s,index+1);//不要这个值
        if(cur != -1){
            ans += cur;
        }
        if(s[index] == '1'){  
            if(index != s.size() -1){
                cur = dfs(s,index + 2);//要这个值,可以通吃
                if(cur != -1){
                    ans += cur;
                }
            }
            
        }
        else if(s[index] == '2'){
            // 这种情况可以吃两个
            if(index != s.size() -1 && s[index+1] <= '6'){
                cur = dfs(s,index + 2); 
                if(cur != -1){
                    ans += cur;
                } 
            }
           
        }
        return ans;
    }
public:
    int numDecodings(string s) {
        if(s[0] == '0')return 0;
        if(s.size() == 1)return 1;
        return dfs(s,0);

    }
};

动态规划版

class Solution {
public:
    int numDecodings(string s) {
        if(s[0] == '0')return 0;
        if(s.size() == 1)return 1;
        vector<int> dp(s.size() + 1 ,-1);
        dp[s.size()] = 1;
        for(int i = s.size() - 1;i >= 0;--i){
            if(s[i] == '0'){
                continue;
            }
            int ans = 0;
            int cur = dp[i+1];
            if(cur != -1){
                ans += cur;
            }
            if(s[i] == '1'){
                if(i != s.size()-1){
                    cur = dp[i+2];
                    if(cur != -1){
                        ans += cur;
                    }
                }
            }
            else if(s[i] == '2'){
                if(i != s.size() - 1 && s[i+1] <= '6'){
                    cur = dp[i+2];
                    if(cur != -1){
                        ans += cur;
                    }
                }
            }
            dp[i] = ans;
        }
        return dp[0];
    }
};

lc377

题目链接
递归版

class Solution {
    int dfs(const vector<int>& nums,int target){
        if(target == 0){
            return 1;
        }
        else if(target < 0){
            return -1;
        }
        int ans = 0;
        for(int i = 0;i < nums.size();++i){
            int cur = dfs(nums,target-nums[i]);
            ans += cur == -1 ? 0 : cur;
        }
        return ans;
    }
public:
    int combinationSum4(vector<int>& nums, int target) {
        return dfs(nums,target);
    }
};

动态规划

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target+1,0);
        dp[0] = 1;
        for(int i = 1;i <= target;++i){
            for(int j = 0;j < nums.size();++j){
                if(i - nums[j] >= 0 && dp[i - nums[j]] < INT_MAX - dp[i]){
                    dp[i] += dp[i - nums[j]];
                }
            }
        }

        return dp[target];
    }
};

lc403

题目链接
记忆化版

class Solution {
    unordered_map<int,int> um;
    vector<vector<int>> vis;
    bool dfs(const vector<int>& stones,int index,int k){
        if(stones.size() - 1 == index)return true;
        if(vis[index][k] != -1)return vis[index][k];
        bool ans = false;
        for(int i = -1;i <= 1;++i){
            if(k + i <= 0)continue;
            //找到下标就可以跳到目标下标
            int next = stones[index] + k + i;
            if(um.find(next) != um.end()){
                ans = ans == true ? ans : dfs(stones,um[next],k + i); 
            }
        }
        vis[index][k] = ans;
        return ans;
    }
public:
    bool canCross(vector<int>& stones) {
        // 必须要精准落到下一个的石子上。
        for(int i = 0;i < stones.size();++i){
            um[stones[i]] = i;
        }
        vis = vector<vector<int>>(stones.size(),vector<int>(stones.size(),-1));
        return dfs(stones,0,0);
    }
};

lc1473 粉刷房子三

题目链接

class Solution {
    vector<vector<vector<int>>> dp;
    // color是上一次涂的颜色。
    int dfs(const vector<int>& houses,const vector<vector<int>>& cost,const int &target,
            int index,int lastColor,int block){

        if(block > target)return INT_MAX;        
        if(index == houses.size()){
            if(block == target){
                return 0;
            }
            return INT_MAX;
        }
        if(dp[index][lastColor][block] != -1){
            return dp[index][lastColor][block];
        }
        int ans = INT_MAX;
        if(houses[index] == 0){ // 可以涂色
            for(int color = 1;color <= cost[0].size();++color){
                // 涂的和上次一样的话就快数就不用加1。
                int blockNum = index - 1 < 0 ? 1 : lastColor == color ? block : block + 1;
                int consume = cost[index][color - 1];
                int cur = dfs(houses,cost,target,index + 1,color,blockNum);
                if(cur != INT_MAX){
                    ans = ::min(ans, cur + consume); 
                }
            }
        }
        else{
            int blockNum = index - 1 < 0 ? 1 : houses[index] == lastColor ? block : block + 1;
            ans = ::min(ans,dfs(houses,cost,target,index + 1,houses[index],blockNum));
        }
        dp[index][lastColor][block] = ans;
        return dp[index][lastColor][block];
    }
public:
    int minCost(vector<int>& houses, vector<vector<int>>& cost, int m, int n, int target) {
        dp = vector<vector<vector<int>>>(m,vector<vector<int>>(n + 1,vector<int>(target + 1,-1)));
        int ans = dfs(houses,cost,target,0,0,0);
        return ans == INT_MAX ? -1 : ans;
    }
};

待写
lc322
题目链接
lc股票系列问题