Python on 一共十七划

题解-通过操作使数组长度最小筑-脑筋急转弯,用小数踢掉大数

Sun, 21 Jan 2024 01:51:17 +0800

Problem: 100164. 通过操作使数组长度最小

思路

观察$nums[i]%nums[j]$有如下的可能性
- 如果$nums[i]<nums[j]$,最后只是将数组中的$nums[j]$踢出
- $nums[i]>=nums[j]$则是二者踢出,$nums[i]%nums[j]$进入数组,且显然$nums[i]%nums[j]<nums[j]<=nums[i]$
因为没有限定ij的关系,发现这种操作要么是小数将大数从数组中踢掉,要么是引入一个更小的数,将二者踢掉
最后剩下的长度应该和数组中最小值有关,且这个最小值包括操作中可能产生的
如果没有产生新的最小值,则很容易知道最后剩下的数就是原始数组中最小值的数量,然后将其两两组合,引进0,就能得到答案
如何产生更小值:
- 回顾1,我们将所有数与最小值相模
- 如果余数不为0,就为新的最小值
- 如果余数全为0,说明所有数都是最小值的倍数,则它们之间两两相模的最小值大于等于原始数组的最小值
我们只需要产生一个新的更小值就能把所有其他数都踢掉,此时答案是1

时间复杂度:$O(n)$

Code

class Solution:
    def minimumArrayLength(self, nums: List[int]) -> int:
        m=min(nums)
        for num in nums:
            if num%m!=0:# 可以产生新的最小值
                return 1
        length=nums.count(m)
        return length//2+length%2

题解-需要添加的硬币的最小数量-最大化在缺口处补硬币的作用

Sun, 03 Dec 2023 12:05:00 +0800

Problem: 100153. 需要添加的硬币的最小数量

思路

这题和LeetCode-1798. 你能构造出连续值的最大数目很像,很经典的想法
是子序列所以先排序
先考虑我们手里的硬币能构造出来多少
假设我们手里的硬币足够我们构造出来[0,x),接下来我们又拿到了一个硬币,数值为y,
- 如果我们把y放进之前的所有序列之中,会发现我们能够构造[y,x+y)
- 再加上刚才的区间,我们手里的硬币加y之后能构造的数的范围为$[0,x)\bigcup[y,x+y)$
- 如果y<=x则我们能够构造的数就能达到[0,x+y)
- 如果y>x则会有一段空缺
为了填补这段空缺,我们应该往里面放另一块硬币,假设为z,根据上面的推论,我们很容易得到z会生成的片段为[z,x+z),而且z的取值范围应该为[y-x,x],为了让填补有效,且最大化填补的内容,应该让z=x,因为这样能最大化填补的空缺
- 取最大更有可能单次填补完空缺
而我们遇到的问题只是将y换成了target,所有遇到的大于当前x的也认为是y即可

Code

class Solution:
    def minimumAddedCoins(self, coins: List[int], target: int) -> int:
        coins.sort()
        res=0
        canMake=0 #能生成的范围是[0,canMake]
        i=0
        while i<(len(coins)):
            val=coins[i]
            if val<=canMake+1:
                canMake+=val
                i+=1
            else:
                res+=1 #这里补的硬币就是canMake+1
                canMake+=canMake+1
        while canMake<target:
            res+=1
            canMake+=canMake+1
        return res

题解-求和游戏-数学,以及简单分类证明

Fri, 01 Dec 2023 20:15:11 +0800

Problem: 1927. 求和游戏

初始思路

考虑一些等价:我们先把这个数分为两个部分$left,right$,分别是左右两边数字的和,形式化写为$\displaystyle right=\sum_{i=n/2}^{n}num_i(0<=num_i<=9)$剩下的问号数量分别为$n_{left},n_{right}$
我们要做的实际上是对$left和right$分别操作$n_{left},n_{right}$n次,其中我们允许的操作就是对该数加上0-9的任意一个数
显然操作是对称的,所以我们只考虑有效的操作数,也就是$abs(n_{left}-n_{right})$,而且显然有效的操作数只会存在于一个数身上:如果出现在两个身上就会对称消除
我们可以先除去一些情况:
- 如果剩下的有效操作是奇数,则Alice一定赢,因为她一定不会选择让数相等的操作(只有一个选择),而Alice有10个合法选择
- 然后我们发现操作一定会让数增加,也就是说,如果存在有效操作的是较大的那个数,则一定不可能相等
现在我们只剩下了一种情况:有一个较小的数能够让双方都操作$x$次,如何让较小的数变为较大的数
设两数相差的绝对值为$gap$,每个人能操作$x$次
Alice有两个选择:
- 一个是积极加,在自己的回合里都加9,这样会让较小的数飞快增长,如果两数相差比较小,就能让这个数超过大点的数,从而Bob不能选出来:也就是$9x>gap$,Alice能赢
- 另一个是完全消极,每次都加0,这样会让数缓慢增长,单靠Bob变数增加,如果$gap>9x$,此时Alice也赢
我们惊讶地发现此时出现了9x大于小于gap,Bob都会输,就只剩下了$$9x==gap$$,所幸,我们能发现此时Bob会赢,因为不管此时Alice如何操作,Bob后手都能补齐9

