代码随想录算法训练营第10天 | ● 理论基础 ● 232.用栈实现队列 ● 225. 用队列实现栈

Posted 小懒懒

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了代码随想录算法训练营第10天 | ● 理论基础 ● 232.用栈实现队列 ● 225. 用队列实现栈相关的知识,希望对你有一定的参考价值。

 

第五章 栈与队列part01

●  day 1 任务以及具体安排:训练营一期day 1 

●  day 2 任务以及具体安排:day 2 第一章数组

●  day 3 任务以及具体安排:day 3 第二章 链表

●  day 4 任务以及具体安排:day 4 第二章 链表

●  day 5 周日休息

●  day 6 任务以及具体安排:day 6 第三章 哈希表

●  day 7 任务以及具体安排:day 7 第三章 哈希表

●  day 8 任务以及具体安排:day 8 第四章 字符串

●  day 9 任务以及具体安排:day 9 第四章 字符串

 

今日任务:

●  理论基础

●  232.用栈实现队列

●  225. 用队列实现栈

理论基础 

 

了解一下 栈与队列的内部实现机智,文中是以C++为例讲解的。 

 

文章讲解:https://programmercarl.com/%E6%A0%88%E4%B8%8E%E9%98%9F%E5%88%97%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

 

 232.用栈实现队列 

 

大家可以先看视频,了解一下模拟的过程,然后写代码会轻松很多。

 

题目链接/文章讲解/视频讲解:https://programmercarl.com/0232.%E7%94%A8%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.html

 

  225. 用队列实现栈 

 

可以大家惯性思维,以为还要两个队列来模拟栈,其实只用一个队列就可以模拟栈了。 

 

建议大家掌握一个队列的方法,更简单一些,可以先看视频讲解

 

题目链接/文章讲解/视频讲解:https://programmercarl.com/0225.%E7%94%A8%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.html

 

 

 

 

 

 

代码随想录算法训练营第四十一天 | 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

我的题解

  1. 确定dp以及下标定义
    $2 = 1 + 1; $
    最大乘积 1 ∗ 1 = 1 ; 最大乘积 1 * 1 = 1; 最大乘积11=1

    $3 = 1 + 2; $
    3 = 1 + 1 + 1 ; 3 = 1 + 1 + 1; 3=1+1+1
    最大乘积 1 ∗ 2 = 2 ; 最大乘积 1 * 2 = 2; 最大乘积12=2

    4 = 1 + 3 ; 4 = 1 + 3; 4=1+3
    4 = 2 + 2 ; 4 = 2 + 2; 4=2+2
    4 = 1 + 1 + 2 ; 4 = 1 + 1 + 2; 4=1+1+2
    4 = 1 + 1 + 1 + 1 ; 4 = 1 + 1 + 1 + 1; 4=1+1+1+1
    最大乘积 2 ∗ 2 = 4 ; 最大乘积 2 * 2 = 4; 最大乘积22=4

    5 = 1 + 4 ; 5 = 1 + 4; 5=1+4
    5 = 2 + 3 ; 5 = 2 + 3; 5=2+3
    5 = 1 + 2 + 2 ; 5 = 1 + 2 + 2; 5=1+2+2
    5 = 1 + 1 + 3 ; 5 = 1 + 1 + 3; 5=1+1+3
    5 = 1 + 1 + 1 + 2 ; 5 = 1 + 1 + 1 + 2; 5=1+1+1+2
    5 = 1 + 1 + 1 + 1 + 1 ; 5 = 1 + 1 + 1 + 1 + 1; 5=1+1+1+1+1
    最大乘积 2 ∗ 3 = 6 ; 最大乘积 2 * 3 = 6; 最大乘积23=6

    可以看到后面的数是由前面的数相加得到的,比如 1 和 4 合成 5, 2 和 3 合成 5,而 4 由 2 和 2 或者 1 和 3 合成,2 由 1 和 1组成,3 由 1 和 2 合成;
    一顿组合之后合成 5 的正整数算式就有好几条,但是最大乘积我们只需要用到 两个正整数合成的 那些算式,多于两个正整数合成的可以有两个正整数合成的算式推导。所以dp用来保存该数最大乘积,每次求该数最大乘积,我们就看两个正整数合成的 那些算式 比较各算式两个数的最大乘积(dp数)的最大乘积,大的更新存入dp数组。

  2. 确定递推公式
    $ dp[i] = max(dp[i], dp[r] * dp[l]); $

  3. dp初始化
    dp[1] = 1; dp[2] = 2; dp[3] = 3;
    为什么要这样初始化,因为 1 不由其他数合成,但是其他数会用到它来合成,而他在其他算式的作用就是 1 的作用;而 2 和 3 不保存该数最大的乘积,是因为这两个数拆数最大乘积都小于本身,那我们本来要求其他数最大乘积,不拆开比拆开还大,那肯定选大的。

  4. 确定遍历顺序
    因为后面的结果要由前面的结果推导,所以第一次遍历顺序直接从左到右;

  5. 推导递推过程

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 ] = m a x ( d p [ i ] , m a x ( j ∗ ( i − j ) , d p [ i − j ] ∗ j ) ) ; dp[i] = max(dp[i], max(j * (i - j), dp[i - j] * j)); dp[i]=max(dp[i],max(j(ij),dp[ij]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 个节点组成且节点值从 1n 互不相同的 二叉搜索树 有多少种?返回满足题意的二叉搜索树的种数。

示例 1:

输入:n = 3
输出:5

示例 2:

输入:n = 1
输出:1

提示:

  • 1 <= n <= 19

代码随想录

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

以上是关于代码随想录算法训练营第10天 | ● 理论基础 ● 232.用栈实现队列 ● 225. 用队列实现栈的主要内容,如果未能解决你的问题,请参考以下文章

代码随想录算法训练营第三十八天 | 理论基础 ,509. 斐波那契数,70. 爬楼梯,746. 使用最小花费爬楼梯

代码随想录算法训练营第15天 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2

代码随想录算法训练营第30天

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

代码随想录算法训练营第13天 | ● 239. 滑动窗口最大值 ● 347.前 K 个高频元素 ● 总结

代码随想录算法训练营第14天|530.二叉搜索树的最小绝对差501.二叉搜索树中的众数236.二叉树的最近公共祖先