<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[M_CODEEE的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/M_CODEEE</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; M_CODEEE]]></copyright><item><title><![CDATA[lc 349. 两个数组的交集]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/126567312</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/126567312</guid><author>M_CODEEE</author><pubDate>Sun, 28 Aug 2022 10:58:12 +0800</pubDate><description><![CDATA[111]]></description><category></category></item><item><title><![CDATA[536. 从字符串生成二叉树]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124272159</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124272159</guid><author>M_CODEEE</author><pubDate>Tue, 19 Apr 2022 14:33:00 +0800</pubDate><description><![CDATA[我觉得这道题不算很难，但是有很多很多细节要处理；看了题解，发现自己的思路和题解其实很相似；但是很多地方我的处理方式是有问题的；导致后面代码越改越乱；这一道题耽误了太多题解，索性看题解了；下面是一段改了很久依然没有过的代码=.=:




# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val...]]></description><category></category></item><item><title><![CDATA[BM28 二叉树的最大深度 DFS学习]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124262462</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124262462</guid><author>M_CODEEE</author><pubDate>Mon, 18 Apr 2022 23:28:56 +0800</pubDate><description><![CDATA[看了一个Up主总结的DFS的做题模板，搬过来记录一下

res = 0 #存储最终结果

start = 0 #初始化当前结果

#构造递归函数,通常参数为当前节点和当前结果

dfs(node,currentresult):

#终止条件返回判断

  if node == None:
    return

#更新当前结果currentresult



#若到达末尾叶子节点，进行最优结果的更新

if node.left == None and node.right == None:

#...]]></description><category></category></item><item><title><![CDATA[360. 有序转化数组]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124250781</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124250781</guid><author>M_CODEEE</author><pubDate>Mon, 18 Apr 2022 23:20:01 +0800</pubDate><description><![CDATA[class Solution:
    def sortTransformedArray(self, nums: List[int], a: int, b: int, c: int) -&gt; List[int]:
        sum = []
        for i in nums:
            temp = i*i*a + b*i +c
            sum.append(temp)
        sum.sort()
        return su...]]></description><category></category></item><item><title><![CDATA[487. 最大连续1的个数 II]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124254151</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124254151</guid><author>M_CODEEE</author><pubDate>Mon, 18 Apr 2022 18:19:51 +0800</pubDate><description><![CDATA[第一次写的代码超时，只过了一半用例


class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -&gt; int:
        temp = 1
        maxs = 1
        if len(nums) == 1:
            return maxs
        if 0 not in nums:
            return len(nums)
        for...]]></description><category></category></item><item><title><![CDATA[1055. 形成字符串的最短路径]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124248227</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124248227</guid><author>M_CODEEE</author><pubDate>Mon, 18 Apr 2022 15:11:15 +0800</pubDate><description><![CDATA[题目：







代码：


class Solution:
    def shortestWay(self, source: str, target: str) -&gt; int:
        #初始化的过程
        s = []
        t = []
        for i in range(0,len(source)):
            s.append(source[i])
        for i in range(0,len(target)):
    ]]></description><category></category></item><item><title><![CDATA[651. 4键键盘 ----- 动态规划]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124238747</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124238747</guid><author>M_CODEEE</author><pubDate>Sun, 17 Apr 2022 23:26:01 +0800</pubDate><description><![CDATA[说实话我觉得这个题挺奇怪的=.=

看题解都看了半天

根据动态规划的做题模板看下：

首先我们看最后一个状态：

有两种情况：1、输入A 2、输入ctrlV

设d[i]为第i次输入后 A的数量

对于最后一次输入的是A这种情况来说：d[i] = d[i-1]+1 这个比价好写

但对于最后一次输入的是ctrlv来说 ,也有两种情况：
1、ctrlA ctrlC ctrlVctrlVctrlVctrlV

2、.......................ctrlA ctrlC ctrlV...]]></description><category></category></item><item><title><![CDATA[416. 分割等和子集 --- 0-1背包问题]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124234755</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124234755</guid><author>M_CODEEE</author><pubDate>Sun, 17 Apr 2022 20:33:11 +0800</pubDate><description><![CDATA[这道题可以转化为0-1背包问题去求解的；

这道题间接可以变为：我们能不能找到一些数令所有数的和 为整个数组和的一半？

设d[i][j]：能否在0-i区间的数组中找到和为j的数

单挑出来 nums[i],对于nums[i],我们有两种选择：

选择nums[i]:

如果选择nums[i] ,那么我们 就要看d[i-1][j-nums[i]]的值是否为true

若为true，那么d[i][j]的值也为true

不选择nums[i]:

不选择nums[i],那么d[i][j]的值就为d[i...]]></description><category></category></item><item><title><![CDATA[剑指 Offer II 098. 路径的数目 -- 动态规划]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124230631</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124230631</guid><author>M_CODEEE</author><pubDate>Sun, 17 Apr 2022 16:25:18 +0800</pubDate><description><![CDATA[思路：
稍后写~

代码：


class Solution:
    def uniquePaths(self, m: int, n: int) -&gt; int:
        #初始化
        sum = [] #保存最后的结果，二维数组list[list[]]
        new = [1 for i in range(0,n)]
        sum.append(new)

        for i in range(1,m):
            ne...]]></description><category></category></item><item><title><![CDATA[剑指 Offer II 103. 最少的硬币数目 -- 动态规划]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124229759</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124229759</guid><author>M_CODEEE</author><pubDate>Sun, 17 Apr 2022 15:33:37 +0800</pubDate><description><![CDATA[思路：

******晚点写嘻嘻



代码：


class Solution:
    def coinChange(self, coins: List[int], amount: int) -&gt; int:
        length = len(coins)
        f = []
        f.append(0)  #初始化f(0) = 0
        for i in range(1,amount+1):
            temp = []
       ...]]></description><category></category></item><item><title><![CDATA[python 函数]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124222804</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124222804</guid><author>M_CODEEE</author><pubDate>Sun, 17 Apr 2022 00:17:59 +0800</pubDate><description><![CDATA[一、格式

def 函数名 ([输入参数])：

函数体

return xxx

二、传参方式

1、位置传参：

例子就是位置传参，根据形参的位置传入实参





2、关键字传参

根据形参名称进行实参传递

看下这种，我是根据关键字的名字传参的，不会再根据顺序传递了

、、



3、如果传入的参数是可变对象，那么函数结束后，可变对象的值是会改变的；不可变对象的值出了函数是不会变的，看下面的例子即可理解：







三、函数的返回值

如果函数的返回值是多个，返回的结果为元组

四、函数参数的.]]></description><category></category></item><item><title><![CDATA[python 字符串2]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124160268</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124160268</guid><author>M_CODEEE</author><pubDate>Sat, 16 Apr 2022 23:10:20 +0800</pubDate><description><![CDATA[在进行字符串拼接操作的时候，尽量使用join方法，而非+；因为join方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象



一、字符串的常用操作

1、查询

index() 查找子串substr第一次出现的位置，如果查找的子串不存在，则抛出ValueError





rindex() 查找子串substr最后一次出现的位置，如果查找的子串不存在，则抛出ValueError





find() 查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1





rf...]]></description><category></category></item><item><title><![CDATA[20. 有效的括号]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124219814</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124219814</guid><author>M_CODEEE</author><pubDate>Sat, 16 Apr 2022 20:34:36 +0800</pubDate><description><![CDATA[代码：

用栈的思想


class Solution:
    def isValid(self, s: str) -&gt; bool:
        stack = []
        dic = {'(':')','[':']','{':'}'}
        for i in s:
            if i  in dic:
                stack.append(i)
            else:
                if not sta...]]></description><category></category></item><item><title><![CDATA[544. 输出比赛匹配对]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124215029</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124215029</guid><author>M_CODEEE</author><pubDate>Sat, 16 Apr 2022 15:57:13 +0800</pubDate><description><![CDATA[比较简单的字符串拼接...


class Solution:
    def findContestMatch(self, n: int) -&gt; str:
        l = [i for i in range(1,n+1)]
        while len(l) &gt; 2:
            new = []
            length = len(l)
            for i in range(0,length//2):
           ...]]></description><category></category></item><item><title><![CDATA[531. 孤独像素 I]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124211705</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124211705</guid><author>M_CODEEE</author><pubDate>Sat, 16 Apr 2022 12:45:23 +0800</pubDate><description><![CDATA[题目：







思路：

1、每个小list中，如果B的个数大于1，那么这个B肯定不满足一行中只有1个B

2、如果一行中只有一个B,记录这个B的下标

3、循环遍历每个小list的B下标的位置，如果找到了，并且不是当前行的B，那么就不满足一列只有一个B的要求



代码如下：


class Solution:
    def findLonelyPixel(self, picture: List[List[str]]) -&gt; int:
        num = 0
        fla.]]></description><category></category></item><item><title><![CDATA[209. 长度最小的子数组]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124204188</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124204188</guid><author>M_CODEEE</author><pubDate>Sat, 16 Apr 2022 11:54:39 +0800</pubDate><description><![CDATA[第一次没仔细审题，要是连续的子串，我直接想着把字符串逆序排序，然后找从前往后加....debug的时候才意识到....


class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -&gt; int:
        nums.sort(reverse = True)
        sum = 0
        num = 0
        for i in range(0,len(nums)):
 ...]]></description><category></category></item><item><title><![CDATA[差分数组 ~~]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124202442</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124202442</guid><author>M_CODEEE</author><pubDate>Fri, 15 Apr 2022 20:47:47 +0800</pubDate><description><![CDATA[给定一个序列 arry = [2,4,1,5,3]

看下其差分序列 d = [2,2,-3,4,-2]

如果对差分序列求前缀和 sum = [2,4,1,5,3]

可以看到为原数组 ：

如果我们相对原序列进行K次操作；举个例子

1、对arry[1~3]进行+1操作

2、对arry[0~4]进行 +3操作

求进行完这两次操作后数组为多少 ；

我们观察 差分序列求前缀和的操作，如果我想给1-3位置的元素+1，那我给差分数组1位置的元素标记+1，那么在进行前缀和操作的时候，1位置后面所有的元素都会]]></description><category></category></item><item><title><![CDATA[算法 前缀和初学]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124198868</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124198868</guid><author>M_CODEEE</author><pubDate>Fri, 15 Apr 2022 17:05:54 +0800</pubDate><description><![CDATA[给定数组 arry = [1,3,5,7,9]

假如我们要求 位置0-2的区间和：1+3+5 = 9

位置1-4的区间和 ： 3+5+7+9 = 24

我们应该怎样快速的实现呢？

设sum[i]为前i个元素的和：
sum[0] = arry[0] #只求位置1的和就直接等于数组第一个元素的值

sum[i] = sum[i-1]+arry[i]

我们根据这个式子计算下arry数组对应的sum

首先 sum[0] = arry[0] = 1

sum[1] = sum[1-1] + arry[..]]></description><category></category></item><item><title><![CDATA[370. 区间加法]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124195158</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124195158</guid><author>M_CODEEE</author><pubDate>Fri, 15 Apr 2022 16:53:54 +0800</pubDate><description><![CDATA[题目：



自己用最常规的思路写了下：


class Solution:
    def getModifiedArray(self, length: int, updates: List[List[int]]) -&gt; List[int]:
        target = []
        for i in range(length):
            target.append(0)
        if not updates:
            return target]]></description><category></category></item><item><title><![CDATA[python HJ4 字符串分隔]]></title><link>https://blog.youkuaiyun.com/M_CODEEE/article/details/124156975</link><guid>https://blog.youkuaiyun.com/M_CODEEE/article/details/124156975</guid><author>M_CODEEE</author><pubDate>Wed, 13 Apr 2022 20:35:50 +0800</pubDate><description><![CDATA[string = input()
length = len(string)
temp =length//8

if temp !=0:
    for i in range(length//8):
        for j in range(8*i,8*i+8):
            if j == 8*i+7:
                print(string[j])
            else:
                print(string[j],end='')

if.]]></description><category></category></item></channel></rss>