LeetCode每日一题

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode每日一题相关的知识，希望对你有一定的参考价值。

参考技术A 使用前缀和

我的问题是找不到dp值代表了什么.找不到状态转移方程
dp[i][k]代表了我是从[j]跳了k步到这里的,[j]有哪几种状态呢,从前面的状态跳了 k + 1 , k , k - 1 步到 [j] ， [j] 才有可能跳 (k + 1) - 1 , k , (k - 1) + 1 步到 [i]

需要注意的地方
1.k > j+1时,是不可能从 j 跳到 i 的
2.因为是覆盖dp,所以 j 从 i - 1 到 0 遍历

下面的是正向思路，可能会好理解一点

暴力超时
使用双指针

我本来的思路是从>= low开始 >=high结束的,这样似乎也是要加条件语句,我在最前面加了,时间并没有少多少,所以这题有什么意思?

本来以为运力一点一点加上去这样暴力的做法是不可以的
第二个问题是不知道具体地处理某一运力下天数的做法
暴力是可以的，只不过需要用二分来优化

1.left为最小运力 maxelem ,right为最大运力 sumvec
2.在 left 和 right 中间有一个最小运力,使得 所需天数==D
3.使用cur表示当前的货物量, 货物量 > mid ,所需的天数++(这里使用了>的小技巧,如果使用<=作为判断条件,需要写的会多一点)
4.所需天数>D,运力不够, left = mid + 1 ,所需天数<= D,运力说不定还能再减一点. right = mid

使用回溯方法，但是超时了。想要用记忆化递归，但是不知道存的是什么。
后来想了想存的是target,但是还是超时了

使用动态规划

使用限定条件 INT_MAX - dp[i - num] 去除比如说990的cnt比999要大且990 的cnt > INT_MAX的情况

序列dp
使用f[]存最大长度,使用g[]存下标. j∈[0,i) 如果可以整除并且 f[j] + 1 > len 就修改保存,遍历完j在[i]后保存len长度和prev下标.
即[i]下存着前一个可以整除的下标
需要注意的地方,初始化prev应该是i,我初始化为0是错误的,当它没有可以整除的数或者被作为第一个被整除的数的时候,存的下标应为自己.

使用二维最大前缀和暴力解

需要注意的是,前缀和矩阵不能从 i``j 开始从 i + 1``j + 1 开始才是一个边长为1的矩形,不然的话k < 0 ,结果找到一个0max就为0了

先固定左边一排，右列逐渐向右。
通过最大连续子数组来剪枝,效果还挺好。最大连续子数组的max初始值记得设置为 nums[0] ,不然，无论max是INT_MIN的话放dp上面还是下面都不好受

分析一下，本题就是一个有条件的斐波那契数列，改了好久
例如
121 分为1 21 和12 1 f(n) = f(n - 1) + f(n - 2)

KMP算法、暴力算法、BM算法

使用pre作为新数组的最后一个元素。

####### 题解思路
我的想法是维护一个k宽度的map，因为map有自动排序功能，进一个出一个比较一个。
看了题解，思路没问题，就是自动排序也可以选择set

https://leetcode-cn.com/problems/scramble-string/solution/di-gui-by-powcai/
做递归,使用哈希表来完成记忆化递归，避免超时

我还以为可以一次遍历解决的.然后发现题解和我的思路一样

使用 next[26] 作为搜索节点、bool isend保存单词的终点。

中序遍历，两两相减的最小值

转数字为字符串后 30 > 3 ==> 303 实际330更大
3331 > 3 ==> 33313 实际应为33331
以数位比较复杂繁琐,使用模拟的方法会更简易
cmp ==> s1 + s2 > s2 + s1

二分

由上到下，由左到右分别进行二分搜索
https://mp.weixin.qq.com/s/M1KfTfNlu4OCK8i9PSAmug

输入 n 最右边的一位，赋给ans上它原本位置的对称位，右移一位。

(对顺序和重复次数无要求时)

1.使用map以int类型表示word中每个字符串对应的数以及其出现的次数.
2.在map中找到puzzle[i]的子集.

LeetCode2022 7月 每日一题

【LeetCode】2022 7月 每日一题

前言

七月太忙了，又是项目又是练车又是各种比赛。大概有10天的每日一题没有当天写完（虽然后面补上了）。

将每日一题的所有思路记录在这里分享一下。

7.1 为运算表达式设计优先级

题目

