<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[lujian233的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/lujian233</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; lujian233]]></copyright><item><title><![CDATA[2020-08-20]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/108134636</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/108134636</guid><author>lujian233</author><pubDate>Thu, 20 Aug 2020 21:37:36 +0800</pubDate><description><![CDATA[原文
哲学家就餐
哲学家从 0 到 4 按 顺时针 编号。请实现函数 void wantsToEat(philosopher, pickLeftFork, pickRightFork, eat, putLeftFork, putRightFork)：
philosopher 哲学家的编号。
pickLeftFork 和 pickRightFork 表示拿起左边或右边的叉子。
eat 表示吃面。
putLeftFork 和 putRightFork 表示放下左边或右边的叉子。
由于哲学家不是在吃面就是在想着啥]]></description><category></category></item><item><title><![CDATA[377. 组合总和 Ⅳ]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/108118893</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/108118893</guid><author>lujian233</author><pubDate>Thu, 20 Aug 2020 11:08:25 +0800</pubDate><description><![CDATA[给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。
示例:
nums = [1, 2, 3]
target = 4
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。
因此输出为 7。
来源：力扣（LeetCode）
链接：传送门
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
超时dfs：
class Solution]]></description><category></category></item><item><title><![CDATA[738. 单调递增的数字]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/108031381</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/108031381</guid><author>lujian233</author><pubDate>Sun, 16 Aug 2020 02:20:57 +0800</pubDate><description><![CDATA[给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
（当且仅当每个相邻位数上的数字 x 和 y 满足 x &lt;= y 时，我们称这个整数是单调递增的。）
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/monotone-increasing-digits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

注意333222这种情况 应该返回299999而不是332999
c]]></description><category></category></item><item><title><![CDATA[2020-08-14]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/108006493</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/108006493</guid><author>lujian233</author><pubDate>Fri, 14 Aug 2020 16:35:43 +0800</pubDate><description><![CDATA[GCC编译过程
预处理(.c)：
编译,优化(.s, .asm)：生成汇编语言
汇编（.o) ：汇编过程实际上指把汇编语言代码翻译成目标机器指令的过程。
链接(.exe)：


预编译
将.c 文件转化成 .i文件
使用的gcc命令是：gcc –E
对应于预处理命令cpp


编译
将.c/.h文件转换成.s文件
使用的gcc命令是：gcc –S
对应于编译命令 cc –S


汇编
将.s 文件转化成 .o文件
使用的gcc 命令是：gcc –c
对应于汇编命令是 as


链接
将.o文件转化成可执行程]]></description><category></category></item><item><title><![CDATA[901. 股票价格跨度]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107952825</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107952825</guid><author>lujian233</author><pubDate>Wed, 12 Aug 2020 11:17:49 +0800</pubDate><description><![CDATA[编写一个 StockSpanner 类，它收集某些股票的每日报价，并返回该股票当日价格的跨度。
今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。
例如，如果未来7天股票的价格是 [100, 80, 60, 70, 60, 75, 85]，那么股票跨度将是 [1, 1, 1, 2, 1, 4, 6]。

提示：
调用 StockSpanner.next(int price) 时，将有 1 &lt;= price &lt;= 10^5。
每个测试用例最多可以调用]]></description><category></category></item><item><title><![CDATA[1156. 单字符重复子串的最大长度]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107915121</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107915121</guid><author>lujian233</author><pubDate>Mon, 10 Aug 2020 16:04:01 +0800</pubDate><description><![CDATA[leetcode
两种情况，交换或者不交换，交换的情况又分两种，交换后只多一个，交换后多了一串，aaabbaaa 这种是交换后只多一个的情况， aaabaaa交换后多一串的情况，abcdf不交换的情况。
遍历两次就行，第一次记录每个字符总数，和不交换情况下最长长度
第二次考虑交换的情况
class Solution {
public:
    int maxRepOpt1(string text) {
        if(text.size() == 0) return 0;
        map&l.]]></description><category></category></item><item><title><![CDATA[659. 分割数组为连续子序列]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107625984</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107625984</guid><author>lujian233</author><pubDate>Tue, 28 Jul 2020 02:13:35 +0800</pubDate><description><![CDATA[给你一个按升序排序的整数数组 num（可能包含重复数字），请你将它们分割成一个或多个子序列，其中每个子序列都由连续整数组成且长度至少为 3 。
如果可以完成上述分割，则返回 true ；否则，返回 false 。
来源：力扣（LeetCode）
链接：添加链接描述

贪心算法：
思路分析： 分析i时，先查找有没有以i-1结尾的子序列，有则接着，没有则需要新建长度最小的序列【i， i+1， i+2】。
class Solution {
public:
    bool isPossible(vector&lt]]></description><category></category></item><item><title><![CDATA[152. 乘积最大子数组]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107603378</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107603378</guid><author>lujian233</author><pubDate>Mon, 27 Jul 2020 02:01:38 +0800</pubDate><description><![CDATA[给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

leetcode
动态规划：
dp[i]表示以i结尾的连续子数组的最大乘积，
最后返回dp[0]到dp[n-1]中最大的值
class Solution {
public:
    int maxProduct(vector&lt;int&gt;&amp; nums) {
        vector&lt;int&gt; maxf(nums), minf(nums);

    ]]></description><category></category></item><item><title><![CDATA[329. 矩阵中的最长递增路径]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107594096</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107594096</guid><author>lujian233</author><pubDate>Sun, 26 Jul 2020 15:22:41 +0800</pubDate><description><![CDATA[给定一个整数矩阵，找出最长递增路径的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

leetcode
记忆化dfs：
class Solution {
public:
    int dir[5] = {1, 0, -1, 0, 1}; 
    int row, col;
    int dfs(vector&lt;vector&lt;int&gt;&gt;&amp; road, vector&lt;vector&lt;int&gt]]></description><category></category></item><item><title><![CDATA[783. 二叉搜索树节点最小距离]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107552165</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107552165</guid><author>lujian233</author><pubDate>Fri, 24 Jul 2020 01:57:31 +0800</pubDate><description><![CDATA[定一个二叉搜索树的根节点 root，返回树中任意两节点的差的最小值。

leetcode
中序遍历：
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Sol]]></description><category></category></item><item><title><![CDATA[双栈实现队列]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107491702</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107491702</guid><author>lujian233</author><pubDate>Tue, 21 Jul 2020 16:22:13 +0800</pubDate><description><![CDATA[class CQueue {
public:
    stack&lt;int&gt; s1;
    stack&lt;int&gt; s2;
    

    CQueue() {
        while(!s1.empty()) s1.pop();
        while(!s2.empty()) s2.pop();
    }
    
    void appendTail(int value) {
        s1.push(value);
    }
    
    int d]]></description><category></category></item><item><title><![CDATA[不同的二叉搜索树 II]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107483068</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107483068</guid><author>lujian233</author><pubDate>Tue, 21 Jul 2020 10:44:40 +0800</pubDate><description><![CDATA[给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。

添加链接描述
递归：
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int ]]></description><category></category></item><item><title><![CDATA[312. 戳气球]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107466241</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107466241</guid><author>lujian233</author><pubDate>Mon, 20 Jul 2020 16:24:47 +0800</pubDate><description><![CDATA[有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。
现在要求你戳破所有的气球。如果你戳破气球 i ，就可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。
求所能获得硬币的最大数量。

来源：力扣（LeetCode）添加链接描述
反向思考，每次添加一个气球，直到添满得到最大值]]></description><category></category></item><item><title><![CDATA[97. 交错字符串]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107422223</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107422223</guid><author>lujian233</author><pubDate>Sat, 18 Jul 2020 02:34:36 +0800</pubDate><description><![CDATA[给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。
示例 1:
输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出: true
示例 2:
输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出: false
来源：力扣（LeetCode）添加链接描述
动态规划
class Solution {
public:
    bool isInterleave(strin]]></description><category></category></item><item><title><![CDATA[926. 将字符串翻转到单调递增]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107386368</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107386368</guid><author>lujian233</author><pubDate>Thu, 16 Jul 2020 16:39:23 +0800</pubDate><description><![CDATA[如果一个由 ‘0’ 和 ‘1’ 组成的字符串，是以一些 ‘0’（可能没有 ‘0’）后面跟着一些 ‘1’（也可能没有 ‘1’）的形式组成的，那么该字符串是单调递增的。
我们给出一个由字符 ‘0’ 和 ‘1’ 组成的字符串 S，我们可以将任何 ‘0’ 翻转为 ‘1’ 或者将 ‘1’ 翻转为 ‘0’。
返回使 S 单调递增的最小翻转次数。
来源：力扣（LeetCode）
链接：添加链接描述
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

前缀和：
class Solution {
publ]]></description><category></category></item><item><title><![CDATA[785. 判断二分图]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107374311</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107374311</guid><author>lujian233</author><pubDate>Thu, 16 Jul 2020 01:50:24 +0800</pubDate><description><![CDATA[给定一个无向图graph，当这个图为二分图时返回true。
如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。
graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边： graph[i] 中不存在i，并且graph[i]中没有重复的值。

来源：力扣（LeetCode）添加链接描述
我的代码：
广度优先遍历，]]></description><category></category></item><item><title><![CDATA[96. 不同的二叉搜索树]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107351279</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107351279</guid><author>lujian233</author><pubDate>Wed, 15 Jul 2020 02:17:58 +0800</pubDate><description><![CDATA[给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？
示例:

来源：力扣（LeetCode）添加链接描述
我的代码：
class Solution {
public:
    int numTrees(int n) {
        int dp[n+1];
        if(n == 1) return 1;
        if(n == 2) return 2;
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
 ]]></description><category></category></item><item><title><![CDATA[786. 第 K 个最小的素数分数]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107343263</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107343263</guid><author>lujian233</author><pubDate>Tue, 14 Jul 2020 17:42:27 +0800</pubDate><description><![CDATA[一个已排序好的表 A，其包含 1 和其他一些素数.  当列表中的每一个 p&lt;q 时，我们可以构造一个分数 p/q 。
那么第 k 个最小的分数是多少呢?  以整数数组的形式返回你的答案, 这里 answer[0] = p 且 answer[1] = q.
示例:
输入: A = [1, 2, 3, 5], K = 3
输出: [2, 5]
解释:
已构造好的分数,排序后如下所示:
1/5, 1/3, 2/5, 1/2, 3/5, 2/3.
很明显第三个最小的分数是 2/5.
输入: A = [1, 7]]></description><category></category></item><item><title><![CDATA[面试题 16.25. LRU缓存]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107334355</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107334355</guid><author>lujian233</author><pubDate>Tue, 14 Jul 2020 11:23:40 +0800</pubDate><description><![CDATA[设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。
它应该支持以下操作： 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少]]></description><category></category></item><item><title><![CDATA[120. 三角形最小路径和]]></title><link>https://blog.youkuaiyun.com/lujian233/article/details/107332227</link><guid>https://blog.youkuaiyun.com/lujian233/article/details/107332227</guid><author>lujian233</author><pubDate>Tue, 14 Jul 2020 10:14:08 +0800</pubDate><description><![CDATA[题目：添加链接描述
给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。
例如，给定三角形：
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
int minimumTotal(vector&lt;vector&lt;int&gt;&gt; &amp;triangle)
{
    ]]></description><category></category></item></channel></rss>