代码随想录算法训练营day46|139.单词拆分剑指Offer10-I.斐波那契数列 10-II.青蛙跳台阶问题

Posted 2023-04-03 weixin_44735258

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了代码随想录算法训练营day46|139.单词拆分剑指Offer10-I.斐波那契数列 10-II.青蛙跳台阶问题相关的知识，希望对你有一定的参考价值。

139.单词拆分

思路：姑且认为这是一道排列题。

class Solution 
public:
    bool wordBreak(string s, vector<string>& wordDict) 
        unordered_set<string> wordset(wordDict.begin(),wordDict.end());
        vector<bool> dp(s.size()+1,false);
        dp[0]=true;
        for(int i=1;i<=s.size();i++)
            for(int j=0;j<i;j++)
                string word=s.substr(j,i-j);
                if(wordset.find(word)!=wordset.end()&&dp[j]==true) dp[i]=true;
            
        
        return dp[s.size()]; 
    
;

转换成unordered_set是为了提高查找效率，降低时间复杂度，它的底层实现是哈希表，所以查找时间复杂度是O(1)，之前是O(n)，如果用set的话是O(nlogn)。

剑指Offer10-I.斐波那契数列

题目链接

本题递归的解法部分用例会超时。所以用动态规划的解法。

首先用dp数组：

class Solution 
public:
    int fib(int n) 
        if(n<2) return n;
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++)
            dp[i]=dp[i-1]+dp[i-2];
            dp[i]%=1000000007;
        
        return dp[n];
    
;

注意不能直接对1e9+7取模，因为这是一个双精度浮点数，而dp数组是一个整数数组。

我们并不用维护dp数组，只需要维护三个变量即可。

class Solution 
public:
    int fib(int n) 
        if(n<2) return n;
        vector<int> dp(2);
        dp[0]=0;
        dp[1]=1;
        int sum;
        for(int i=2;i<=n;i++)
            sum=dp[0]+dp[1];
            sum%=1000000007;
            dp[0]=dp[1];
            dp[1]=sum;
        
        return dp[1];
    
;

10-II.青蛙跳台阶问题

题目链接

本题直接给出来了dp[0]=1，那就好说了，否则dp[0]是没有意义的，我们直接从dp[1]开始初始化就行。其实就是斐波那契数列，dp[i]表示到达i阶楼梯有dp[i]种方法。

class Solution 
public:
    int numWays(int n) 
        if(n==0) return 1;//直接站在原地就是一种方法
        if(n==1) return 1;
        vector<int> dp(n+1);
        dp[0]=1;
        dp[1]=1;//到达1阶有dp[1]种方法
        for(int i=2;i<=n;i++)
            dp[i]=dp[i-1]+dp[i-2];
            dp[i]%=1000000007;
        
        return dp[n];
    
;

错因：n==0的时候返回数值没有做特殊处理。

63. 股票的最大利润

题目链接

1、每一天都有两种状态：持有股票和不持有股票，所以需要二维数组来记录每一天的状态。dp[i][0]表示第i天持有股票拥有的最大现金，dp[i][1]表示第i天不持有股票拥有的最大现金。

2、递推公式。dp[i][0]可以由两种状态推到过来，可能是第i天之前就买入了，然后就延续这种状态，也可能是第i天买入的，刚刚改变，所以dp[i][0]=max(dp[i-1][0],-prices[i])（因为只买卖一次，开始现金是0，所以直接取负的就好）；dp[i][1]也是由两种状态推来，可能是之前就卖出了，也可能是当天刚卖出（那前一天一定是持有的状态），dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i])

3、如何初始化dp数组。dp[0][0]是-prices[0]，dp[0][1]是0

4、遍历顺序。根据递推公式，当前的状态是由前一天的状态推导来，所以就是从前往后遍历。

5、出错后要打印dp数组进行debug

