【leetcode】动态规划刷题记录

【leetcode】动态规划刷题记录

---

前言

本文是基于leetcode动态规划例题的学习记录

---

太难了，还是先从简单的开始吧~

62. 不同路径

链接
先复习下动态规划五部曲

• 确定dp数组（dp table）以及下标的含义
• 确定递推公式
• dp数组的初始化
• 确定遍历顺序
• 举例推导dp数组

class Solution {
public:
    int uniquePaths(int m, int n) {
        int size = max(m, n);
        int f[size + 1][size + 1];
        for(int i = 0; i < size; i ++ )
        {
            f[i][0] = 1;
            f[0][i] = 1;
        }
        for(int i = 1; i < m; i ++ )
            for(int j = 1; j < n; j ++ )
                f[i][j] = f[i - 1][j] + f[i][j - 1];
        return f[m - 1][n - 1];
    }
};

63. 不同路径 II

链接
明明是做过的题，结果还是想当然了，想着dp到终点的值和dp到障碍物乘障碍物dp到终点的值就可以得出答案，但是忽略了一些障碍物的路径是重合的
自己写的（错误版本）：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int n = obstacleGrid.at(0).size(), m = obstacleGrid.size();
        int res = dp(m, n);
        for(int i = 0; i < m; i ++ )
            for(int j = 0; j < n; j ++ )
                if(obstacleGrid[i][j])res -= dp(i + 1, j + 1) * dp(m - i, n - j);
        return res;
    }
private:
    int dp(int m, int n)
    {
        cout << "-------------" << endl;
        int size = max(m, n);
        int f[size + 1][size + 1];
        for(int i = 1; i <= size; i ++ )
        {
            f[i][1] = 1;
            f[1][i] = 1;
        }
        for(int i = 2; i <= m; i ++ )
        {
            for(int j = 2; j <= n; j ++ )
            {
                f[i][j] = f[i - 1][j] + f[i][j - 1];
                cout << f[i][j] << ' ';
            }
            cout << endl;
        }
        cout << f[m][n] << endl;
        return f[m][n];
    }
};

题解版本：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
       int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

343. 整数拆分

链接
不是很难，过

class Solution {
public:
    int integerBreak(int n) {
        int f[n + 1];
        memset(f, 0, sizeof(f));
        f[0] = 1, f[1] = 1;
        for(int i = 2; i <= n; i ++ )
            for(int j = 1; j < i; j ++ )
                f[i] = max(f[i], max(j * (i - j), j * f[i - j]));
        return f[n];
    }
};

96. 不同的二叉搜索树

链接
一开始没啥思路，看了题解的思路然后自己把代码打了一遍（真的要多画图啊~）

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

198. 打家劫舍

链接
写过同类型的，再重温一下

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

213. 打家劫舍 II

链接
一般的话就是在前题基础上改一改，这题倒跟我想不同路径的思路有点像，只不过这道题这样想是对的，因为集合不会重合

class Solution {
public:
    int rob(vector<int>& nums) {
        if(!nums.size()) return 0;
        if(nums.size() == 1)return nums[0];
        if(nums.size() == 2)return max(nums[0], nums[1]);
        vector<int> f1(nums.size());
        vector<int> f2(nums.size());
        f1[0] = nums[0], f1[1] = max(nums[0], nums[1]);
        for(int i = 2; i < nums.size() - 1; i ++ )
            f1[i] = max(f1[i - 1], f1[i - 2] + nums[i]);
        f2[0] = nums[1], f2[1] = max(nums[1], nums[2]);
        for(int i = 3; i < nums.size(); i ++ )
            f2[i - 1] = max(f2[i - 2], f2[i - 3] + nums[i]);
        cout << f2[nums.size() - 2];
        return max(f1[nums.size() - 2], f2[nums.size() - 2]);
    }
};

337. 打家劫舍 III

链接
想了很久都没想清楚到底怎么去记住父节点和父节点的父节点，看了看题解，原来是map,原来是后序遍历
题解

class Solution {
public:
    unordered_map<TreeNode* , int> umap; // 记录计算过的结果
    int rob(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right == NULL) return root->val;
        if (umap[root]) return umap[root]; // 如果umap里已经有记录则直接返回
        // 偷父节点
        int val1 = root->val;
        if (root->left) val1 += rob(root->left->left) + rob(root->left->right); // 跳过root->left
        if (root->right) val1 += rob(root->right->left) + rob(root->right->right); // 跳过root->right
        // 不偷父节点
        int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子
        umap[root] = max(val1, val2); // umap记录一下结果
        return max(val1, val2);
    }
};

作者：代码随想录
链接：https://leetcode.cn/problems/house-robber-iii/solutions/851250/dai-ma-sui-xiang-lu-337-da-jia-jie-she-i-j60v/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。