Code

class Solution:
    def sumGame(self, num: str) -> bool:
        n=len(num)
        nums=0
        left=0
        right=0
        for i in range(n//2):
            if num[i]=='?':
                nums+=1
            else:
                left+=ord(num[i])-ord('0')
        for i in range(n//2,n):
            if num[i]=='?':
                nums-=1
            else:
                right+=ord(num[i])-ord('0')
        if nums%2!=0 or (left>right and nums>0) or (left<right and nums<0):
            #最后轮到Alice或者一定不能赢的情况
            return True
        AliceCan=abs(nums)//2
        want=abs(left-right)
        if AliceCan*9!=want:
            return True
        return False

题解-找出叠涂元素-哈希表,两种思路,在途中检查和在最后检查

Fri, 01 Dec 2023 08:51:11 +0800

Problem: 2661. 找出叠涂元素

思路:中途检查

解法

数据量不大,看着可以在每次涂色时候查询是否合法
但是每次都查询显然会超时,我们选择一个更有效的优化
已经说明各个数各不相同,不会出现一个格子被涂两遍的情况
我们用数组来记录每一行和每一列已经被涂的格子数量,就能知道这一行列是否被全涂满

时间复杂度: $O(m*n)$

空间复杂度: $O(m*n)$

Code

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        matMap={} 
        m=len(mat)
        n=len(mat[0])
        row=[0]*m
        col=[0]*n
        for i in range(m):
            for j in range(n):
                matMap[mat[i][j]]=(i,j) 
        for index in range(len(arr)):
            num=arr[index]
            x,y=matMap[num]
            row[x]+=1
            col[y]+=1
            if row[x]==n or col[y]==m:
                return index
            
        return -1

思路:最后查询

解法

我们注意到当我们知道某一行的所有元素的时候,变相知道了这一行会被什么时候涂满,既这一行存在arr中最靠后的那个索引
所以我们的任务变成了寻找最先被涂满的行或者列
对arr进行hash,记录每个元素的具体位置,再遍历行列,在遍历过程中
- 行列取最大值表示让这一行填满最少需要的步数
- res取上述的数的最小值时间复杂度: $O(mn)$ 空间复杂度: $O(mn)$

Code

class Solution {
public:
    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
        int res=arr.size();
        unordered_map<int,int>hash;
        for (int i=0;i<arr.size();i++){
            hash[arr[i]]=i;
        }
        for (int i=0;i<mat.size();i++){
            int tmp=0;
            for (int j=0;j<mat[0].size();j++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        for (int j=0;j<mat[0].size();j++){
            int tmp=0;
            for (int i=0;i<mat.size();i++){
                tmp=max(tmp,hash[mat[i][j]]);
            }
            res=min(res,tmp);
        }
        
        return res;
    }
};

class Solution:
    def firstCompleteIndex(self, arr: List[int], mat: List[List[int]]) -> int:
        res=len(arr)
        m=len(mat)
        n=len(mat[0])
        arrLocation={}
        for i,a in enumerate(arr):
            arrLocation[a]=i
        for i in range(m):
            nowColNeedSteps=0
            for j in range(n):
                nowColNeedSteps=max(nowColNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowColNeedSteps)
        for j in range(n):
            nowRowNeedSteps=0
            for i in range(m):
                nowRowNeedSteps=max(nowRowNeedSteps,arrLocation[mat[i][j]])
            res=min(res,nowRowNeedSteps)           
        return res

题解-统计子串中的唯一字符-哈希表+栈，计算贡献

Sun, 26 Nov 2023 16:17:28 +0800

Problem: 828. 统计子串中的唯一字符

思路

注意到一个唯一字符对数个子串生效，也就是在多个子串中唯一字符是固定的那几个，很容易想到贡献法
对于子串起点和终点我们设置成$left,right$,任意字符位置为$a_i$序列,让子串生效的范围是$left-right$这个范围内,存在一个字符a,其序列满足
$$a_{i-1}<left<=a_i<=right<a_{i+1}$$,
同样可以通过枚举起点终点,得知满足这个条件子串的个数为 $(a_i-a_{i-1})*(a_{i+1}-a_{i})$,
为了计算方便我们将-1和n作为每个字符的两端,既$a_{-1}=-1,a_{n+1}=n$
该字母在$a_i$上为答案做的贡献就等于子串的数量

解题方法

使用哈希表存储每个字母的位置序列
为了前后方便我们使用栈来维护具体的字母序列

时间复杂度,O(n)
空间复杂度,O(n)

Code

class Solution:
    def uniqueLetterString(self, s: str) -> int:
        n=len(s) 
        hash=[[n] for _ in range(26)] #最右端点
        for i in range(len(s)-1,-1,-1):
            hash[ord(s[i])-ord('A')].append(i)
            #小的在顶部,大的在底部
        res=0
        for i in range(26):
            pre=-1
            while len(hash[i])>1:
                index=hash[i].pop()
                back=hash[i][-1]
                res+=(index-pre)*(back-index)
                pre=index
        return res

题解-找到 Alice 和 Bob 可以相遇的建筑-单调栈+二分+离线

Sun, 19 Nov 2023 14:19:00 +0800

Problem: 100110. 找到 Alice 和 Bob 可以相遇的建筑

思路

分解一下题目,发现和Alice和Bob二人顺序没关系,为了方便,我们假设Alice所在建筑位置在左边,称为a,bob就会在右边,称为b
假设a,b相等,则所在的位置就是b
若b所在高度大于a,则答案是b
剩下的就是我们要考虑的一般情况:b的高度小于a,

解题方法

我们要做的明确,查b的右侧大于a的第一个建筑
每次都向后查询显然时间复杂度不够,遍历q又是必须的,所以我们想把这个查询压到log级别
显然可以通过维护右侧单调栈+二分的模式
但是为每一个点都配单调栈内存不够
我们发现左边的单调栈一定是右边的转过来的
所以我们只需要维护一个单调栈
在遇到对于要处理的点的查询的时候直接查询就行
也就是我们总体过程是离线查询+单调栈+二分

代码细节

我们先用哈希表记录查询,保证不漏:
先保证a<=b
以b为key,存储想查询的值:a和答案位置i
需要注意的是可能存在多个a的情况,需要用列表而不是一一对应
从后向前遍历,维护单调栈
对于遍历的点,如果在哈希表内,说明其是b
现在维护的单调栈满足需求
二分查到的答案再写回相应的位置

Code

class Solution:    
    def leftmostBuildingQueries(self, heights: List[int], queries: List[List[int]]) -> List[int]:
        n=len(queries)  
        hash={}#记录b对应的a和index
        for i in range(n):
            a=min(queries[i])
            b=max(queries[i])
            if b not in hash:
                hash[b]=[]
            hash[b].append([a,i])
    #记录右边单调递增
    st=[]
    res=[-1]*n
    for i in range(len(heights)-1,-1,-1):
        h=heights[i]
        while st and h&gt;heights[st[-1]]:
            st.pop()
        st.append(i)
        if i in hash:
            b=i
            for a,index in hash[i]:
                if heights[b]&gt;heights[a] or a==b:
                    res[index]=b
                else:
                    l,r=0,len(st)-1
                    while l&lt;=r:
                        mid=(l+r)//2
                        if heights[st[mid]]&gt;heights[a]:
                            l=mid+1
                        else:
                            r=mid-1
                    if (l-1&lt;0):
                        res[index]=-1
                    else:
                        res[index]=st[l-1]
    return res</code></pre>



题解-逃离火灾-两次BFS-在路上不会被烧到,处理边界
Thu, 09 Nov 2023 09:23:43 +0800

Problem: [2258. 逃离火灾](https://leetcode.cn/problems/escape-the-spreading-fire/description/)


思路
– 由题意可知需要计算一条最短路,耗时最短以保证后续火传过来的时候让火传递的时间足够长来接近答案
– 火的蔓延时间用DFS求解,可以求出来火到各个节点的最少用时
– 应该考虑每次刷新一下出发时间来看此次最短路是否被烧掉吗?其实不用
    – 只需要考虑在终点人能否比火早到即可
    – 假如人在路上遇到火,则火到终点的用时一定小于等于人
– 保证了到终点的时候火耗时大于人可以反推出
    1. 人和火相遇的路都能保证有如此长的等待时间
    2. 若人和火不相遇则显然
细节
1. 如果起点起火不可达
2. 对于只有人可达的情况,是等待多久都可以的情况
3. 重点:因为允许人和火同时进安全屋,但是不能要求其他格子里人和火同时到
    1. 考虑将终点旁边的两格当做终点,如果他们到达终点所剩下的时间大于等于1,显然可以在外面等一分钟
解题方法
– 两遍BFS求火和人到各个节点的距离
– 对于起点和终点的几种情况特判
– 查询以终点左边和上边的点是否允许多等一分钟
– 返回答案
Code
class Solution:
    def maximumMinutes(self, grid: List[List[int]]) -> int:
        n=len(grid[0])
        m=len(grid)
        times=[[0x7fffffff]*n for _ in range(m)]
        q=deque()
        directions=[[0,-1],[0,1],[1,0],[-1,0]]
        for i in range(m):
            for j in range(n):
                if grid[i][j]==1:
                    q.append([i,j])
                elif grid[i][j]==2:
                    times[i][j]=-1#不可达
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                times[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        #然后我们求人到各个节点用时
        people=[[0x7fffffff]*n for _ in range(m)]
        q.append((0,0))
        h.clear()
        now=0
        h=set()  
        while q:
            length=len(q)
            for _ in range(length):
                i,j=q.popleft()
                people[i][j]=now
                h.add((i,j))
                for dx,dy in directions:
                    x,y=i+dx,j+dy
                    if 0<=x<m and 0<=y<n and grid[x][y]!=2 and grid[x][y]!=1 and (x,y) not in h:
                        q.append((x,y)) 
            now+=1
        if times[-1][-1]<people[-1][-1] or people[-1][-1]==0x7fffffff:
            return -1 
        if times[0][0]==0:
            return -1
        if times[-1][-1]==0x7fffffff:
            return 1000000000#火不可达,说明人到火这一路都没有火
        maxNeed=times[-1][-1]-people[-1][-1]
        if times[-1][-2]>people[-1][-2]+maxNeed or times[-2][-1]>people[-2][-1]+maxNeed:
            return maxNeed
        return maxNeed-1



题解-每棵子树内缺失的最小基因值
Tue, 07 Nov 2023 15:33:00 +0800

每棵子树内缺失的最小基因值

题目简介
有一棵根节点为 0 的家族树 ，总共包含 n 个节点，节点编号为 0 到 n – 1 。给你一个下标从 0 开始的整数数组 parents ，其中 parents[i] 是节点 i 的父节点。由于节点 0 是 根 ，所以 parents[0] == -1 。
总共有 $10^5$ 个基因值，每个基因值都用 闭区间 $[1, 10^5]$ 中的一个整数表示。给你一个下标从 0 开始的整数数组 nums ，其中 nums[i] 是节点 i 的基因值，且基因值互不相同 。
请你返回一个数组 ans ，长度为 n ，其中 ans[i] 是以节点 i 为根的子树内 缺失 的 最小 基因值。
节点 x 为根的 子树 包含节点 x 和它所有的后代节点。
思路

在概念上与41. 缺失的第一个正数题类似,都是找数,由于本题没有要求O(1)O(1)O(1)的空间复杂度,所以用哈希表是可能的
与数组中缺失的第一个正数类似的是,如果一棵树的节点不包括1,则以该树的任意节点为根的的子树都缺少1,这是最简单的情况
对于子节点有1的才是重要讨论的情况

解题方法

注意到需要处理的只是根节点到基因值为1的这一段的每个节点  

注意到此时讨论的只是一条链
其他的节点的缺失值一定为1


可以用哈希表记录以该节点为根的子树包含的所有基因值,然后再每个节点都遍历一下
上述复杂度很高,再仔细观察节点的哈希表的形式,可以知道父节点的哈希表是所有子节点的合集加上自己的基因数

所以我们只需要自底向上遍历,维护一个哈希表就可以了
注意到父节点缺失的值不可能比子树缺失的还小,所以也需要维护一个基因数


时间复杂度:$O(n)$
空间复杂度:$O(n)$

代码
class Solution:
    def smallestMissingValueSubtree(self, parents: List[int], nums: List[int]) -> List[int]:
        n=len(parents)
        res=[1]*n #默认最有可能缺1
        if 1 not in nums:
            return res
        graph=[[]for _ in range(n)]
        for i in range(1,n):
            graph[parents[i]].append(i)
    visited=set()  
    def dfs(index):
        visited.add(nums[index])
        for child in graph[index]:
            if nums[child] not in visited:
                dfs(child)

    root=nums.index(1) #找分界点
    now=2
    while root&gt;=0: #自底向上递归查找
        dfs(root)
        while now in visited:
            now+=1
        res[root]=now
        root=parents[root]
    return res</code></pre>

其他
这个理论上不能用与41题类似的将数组本身化为哈希表的操作,不然代码的复杂性很高,而且也不好理解


题解-做菜顺序-排序,贪心,前缀和,一点点证明
Sun, 22 Oct 2023 08:16:17 +0800

Problem: 1402. 做菜顺序


思路

注意到没有要求顺序,先排序
朴素思想是将大的数越往后放越好,但对于负数,虽然也是越大越往后放越好,但其有可能增加答案,也有可能减少答案,需要一些证明

解题方法

注意到对于负数的选取一定是连续而非跳跃的:假设存在$[a_{i-1},a_i,a_{i+1}].a_i<a_{i+1},$数组,三者均小于0,假如一定要取两个元素,(这种假定的含义是我需要后面的正数有足够的倍数,期望前面提供倍数的负数(代价)最小),选取元素$a_{i-1},a_{i+1}$代价大于选取$a_i,a_{i+1}$
推广可知我们会选取所有的正数和部分负数,且负数在排序后的数组中是连续的,并且和正数部分相连
实际上是求一个子数组的这个操作最大能多大,可以枚举每一次从哪选,结束一定是在最大的数结束
然后简化:注意到相关操作实际上是对于之前结果再加上一次已经遍历的数,所以可以将其转化为一遍扫描的方式


时间复杂度, $O(nlogn)$

Code
class Solution:
    def maxSatisfaction(self, satisfaction: List[int]) -> int:
        satisfaction.sort(reverse=True) #方便操作
        res=0
        pre=0
        now=0
        for num in satisfaction:
            pre+=num
            now+=pre
            res=max(now,res)
            if now<0:
                break #之后一定小于0
        return res



题解-最长相邻不相等子序列 II
Sun, 15 Oct 2023 02:42:00 +0800

Problem:最长相邻不相等子序列

题目
给你一个整数 n 和一个下标从 0 开始的字符串数组 words ，和一个下标从 0 开始的数组 groups ，两个数组长度都是 n 。
两个长度相等字符串的 汉明距离 定义为对应位置字符 不同 的数目。
你需要从下标 [0, 1, ..., n - 1] 中选出一个 最长子序列 ，将这个子序列记作长度为 k 的 [i₀, i₁, ..., i_{k - 1}] ，它需要满足以下条件：

相邻 下标对应的 groups 值 不同。即，对于所有满足 0 < j + 1 < k 的 j 都有 groups[i_j] != groups[i_{j + 1}] 。
对于所有 0 < j + 1 < k 的下标 j ，都满足 words[i_j] 和 words[i_{j + 1}] 的长度 相等 ，且两个字符串之间的 汉明距离 为 1 。

请你返回一个字符串数组，它是下标子序列 依次 对应 words 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。
子序列 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。
注意：words 中的字符串长度可能 不相等 。


题解-有向图访问计数,一个有向基环树的简单应用
Sat, 14 Oct 2023 08:27:00 +0800
> Problem: 2876. 有向图访问计数
思路
– 注意到这个图一定有环,而且每个点的出度都为1
– 由题意可知从任意节点出发其都能访问到相关的环
– 答案只分为两个情况:
    – 点在环上,此时能访问的点只有环上的点,不可能出环,答案为环的长度
    – 点在环外,除了环本身之外,其能访问本节点到环的几个节点,答案为环的长度加上其到环的距离
– 注意到可能有多个环相互独立存在,但是不可能出现两个环连通,所以几个图之间互相并不干扰
解题方法
1. 由以上思路得到基本想法,遍历解决每一个单独的环即可
2. 选择一个没有访问的节点,开始访问,其一定能进入环
    1. 记录初次访问访问点的深度
    2. 判断是否已经入环的方法就是判断该节点是否已经访问过
3. 对于当前点已经访问过有两种情况:
    1. 当前节点在之前的旧图上就访问过:此时根据访问深度加上之前已经得出点的答案来更新答案数组
    2. 当前节点是在这个新图上访问两次:此时第二次访问深度减去节点访问深度就是环的长度,更新环上节点的答案,环外带上的节点根据访问深度加环的长度更新
4. 持续上述操作直到所有节点都访问过,因为我们每次都将单个有环图的所有节点处理,所以每个节点都已经处理
> 时间复杂度,$O(n)$
> 空间复杂度,$O(n)$
代码
,对于这种问题应该可以补一个快慢指针法,但是此处没有做
class Solution:
    def countVisitedNodes(self, edges: List[int]) -> List[int]:
        n=len(edges)
        res=[-1]*n
        visited=set()
        for i in range(n):
            if i in visited:
                continue
            now=begin=i #记录begin就不用做反图,直接顺序遍历就能找到答案
            tmp=dict()#记录此次遍历的时候访问的点
            index=0
            while now not in visited:
                tmp[now]=index
                visited.add(now)
                index+=1
                now=edges[now]
            # 此时我们访问了的图有三种可能,一条带,一个环,一个有带的环
            # 后两种可能都是如下解法
            if now in tmp:
                #此时tmp[now]长度为点到环的长度
                belt=dict()
                circle=set()
                length=tmp[now]
                now=begin
                while length>0:
                    belt[now]=length
                    length-=1
                    now=edges[now]
                while now not in circle:
                    circle.add(now)
                    now=edges[now]
                r=len(circle)#环的长度
                for u in tmp:
                    res[u]=r if u in circle else r+belt[u]
            # 第一种可能是比较好处理的
            else:
                #说明连接到了之前的有向基环树上,直接与已经访问的点相加即可
                length=index
                baseLength=res[now]
                now=begin
                while length>0:
                    res[now]=baseLength+length
                    now=edges[now]
                    length-=1
    return res</code></pre>



题解-哈希表,用输入流实现C++的split函数
Wed, 11 Oct 2023 06:07:00 +0800

题目:奖励最顶尖的 K 名学生

题目描述
给你两个字符串数组 positive_feedback 和 negative_feedback ，分别包含表示正面的和负面的词汇。不会 有单词同时是正面的和负面的。
一开始，每位学生分数为 0 。每个正面的单词会给学生的分数 加 3 分，每个负面的词会给学生的分数 减  1 分。
给你 n 个学生的评语，用一个下标从 0 开始的字符串数组 report 和一个下标从 0 开始的整数数组 student_id 表示，其中 student_id[i] 表示这名学生的 ID ，这名学生的评语是 report[i] 。每名学生的 ID 互不相同。
给你一个整数 k ，请你返回按照得分 从高到低 最顶尖的 k 名学生。如果有多名学生分数相同，ID 越小排名越前。
思路

题目不难,只需要对比各个词出现次数就可以
对于不同语言来说上面的可能有一定难度
所以写了一版C++的split(是用输入流实现的)

代码
class Solution {
public:
  vector<int> topStudents(vector<string>& positive_feedback, vector<string>& negative_feedback, vector<string>& report, vector<int>& student_id, int k) {
      unordered_map<string,int>score;
      vector<pair<int,int>>list;//直接嵌套vector的时间效率不如pair
      for (auto word:positive_feedback) score[word]=3;
      for (auto word:negative_feedback) score[word]=-1;
      for (int i=0;i<student_id.size();i++){
          string words=report[i];
          int id=student_id[i];
          int s=0;
          string key;
          istringstream is(words);//将字符转成输入流然后操作
          while(getline(is,key,' ')){
              if (score.count(key))
                  //key不存在时int默认为0,但是那样效率不
                  s+=score[key];如判断高
          }
          list.emplace_back(make_pair(id,s));
      }
      sort(list.begin(),list.end(),[&](const pair<int,int>a,const pair<int,int>b){
          return a.second>b.second ||(a.second==b.second&&a.first<b.first);
      });
      vector<int>res;
      for (int i=0;i<k;i++){
          res.emplace_back(list[i].first);
      }
      return res;
}
};



题解-移动机器人-数组计算的三种思考方式方式(动态规划,贡献,前缀和)与相关证明
Tue, 10 Oct 2023 08:04:17 +0800

Problem: 2731. 移动机器人


前述条件

碰撞和1503. 所有蚂蚁掉下来前的最后一刻类似,注意到对于身份没有要求,所以可以直接认为两个机器人碰撞是交换了二者的身份,也可以认为是穿过去了
因此能够得到机器人的最终位置,为了方便计算,我们排序
数据量为$10^5$,暴力求解不现实
以下是三种常用的解决方法,这三种思路最开始的进入方式不同,但是都能得出正确结果

两种对于距离的计算方法
算法的时间复杂度均为$O(n)$
动态规划
思考方式与证明

假设已经计算出来了$a[i]$之前所有的机器人两两之间距离之和为$s$
增加一个元素$a[i]$,观察其和之前的所有机器人之间的距离之和,能够发现

实际上就是与之前的每个元素计算距离
$a[i]$与$a[0],a[1]….,a[i-1]$之间的距离实际上分别是是$a[i-1]$与$a[0]….,a[i-1]$之间的距离加上$a[i]$与$a[i-1]$之间的距离,共$i$个
上述结论可以推导:
设$distance[i]$表示$a[i]$和$a[0],a[1]….,a[i-1]$之间的距离之和,有
$$ distance[i]=i*a[i]+distance[i-1] \distance[0]=0 $$



代码
可以看出来这个公式只与前一个状态有关,因此可以优化空间
class Solution:
    def sumDistance(self, nums: List[int], s: str, d: int) -> int:
        mod=1000000007
        n=len(nums)
        for i,a in enumerate(s):
            nums[i]+=d if s[i]=='R' else -d  
        nums.sort()
        res=0
        distance=0
        for i in range(1,n):
            distance+=i*(nums[i]-nums[i-1]) 
            #这个方法对于只int的话4*(10**9)会超范围
            distance%=mod  
            res+=distance
        return res%mod
贡献距离法
思考方式

对于这种什么什么之和的问题可以考虑计算每个片段对结果的贡献
在这个题目之中片段就是每个元素之间的距离,我们需要计算的就是这段距离在结果中出现了多少次
为了方便理解将每次计算距离视为两点之间的连线,看片段上线的数目就知道这个片段的使用次数
从$a[0]-a[1]$这一的角度来看:从$a[0]$连出去了$n-1$条线,每条线都经过了$a[1]$,所以得出$a[0]-a[1]$段的贡献是$n-1$
从$a[1]-a[2]$的角度来看,$a[1]$连出去的$n-2$也就是$(n-i-1)$条线覆盖了$a[1]-a[2]$

但还不够,注意到$a[0]$发出去的线只有一条落在了$a[1]$上,剩下的线也覆盖了$a[2]$


希望确切地知道此时到底有多少条线覆盖了这段距离

证明

设$f[i]$表示$a[i]$到$a[i+1]$这段距离对结果的贡献次数
同时可知$f[i]$也表示此时距离上面的线段数量
从a[i]发出的所有向右的线都会做贡献,这个次数为$n-i$
发现$a[i]$之前的线段,也就是参与了$f[i-1]$计算的线段,有一部分落在了$a[i]$上,剩下的部分继续参与$f[i]$的计算
可知落在$a[i]$上的线段实际上是a[i]发出的指向左边的线段,其数量为$i$
综上
$f[0]=n-i\f[i]=(f[i-1]-i+n)-i=f[i-1]-2*i+n$
$$\displaystyle res=\sum_{i=0}^{n-2}f[i]*(a[i+1]-a[i])$$

Code
可以看出只与前一个状态有关,进行空间优化
代码为了方便对于$f[i]$计算的是$a[i+1]$到$a[i]$
class Solution:
  def sumDistance(self, nums: List[int], s: str, d: int) -> int:
      mod=1000000007
      n=len(nums)
      for i,a in enumerate(s):
          nums[i]+=d if s[i]=='R' else -d  
      nums.sort()
      pre=0
      res=0
      for i in range(n-1):
          pre=(pre+n-2*i-1)%mod
          res=(res+(nums[i+1]-nums[i])*pre)%mod
      return res
前缀和的形式化证明
下面是灵神的证明方式,与上面的证明相比更加数学,如下
$ (a[i]−a[0])+(a[i]−a[1])+⋯+(a[i]−a[i−1])=i⋅a[i]−(a[0]+a[1]+⋯+a[i−1])\$ $(a[0]+a[1]+⋯+a[i−1])$可根据前缀和求
下面是灵神的代码


题解-英雄的力量
Tue, 01 Aug 2023 06:31:49 +0800

Problem: 2681. 英雄的力量

题目描述
给你一个下标从0开始的整数数组nums，它表示英雄的能力值。如果我们选出一部分英雄，这组英雄的力量定义为：

i₀ ，i₁ ，… i_k 表示这组英雄在数组中的下标。那么这组英雄的力量为 max(nums[i₀],nums[i₁] ... nums[i_k])² * min(nums[i₀],nums[i₁] ... nums[i_k]) 。

请你返回所有可能的非空英雄组的力量之和。由于答案可能非常大，请你将结果对10⁹+ 7取余。
思路

选取与顺序无关先排序
接下来只要枚举所有子序列的最大值的平方和最小值的乘积之和
注意到只和最大值和最小值有关

解题方法

确定了子序列的最大值之后,我们只需要确定子序列里面各个值最小值出现了几次
也就是确定排序后的$nums[i]$必选且为最大值时,我们假设此时在答案中与除自身之外他的平方相乘的所有值之和为$pre_i$,此时有答案$res_i=nums[i]^2*(pre_i+nums[i])$
不去管$pre_i$现在为多少,我们假设现在要选取的是$nums[i+1]$为最大值,则注意到对于子序列

如果不选$ nums[i] $,$ pre_i$也会和$nums[i+1]$相乘
如果选取$nums[i]$,对于所有$nums[i]$不是最小值的情况,$pre_i$也会和$nums[i+1]$相乘,而$nums[i]$是最小值的情况只有一个(也就是选取$i$和$i+1$两个)


根据以上的两个推理,我们能够得出 $$ \displaystyle res_{i+1}=nums[i+1]^2 \cdot (pre_i \cdot 2+nums[i]+nums[i+1]) \\ pre_{i+1}=pre_i\cdot 2+nums[i] $$
$res=\displaystyle\sum^{n}_{i=0} res_i $


时间复杂度$O(nlogn)$
空间复杂度$O(1)$

Code



class Solution:
    def sumOfPower(self, nums: List[int]) -> int:
        mod=1000000007
        nums.sort()
        pre=0
        res=0
        for num in nums:
            res=(res+(pre+num)*(num**2)
            pre=(pre*2+num
        return res



class Solution {
public:
    int sumOfPower(vector<int>& nums) {
        const int mod=1e9+7;
        sort(nums.begin(),nums.end());
        int res=0,pre=0;
        for (long num:nums){
            res=(res+(num*nu
            pre=(pre*2+num
        }
        return res;
    }
};



题解-在二叉树中分配硬币-深度优先搜索,自底向上考虑
Fri, 14 Jul 2023 23:46:22 +0800

Problem: 979. 在二叉树中分配硬币


思路

考虑最后计算成本的时候实际上是计算的是每个节点对硬币的操作数
每个节点只需要一个硬币,如何确定多出来的或少的硬币的流向
考虑自底向上,叶子节点只需要一个硬币,这样就能向父节点要硬币或者向父节点送硬币,之后父节点变成了叶子节点(其子节点已完成使命)
设一个值为$Need$表示需要向上移或者向上要的硬币数,根据以上推论我们能够得到如下公式,正数表示需要向上移动,负数表示需要上方向下移动
$$Need_{节点}=Need_{子节点}+val-1$$
每次将一个节点处理完就将Need的绝对值加入到操作数之中

Code
class Solution:
    def distributeCoins(self, root: Optional[TreeNode]) -> int:
        self.res=0
        def dfs(node:TreeNode):
            if node==None:
                return 0
            left=dfs(node.left)
            right=dfs(node.right)
            self.res+=abs(left)+abs(right)
            return right+left+node.val-1
        dfs(root)
        return self.res
class Solution {
public:
    int res=0;
    int dfs(TreeNode* root){
        if (!root) return 0;
        int left=dfs(root->left);
        int right=dfs(root->right);
        res+=abs(left)+abs(right);
        return left+right+root->val-1;
    }
    int distributeCoins(TreeNode* root) {
        dfs(root);
        return res;
    }
};