241. 为运算表达式设计优先级

给你一个由数字和运算符组成的字符串 expression ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。

生成的测试用例满足其对应输出值符合 32 位整数范围，不同结果的数量不超过 104 。

示例 1：

输入：expression = "2-1-1"
输出：[0,2]
解释：
((2-1)-1) = 0 
(2-(1-1)) = 2

示例 2：

输入：expression = "2*3-4*5"
输出：[-34,-14,-10,-10,10]
解释：
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

提示：

  • 1 <= expression.length <= 20
  • expression 由数字和算符 '+'、'-' 和 '*' 组成。
  • 输入表达式中的所有整数值在范围 [0, 99]

思路

本题是一道中等题，但是其思路万变不离其宗

复杂问题需要简单化，就需要分治。典型的分治问题

将一个表达式可以分成三个部分

  • 左部分（当成一个计算出结果的数据）
  • 中间部分（符号）
  • 有部分（右边的计算出结果的数据）

这么分完之后，我们又可以对左部分进行分解成三部分，右部分分解成三部分

最后将所有的左部分和右部分得到的结果放入到数组中，返回这个数组即可

如果转化成代码，那么就可以使用dfs进行左中右的分治，dfs(left, right)表示在[left, right]区间所有的计算结果的可能，而这个可能又可以分解成[left, i-1]与[i, right]两部分的结果相并

代码

ts版本

function diffWaysToCompute(expression: string): number[] 
    const s: string = expression

    const calc: Function = (num1: number, num2: number, sign: string): number => 
        let res: number = 0
        switch(sign) 
            case '+':
            res = num1 + num2
            break
            case '-':
            res = num1 - num2
            break
            case '*':
            res = num1 * num2
        
        return res
    

    const dfs: Function = (left: number, right: number): number[] => 
        let res: number[] = []
        for (let i = left; i <= right; i++) 
            let c = s[i]
            if (c >= '0' && c <= '9') continue
            let lRes = dfs(left, i - 1)		// 左部分
            let rRes = dfs(i + 1, right)	// 右部分
            for (let lr of lRes) 
                for (let rr of rRes) 
                    res.push(calc(lr, rr, c))
                
            
        
        // 计算数字
        if (res.length == 0) 
            let tmp = 0
            for (let i = left; i <= right; i++) 
                tmp = tmp * 10 + parseInt(s[i])
            
            res.push(tmp)
        
        return res
    

    return dfs(0, s.length-1)

7.2 最低加油次数

题目

871. 最低加油次数

汽车从起点出发驶向目的地，该目的地位于出发位置东面 target 英里处。

沿途有加油站，每个 station[i] 代表一个加油站，它位于出发位置东面 station[i][0] 英里处，并且有 station[i][1] 升汽油。

假设汽车油箱的容量是无限的，其中最初有 startFuel 升燃料。它每行驶 1 英里就会用掉 1 升汽油。

当汽车到达加油站时，它可能停下来加油，将所有汽油从加油站转移到汽车中。

为了到达目的地，汽车所必要的最低加油次数是多少？如果无法到达目的地，则返回 -1 。

注意：如果汽车到达加油站时剩余燃料为 0，它仍然可以在那里加油。如果汽车到达目的地时剩余燃料为 0，仍然认为它已经到达目的地。

示例 1：

输入：target = 1, startFuel = 1, stations = []
输出：0
解释：我们可以在不加油的情况下到达目的地。

示例 2：

输入：target = 100, startFuel = 1, stations = [[10,100]]
输出：-1
解释：我们无法抵达目的地，甚至无法到达第一个加油站。

示例 3：

输入：target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]
输出：2
解释：
我们出发时有 10 升燃料。
我们开车来到距起点 10 英里处的加油站，消耗 10 升燃料。将汽油从 0 升加到 60 升。
然后，我们从 10 英里处的加油站开到 60 英里处的加油站（消耗 50 升燃料），
并将汽油从 10 升加到 50 升。然后我们开车抵达目的地。
我们沿途在1两个加油站停靠，所以返回 2 。

提示：

  1. 1 <= target, startFuel, stations[i][1] <= 10^9
  2. 0 <= stations.length <= 500
  3. 0 < stations[0][0] < stations[1][0] < ... < stations[stations.length-1][0] < target

思路

困难题。属于是思路想不到，但是一旦想到，直接可以开始写。

