刷题PIA 之动态规划

专业刷题Pia

已于 2023-05-26 21:22:50 修改

阅读量36

点赞数

文章标签：动态规划算法

于 2023-05-26 21:16:27 首次发布

本文链接：https://blog.csdn.net/m0_62789921/article/details/130886513

版权

0. 刷题bgm：**** Being Sober - Annika Wells

1. 斐波那契数列

描述：

输入：

输出：

算法：DP

#include <vector>
class Solution {
public:
    int Fibonacci(int n) {
        vector<int> FB(n,0);
        FB[0] = 1;
        FB[1] = 1;
        for(int i(2);i<n;i++)
        {   
            FB[i] = FB[i-1] + FB[i-2];
        }
        return FB[n - 1];
    }
};

分析：找到状态函数，即可获得递推公式，该题直接将递推公式吐出来了。

2.爬楼梯

#include <memory>
#include <vector>
class Solution {
public:
    int jumpFloor(int number) {
        vector<int> JF;
        JF.push_back(1);
        if(number == 1) return 1;
        JF.push_back(2);
        for(int i(2);i<number;i++)
        {
            JF.push_back(JF[i-1]+ JF[i-2]);
        }
        return JF[JF.size() - 1];
    }
};

分析：push_back效率较低，运算速度不如直接指定vector容量进行运算。

3.最小花费爬楼梯

#include <bits/types/clockid_t.h>
#include <cmath>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param cost int整型vector 
     * @return int整型
     */
    int minCostClimbingStairs(vector<int>& cost) {
        // write code here
        vector<int> CCS(cost.size() + 1,0);
        if (cost.size() == 1) return 0;
        CCS[0] = 0;
        CCS[1] = 0;
        for(int i(2);i<cost.size() + 1;i++)
        {
            CCS[i] = min(cost[i-1] + CCS[i-1],cost[i-2] + CCS[i-2]);
        }
        return CCS[cost.size()];
    }
};

4. 买卖股票的最好时机(一)