class Solution 
public:
    int maxProfit(vector<int>& prices) 
        int len=prices.size();
        if(len==0) return 0;
        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<len;i++)
            dp[i][0]=max(dp[i-1][0],-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
        
        return dp[len-1][1];
    
;

错因：开始没有对空数组进行判断，如果为空直接返回0。

代码随想录算法训练营第四十一天 | 343.整数拆分96.不同的二叉搜索树

打卡第41天，基础动态规划继续。

今日任务

343.整数拆分
96.不同的二叉搜索树

343.整数拆分

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

提示:

2 <= n <= 58

我的题解

确定dp以及下标定义
$2 = 1 + 1； $
$最大乘积 1 * 1 = 1 ；$

$3 = 1 + 2； $
$3 = 1 + 1 + 1 ；$
$最大乘积 1 * 2 = 2 ；$

$4 = 1 + 3 ；$
$4 = 2 + 2 ；$
$4 = 1 + 1 + 2 ；$
$4 = 1 + 1 + 1 + 1 ；$
$最大乘积 2 * 2 = 4 ；$

$5 = 1 + 4 ；$
$5 = 2 + 3 ；$
$5 = 1 + 2 + 2 ；$
$5 = 1 + 1 + 3 ；$
$5 = 1 + 1 + 1 + 2 ；$
$5 = 1 + 1 + 1 + 1 + 1 ；$
$最大乘积 2 * 3 = 6 ；$

可以看到后面的数是由前面的数相加得到的，比如 1 和 4 合成 5， 2 和 3 合成 5，而 4 由 2 和 2 或者 1 和 3 合成，2 由 1 和 1组成，3 由 1 和 2 合成；
一顿组合之后合成 5 的正整数算式就有好几条，但是最大乘积我们只需要用到两个正整数合成的那些算式，多于两个正整数合成的可以有两个正整数合成的算式推导。所以dp用来保存该数最大乘积，每次求该数最大乘积，我们就看两个正整数合成的那些算式比较各算式两个数的最大乘积（dp数）的最大乘积，大的更新存入dp数组。
确定递推公式
$ dp[i] = max(dp[i], dp[r] * dp[l]); $
dp初始化
dp[1] = 1; dp[2] = 2; dp[3] = 3;
为什么要这样初始化，因为 1 不由其他数合成，但是其他数会用到它来合成，而他在其他算式的作用就是 1 的作用；而 2 和 3 不保存该数最大的乘积，是因为这两个数拆数最大乘积都小于本身，那我们本来要求其他数最大乘积，不拆开比拆开还大，那肯定选大的。
确定遍历顺序
因为后面的结果要由前面的结果推导，所以第一次遍历顺序直接从左到右；
推导递推过程

class Solution 
public:
    int integerBreak(int n) 
        if(n == 2) return 1;
        if(n == 3) return 2;
        vector<int> dp(n + 1, 0);
        dp[1] = 1; dp[2] = 2; dp[3] = 3; //初始化
        for(int i = 4; i <= n; i++) 
            for(int l = 1, r = i - 1; l <= r; l ++, r --) 
                dp[i] = max(dp[i], dp[r] * dp[l]); // 递推公式
            
        
        return dp[n];
    
;

时间复杂度：O(n^2)
空间复杂度：O(n)

代码随想录

可以从1遍历j，然后有两种渠道得到dp[i].

一个是j * (i - j) 直接相乘。

一个是j * dp[i - j]，相当于是拆分(i - j)，对这个拆分不理解的话，可以回想dp数组的定义。

j 怎么就不拆分呢？

j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了。那么从1遍历j，比较(i - j) * j和dp[i - j] * j 取最大的。
递推公式
$d p [i] = ma x (d p [i], ma x (j * (i - j), d p [i - j] * j));$

可以这么理解，j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。

class Solution 
public:
    int integerBreak(int n) 
        vector<int> dp(n + 1);
        dp[2] = 1; //初始化
        for(int i = 3; i <= n; i++) 
            for(int j = 1; j <= i / 2; j ++) 
                dp[i] = max(dp[i], max(j * (i - j), dp[i - j] * j)); // 递推公式
            
        
        return dp[n];
    
;

时间复杂度：O(n^2)
空间复杂度：O(n)

96.不同的二叉搜索树

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 19

代码随想录

dp以及下标定义
dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。
递推公式
dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量
初始化
从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1，否则乘法的结果就都变成0了。
所以初始化dp[0] = 1
遍历顺序
节点数为i的状态是依靠 i之前节点数的状态。
那么遍历i里面每一个数作为头结点的状态，用j来遍历。
推导

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