我们可以把这个题看作，每次经过加油站，直接把油抬走。每次到车没油了，再在所有抬上车的油箱中，选择油最多的邮箱进行加油（贪心）

这样如果车上的油可以让我们到目的地，就成功返回加油次数，否则就返回-1

既然我们要每次加油加最多油的油箱，有一个数据结构非常适合，那就是优先队列（堆），这里选择大根堆，每次最多油的油箱放在最上面，需要用的时候就把他拿出来

代码

ts没有自带的优先队列实现，我这里直接硬写了一个实现的非常垃圾的有序数组来模拟大根堆（实际上仅仅是模拟堆头是最大的这一个功能罢了，其他的结构完全对不上哈哈哈哈…），原理就是每次插入，大的数据就差在前面，就这么简单

function minRefuelStops(target: number, startFuel: number, stations: number[][]): number 
    let loc = 0 // 当前行驶的路程
    let res = 0 // 加油的次数
    let nowFuel = startFuel // 当前拥有的油量
    let heap = new Q()  // 可以加油的加油站油量存储
    let curIdx = 0  // 当前经过的加油站的idx
    let ssl = stations.length
    while (loc < target)   // 只要没有到达target，就一直循环下去
        if (nowFuel == 0)  // 如果模拟到油没了，两种情况判断
            if (!heap.isEmpty()) nowFuel += heap.poll(); res++    // 大根堆里存在加油站可以加油
            else return -1  // 无法加油
        
        loc += nowFuel
        nowFuel = 0 // 继续行驶剩余油量
        // 经过的加油站都存储到大根堆里
        while (curIdx < ssl && stations[curIdx][0] <= loc) 
            heap.push(stations[curIdx++][1])
            // console.log(heap.arr)
        
    
    return res


// 憨憨方式模拟大根堆
class Q 
    arr: number[]
    constructor() 
        this.arr = []
    
    push(val: number) 
        if (this.arr.length == 0) 
            this.arr.push(val)
         else 
            let l = this.arr.length
            for (let i = 0; i < l; i++) 
                let curItem = this.arr[i]
                if (val >= curItem) 
                    if (i == 0) 
                        this.arr = [val].concat(this.arr)
                     else 
                        this.arr.splice(i, 0, val)
                    
                    break
                 else if(val < curItem && i == l - 1) 
                    this.arr = this.arr.concat([val])
                
            
        
    
    poll() 
        return this.arr.shift() || 0
    
    isEmpty() 
        return this.arr.length == 0

7.3 下一个更大元素 III

题目

556. 下一个更大元素 III

给你一个正整数 n ，请你找出符合条件的最小整数，其由重新排列 n 中存在的每位数字组成，并且其值大于 n 。如果不存在这样的正整数，则返回 -1 。

注意 ，返回的整数应当是一个 32 位整数 ，如果存在满足题意的答案，但不是 32 位整数 ，同样返回 -1 。

示例 1：

输入：n = 12
输出：21

示例 2：

输入：n = 21
输出：-1

提示：

  • 1 <= n <= 231 - 1

思路

这种题目属于是多解题了，我第一反应直接双指针。

讲讲我的思路吧，两个指针i、j，i在前，j在后

i去寻找s[i] < s[i+1]的位置，也就是找到一个可以进行交换的位置

j在i固定好后（找到位置后），从后向前遍历，寻找到一个比s[i]小的数，与s[i]交换，这样就能保证前半部分（到i的部分）是最小的

后半部分（i+1到末尾），需要确保也是最小的，那么就得sort排个序（或者reverse一下）

前半部分加上后半部分，转为int，结果判断是否是32位有符号数

代码

function nextGreaterElement(n: number): number 
    let s = [...n + ""]
    let l = s.length
    for (let i = l - 2; i >= 0; i--) 
        if (s[i] >= s[i + 1]) continue  // 左位比右位大，交换后的数会变小，直接跳过
        for (let j = l - 1; j > i; j--) 
            // 左位比右位小，从后向前找比s[i]大的那一位
            if (s[j] > s[i]) 
                // 交换两个
                let tmp = s[i]
                s[i] = s[j]
                s[j] = tmp
                break
            
        
        // 交换完后，要确保后面的部分是最小的
        let left = s.slice(0, i + 1)
        let right = s.slice(i + 1, l)
        right.sort()
        let res = parseInt(left.join('') + right.join(''))
        return res <= 2 ** 31 - 1 ? res : -1
    
    return -1