#include <climits>
class Solution {
public:
    /**
     * 
     * @param prices int整型vector 
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        // write code here
        vector<int>MP(prices.size(),0);
        MP[0] = 0;
        MP[1] = (prices[1] - prices[0] > 0) ? prices[1] - prices[0] : 0;
        int minnum = min(prices[1],prices[0]);
        for(int i(2);i<prices.size();i++)
        {
            minnum = (prices[i] < minnum)?prices[i]:minnum;
            MP[i] = max(MP[i-1],prices[i] - minnum);
        }
        return MP[prices.size()-1];
    }
};

5. 买卖股票的最好时机(二)

#include <memory>
#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型vector 股票每一天的价格
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        // write code here
        vector<int>MP(prices.size(),0);
        MP[0] = 0;
        MP[1] = (prices[1] - prices[0]<0)?0:prices[1] - prices[0];
        for(int i(2);i<prices.size();i++)
        {
            MP[i] = max(MP[i-1],MP[i-1]+prices[i]-prices[i-1]);
        }
        return MP[prices.size()-1];
    }
};

6.打家劫舍(一)

#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int rob(vector<int>& nums) {
        // write code here
        vector<int>R(nums.size(),0);
        R[0] = nums[0];
        R[1] = (nums[1] > nums[0])?nums[1]:nums[0];
        for(int i(2);i<nums.size();i++)
        {
            R[i] = max(R[i-1],R[i-2]+nums[i]);
        }
        return R[nums.size()-1];
    }
};

7.打家劫舍(二)

#include <cmath>
#include <type_traits>
#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int rob(vector<int>& nums) {
        // write code here
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0],nums[1]);
        vector<int> R1(nums.size(),0),R2(nums.size(),0);
        R1[0] = nums[0];
        R2[0] = nums[1];
        R1[1] = nums[0];
        R2[1] = nums[1];
        R2[2] = max(nums[1],nums[2]);
        R1[2] = max(R1[1],R1[0] + nums[2]); 
        for(int i(3);i<nums.size();i++)
        {
            R1[i] = max(R1[i-1],R1[i-2]+nums[i]);
            R2[i] = max(R2[i-1],R2[i-2]+nums[i]);
        }
        return max(R1[nums.size()-2],R2[nums.size()-1]);
    }
};

分析：该题需要考虑前三种情况，否则代码会出错。

8.连续子数组的最大和 ***

#include <algorithm>
#include <vector>
class Solution {
  public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int dp = array[0], sum = dp;
        for (int i = 1; i<array.size(); i++) {
            dp = (dp < 0)?array[i]:dp+array[i];
            sum = sum > dp ?sum:dp;
        }
        return sum;
    }
};

分析：

9. 不同路径的数目(一)

#include <vector>
class Solution {
  public:
    /**
     *
     * @param m int整型
     * @param n int整型
     * @return int整型
     */
    int uniquePaths(int m, int n) {
        // write code here
        vector<vector<int>>dp (m, vector<int>(n, 1));
        for (int i(1); i < m; i++) {
            for (int j(1); j < n; j++) {
                dp[i][j] = dp[i][j-1] + dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
};

10.矩阵的最小路径和

class Solution {
public:
    /**
     * 
     * @param matrix int整型vector<vector<>> the matrix
     * @return int整型
     */
    int minPathSum(vector<vector<int> >& matrix) {
        // write code here
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>>dp (m, vector<int>(n, 1));
        dp[0][0] = matrix[0][0];
        for(int i(1);i<m;i++)
        {
            dp[i][0] = dp[i-1][0] + matrix[i][0];
        }
        for(int i(1);i<n;i++)
        {
            dp[0][i] = dp[0][i-1] + matrix[0][i];
        }
        for (int i(1); i < m; i++) {
            for (int j(1); j < n; j++) {
                dp[i][j] = min(dp[i][j-1],dp[i-1][j]) + matrix[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

11.兑换零钱(一)


#include <climits>
#include <vector>
class Solution {
  public:
    /**
     * 最少货币数
     * @param arr int整型vector the array
     * @param aim int整型 the target
     * @return int整型
     */
    int minMoney(vector<int>& arr, int aim) {
        // write code here
        // int n = arr.size();
        // vector<int> index;
        // vector<int> dp(aim + 1, -1);
        // dp[0] = 0;
        // index.push_back(0);
        // int aimer;
        // for (int i(1); i < aim + 1; i++) {
        //     if (index.size() == 1) {
        //         aimer = i;
        //         auto iter = find(arr.begin(), arr.end(), aimer);
        //         if (iter != arr.end()) {
        //             dp[i] = 1;
        //             index.push_back(i);
        //         }
        //     } else {
        //         for (int j(0); j < index.size(); j++) {
        //             aimer = i - index[j];
        //             auto iter = find(arr.begin(), arr.end(), aimer);
        //             if (iter != arr.end()) {
        //                 dp[i] = (min(dp[i], dp[index[j]] + 1) != -1) ? min(dp[i],
        //                         dp[index[j]] + 1) : dp[index[j]] + 1;
        //                 if ( find(index.begin(), index.end(), i) == index.end()) {
        //                     index.push_back(i);
        //                 }
        //             }
        //         }
        //     }
        // }

        vector<int>dp (aim + 1,1e8);
        dp[0] = 0;
        for(auto c : arr)
        {
            for(int j(c);j<=aim;j++)
            {
                dp[j] = min(dp[j], dp[j-c] + 1);            
            }
        }
        return dp[aim] != 1e8?dp[aim]:-1;
    }
};

TRICK：以零钱数组作为最外环（时间复杂度（O(nm）），而非用目标作为最外环(时间复杂度（O(nm*logn）)

12. 买卖股票的最好时机(二)


#include <vector>
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 两次交易所能获得的最大收益
     * @param prices int整型vector 股票每一天的价格
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        // write code here
        vector<int> first(prices.size(), 0);
        int minp = prices[0];
        for (int i = 1; i < prices.size(); ++i) {
            minp = min(minp, prices[i]);
            first[i] = max(first[i - 1], prices[i] - minp);
        }
        vector<int> second(prices.size(), 0);
        int maxp = prices[prices.size() - 1];
        for (int i = prices.size() - 2; i >= 0; --i) {
            maxp = max(maxp, prices[i]);
            second[i] = max(second[i + 1], maxp - prices[i]);
        }
        int ans = 0;
        for (int i = 0; i < prices.size(); ++i) {
            ans = max(ans, first[i] + second[i]);
        }
        return ans;
    }
};

TRICK：利用左右极值遍历，保证分解线，再做循环。

13.最长公共子序列(二)

思路：

首先，区分两个概念：子序列可以是不连续的；子数组（子字符串）需要是连续的；

另外，动态规划也是有套路的：单个数组或者字符串要用动态规划时，可以把动态规划 dp[i] 定义为 nums[0:i] 中想要求的结果；当两个数组或者字符串要用动态规划时，可以把动态规划定义成两维的 dp[i][j] ，其含义是在 A[0:i] 与 B[0:j] 之间匹配得到的想要的结果。