Python on 一共十七划

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

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

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

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>



题解-每棵子树内缺失的最小基因值
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题类似的将数组本身化为哈希表的操作,不然代码的复杂性很高,而且也不好理解


题解-最长相邻不相等子序列 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, 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;
    }
};