7.4 最小绝对差

题目

1200. 最小绝对差

给你个整数数组 arr，其中每个元素都 不相同。

请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。

每对元素对 [a,b] 如下：

  • a , b 均为数组 arr 中的元素
  • a < b
  • b - a 等于 arr 中任意两个元素的最小绝对差

示例 1：

输入：arr = [4,2,1,3]
输出：[[1,2],[2,3],[3,4]]

示例 2：

输入：arr = [1,3,6,10,15]
输出：[[1,3]]

示例 3：

输入：arr = [3,8,-10,23,19,-4,-14,27]
输出：[[-14,-10],[19,23],[23,27]]

提示：

  • 2 <= arr.length <= 10^5
  • -10^6 <= arr[i] <= 10^6

思路

先按升序排序，第一次遍历，获取最小绝对差

第二次遍历得到绝对差为最小绝对差的元素对

代码

function minimumAbsDifference(arr: number[]): number[][] 
    arr.sort((a, b) => a - b)   // 顺序排序
    // 第一次遍历，寻找最小绝对差
    let min = Number.MAX_VALUE
    for (let i = 0; i < arr.length-1; i++) 
        let cha = arr[i+1] - arr[i]
        if (cha < min) 
            min = cha
        
    
    // 第二次遍历，获取绝对差为最小绝对差的元素对
    let res = []
    for (let i = 0; i < arr.length-1; i++) 
        if (arr[i+1] - arr[i] == min) 
            res.push([arr[i],arr[i+1]])
        
    
    return res

7.5 我的日程安排表 I

题目

729. 我的日程安排表 I

实现一个 MyCalendar 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ，则可以存储这个新的日程安排。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生 重复预订 。

日程可以用一对整数 start 和 end 表示，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end 。

实现 MyCalendar 类：

  • MyCalendar() 初始化日历对象。
  • boolean book(int start, int end) 如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true 。否则，返回 false 并且不要将该日程安排添加到日历中。

示例：

输入：
["MyCalendar", "book", "book", "book"]
[[], [10, 20], [15, 25], [20, 30]]
输出：
[null, true, false, true]

解释：
MyCalendar myCalendar = new MyCalendar();
myCalendar.book(10, 20); // return True
myCalendar.book(15, 25); // return False ，这个日程安排不能添加到日历中，因为时间 15 已经被另一个日程安排预订了。
myCalendar.book(20, 30); // return True ，这个日程安排可以添加到日历中，因为第一个日程安排预订的每个时间都小于 20 ，且不包含时间 20 。

提示：

  • 0 <= start < end <= 109
  • 每个测试用例，调用 book 方法的次数最多不超过 1000 次。

思路

使用公交车站的思路，理解为start时刻上车一人，end时刻下车一人

同时要保证公交车仅仅能够乘坐一个人，如果上车后多余一个人，那么就无法让其上车

要注意，输入的那个列表需要按时间排序，因为是按照时间来进行上下车的

代码

class MyCalendar 
    map: Map<number, number> = new Map()
    constructor() 
    

    book(start: number, end: number): boolean 
        let map = this.map
        map.set(start, map.get(start) === undefined ? 1 : map.get(start) + 1)
        map.set(end, map.get(end) === undefined ? -1 : map.get(end) - 1)
        let arr = Array.from(map)
        arr.sort((a, b) =>  return a[0] - b[0] ) // 按时间排序
        let tmp = 0
        for (let val of arr) 
            tmp += val[1]
            if (tmp > 1)   // 交叉了，还原，返回false
                map.set(start, map.get(start) === undefined ? -1 : map.get(start) - 1)
                map.set(end, map.get(end) === undefined ? 1 : map.get(end) + 1)
                return false
            
        
        return true

7.6 Lisp 语法解析

题目

736. Lisp 语法解析

给你一个类似 Lisp 语句的字符串表达式 expression，求出其计算结果。

