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 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ,则可以存储这个新的日程安排。

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

日程可以用一对整数 startend 表示,这里的时间是半开区间,即 [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" 来表示,该表达式总是包含两个表达式 e1e2 ,最终结果是 e1 表达式的值与 e2 表达式的值之
  • mult 表达式表示为 "(mult e1 e2)" ,其中 mult 总是以字符串 "mult" 表示,该表达式总是包含两个表达式 e1e2,最终结果是 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月 每日一题