C++ on 一共十七划

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

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

题解-哈希表,用输入流实现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]$为最大值,则注意到对于子序列
1. 如果不选$ nums[i] $,$ pre_i$也会和$nums[i+1]$相乘
2. 如果选取$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;
    }
};

题解-困于环中的机器人-模拟与相关证明

Tue, 11 Apr 2023 21:51:11 +0800

思路

对于机器人,如果走结束后方向仍在北方,且不在原点才会脱离圈,不然就会困在圈里
因此只需要模拟即可

证明

假设我们第一次位移结束之后之后机器人所在的坐标为(x,y)
我们按照此时机器人面向的方向讨论
- 此时面向北方的:下一次前进路线和上次一致,第二次前进之后是(2x,2y),以此类推因此只要x,y不全为0则不会回到原点
- 此时面向南方: 考虑转换参考系,以面朝的方向为y正半轴,此时两个参考系实际上是180度旋转的,在新参考系下前进了(x,y),并转换了方向,在之前的参考系下,下一次的前进方向与这一次相反,也就是说下一次会移动(-x,-y)的位移,并且下次移动之后会转向北方:与没有动之前一致,进入循环
- 面向东方:同理,不过是每次都是翻转了90度的方向则位移路径为 (0,0)->(x,y)->(x+y,y-x)->(x+y-x,y-x-y)->(x+y-x-y,y-x-y+x),又到0,且方向回到了北方
- 面向西方同理
也相当于一个向量乘同一个旋转矩阵和位移矩阵多次但是方向需要另外特判一下

实现思路

用一组数字记录当前坐标
方向只有四种,且每个方向前进的方式不同,所以我们可以用数组存储每一种前进方式,根据方向增加
用一个单独的数字记录当前面向的方向
按照操作,模拟前进方式
判断

代码

class Solution {
public:
    bool isRobotBounded(string instructions) {
        vector<vector<int>> direction{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int x=0,y=0,now_direction=0;
        for (char choice:instructions){
            switch(choice){
                case 'G':
                    x+=direction[now_direction][0];
                    y+=direction[now_direction][1];
                    break;
                case 'L':
                    now_direction-=1;
                    if (now_direction<0)
                        now_direction+=4;
                    break;
                case 'R':
                    now_direction+=1;
                    now_direction%=4;
                    break;
                default:
                    break;
            }
        } 
        return !((x!=0||y!=0)&&now_direction==0);
    }
};

题解-移位字符串分组-哈希表

Tue, 14 Mar 2023 17:11:00 +0800

Problem: 249. 移位字符串分组

思路

类似于凯撒密码的归类方式,我们将所有能通过轮转得到的字符串放在一起,不难想到可以通过暴力来对每一个字符串匹配
对于字符串仔细观察可以发现每一个可以归类到一起的字符串的本质是相同的,不只是字符串长度,还有与左右字母之间的差值
综上,对于每一类字符串我们只需要将其转化为模板的样子就能判断是否能归类
我们的问题就是如何将字符转成一个标准的模板
考虑字符之间的相对关系,
- 我们设首位为0,后面的每一位对应的是字符串该位与前一位的差
- 如果小于0则加26,来保证模式字符串相等

解题方法

对于每一个字符串,计算其相对字符的模板字符串
查询哈希表,如果有则插入到相对的答案组中
没有就新开一个答案组
重复上述操作

复杂度

时间复杂度:

只遍历一次 $O(mn)$,m为字符串长度

空间复杂度:

运用了哈希表 $O(n)$

Code


class Solution {
public:
    vector<vector<string>> groupStrings(vector<string>& strings) {
        vector<vector<string>>res;
        unordered_map<string,int>hash;//模板字符串及其对应的在答案的行数
        for (auto &iter:strings){
            string tmp="0_";
            char a=iter[0];
            int now;
            for (int i=1;i<iter.size();i++){
                now=iter[i]-a;
                if (now<0)//保证模板的一致性
                    now+=26;
                tmp+=to_string(now)+"_";
                a=iter[i];
            }
            if (hash.find(tmp)!=hash.end()){
                res[hash[tmp]].emplace_back(iter);
            }
            else{
                hash[tmp]=res.size();
                res.emplace_back(vector<string>(1,iter));
            }
        }
        return res;
    }
};

题解-全局倒置和部分倒置-找数学规律

Wed, 16 Nov 2022 21:51:11 +0800

思路

根据题意可知全局倒置包含局部倒置，对于本题如果有非局部倒置的全局倒置，则返回false，不然就返回true
很容易相出用暴力去搜索自己2位之后的数组元素中是否有比自己小的，时间复杂度:$O(n^2)$
倒置是根据的是递增数组出现的，也就是说我们得到的数组实际上是对递增数组进行过几次置换的数组
根据定义可以知道局部倒置的实质就是将相邻的数组元素进行的交换，所以要做的就是与原数组进行比较
- 位置不变的跳过
- 位置变化的判断是否和原数组相邻位置的值相等，相等则跳过
- 不满足上述两个条件的就是全局置换，返回false

代码

class Solution {
public:
    bool isIdealPermutation(vector<int>& nums) {
        int n=nums.size()-1;
        int i=0;
        while (i<n){
            if (nums[i]==i)
                i++;
            else if (nums[i]==i+1&&nums[i+1]==i)
                i+=2;
            else
                return false;
        }
        return true;
    }
};