表达式语法如下所示:

  • 表达式可以为整数，let 表达式，add 表达式，mult 表达式，或赋值的变量。表达式的结果总是一个整数。
  • (整数可以是正整数、负整数、0)
  • let 表达式采用 "(let v1 e1 v2 e2 ... vn en expr)" 的形式，其中 let 总是以字符串 "let"来表示，接下来会跟随一对或多对交替的变量和表达式，也就是说，第一个变量 v1被分配为表达式 e1 的值，第二个变量 v2 被分配为表达式 e2 的值，依次类推；最终 let 表达式的值为 expr表达式的值。
  • add 表达式表示为 "(add e1 e2)" ，其中 add 总是以字符串 "add" 来表示，该表达式总是包含两个表达式 e1、e2 ，最终结果是 e1 表达式的值与 e2 表达式的值之 和 。
  • mult 表达式表示为 "(mult e1 e2)" ，其中 mult 总是以字符串 "mult" 表示，该表达式总是包含两个表达式 e1、e2，最终结果是 e1 表达式的值与 e2 表达式的值之 积 。
  • 在该题目中，变量名以小写字符开始，之后跟随 0 个或多个小写字符或数字。为了方便，"add" ，"let" ，"mult" 会被定义为 “关键字” ，不会用作变量名。
  • 最后，要说一下作用域的概念。计算变量名所对应的表达式时，在计算上下文中，首先检查最内层作用域（按括号计），然后按顺序依次检查外部作用域。测试用例中每一个表达式都是合法的。有关作用域的更多详细信息，请参阅示例。

示例 1：

输入：expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"
输出：14
解释：
计算表达式 (add x y), 在检查变量 x 值时，
在变量的上下文中由最内层作用域依次向外检查。
首先找到 x = 3, 所以此处的 x 值是 3 。

示例 2：

输入：expression = "(let x 3 x 2 x)"
输出：2
解释：let 语句中的赋值运算按顺序处理即可。

示例 3：

输入：expression = "(let x 1 y 2 x (add x y) (add x y))"
输出：5
解释：
第一个 (add x y) 计算结果是 3，并且将此值赋给了 x 。 
第二个 (add x y) 计算结果是 3 + 2 = 5 。

提示：

  • 1 <= expression.length <= 2000
  • exprssion 中不含前导和尾随空格
  • expressoin 中的不同部分（token）之间用单个空格进行分隔
  • 答案和所有中间计算结果都符合 32-bit 整数范围
  • 测试用例中的表达式均为合法的且最终结果为整数

思路

纯纯的困难题，思路其实很简单，要么dfs要么就分治（其实都算分治吧），写法上的区别存粹就是自己定义属性上的区别

我这里借鉴了高阅读量题解的思路，直接一整个复现了一下，debug搞了20多分钟，纯纯的细节题

自己还是理一遍思路吧：

对于一个expression表达式，我们首先进行一个分解

例如"(let a 114 b 514 (add a b))"，我们应该分解成两个部分，let部分和add部分

  • let部分我们叫做定义部分
  • add部分叫做剩余expression部分

我们在定义部分，对其中的变量进行map的映射赋值操作

在剩余expression部分进行最终返回值的计算

例如上面的例子就可以分解成

  • let a 114 b 514
  • return (add a b)

对于剩余的expression部分，我们又可以对其进行分解，分解成定义部分和剩余部分，直到所有的值被计算完，就返回结果

代码

function evaluate(expression: string): number 
    const LET: string = 'let'
    const ADD: string = 'add'
    // const MULT: string = 'mult'

    /**
     * 对表达式进行分解
     * 
     * @param expr 表达式
     * @returns 分解后的表达式
     */
    const parseExpress = (expr: string) => 
        expr = expr.substring(1, expr.length - 1)
        let res: string[] = []
        let left: number = 0    // 左指针
        let right: number = 0   // 右指针
        let len = expr.length
        while (right < len) 
            if (expr[right] === ' ') 
                // 是空格，那么可以分割成let v1 e1 和 一部分expr
                res.push(expr.substring(left, right))
                left = right + 1    // 左指针指向下一个内容
             else if (expr[right] === '(') 
                // 是左括号，证明遍历到了expr的部分，进行括号统计，找到当前携带括号的expr的作用域
                let cnt = 0
                while (right < len) 
                    if (expr[right] === '(') cnt++
                    else if (expr[right] === ')') cnt--
                    right++
                    if (cnt === 0) break    // cnt再次为0表示括号统计完毕
                
                res.push(expr.substring(left, right))
                left = right + 1
            
            right++     // 右指针继续向下遍历
        
        if (left < len)    // 如果没有出现左括号，补充剩余部分x
            res.pushleetcode 每日一题 953. 验证外星语词典


 LeetCode2022 7月 每日一题


 LeetCode2022 7月 每日一题


 LeetCode9月 每日一题


 LeetCode9月 每日一题


 LeetCode9月 每日一题