2022-01-30每日刷题打卡

2022-01-30每日刷题打卡

力扣

5993. 将找到的值乘以 2

给你一个整数数组 nums ，另给你一个整数 original ，这是需要在 nums 中搜索的第一个数字。

接下来，你需要按下述步骤操作：

如果在 nums 中找到 original ，将 original 乘以 2 ，得到新 original（即，令 original = 2 * original）。
否则，停止这一过程。
只要能在数组中找到新 original ，就对新 original 继续 重复 这一过程。
返回 original 的 最终 值。

示例 1：

输入：nums = [5,3,6,1,12], original = 3
输出：24
解释：

• 3 能在 nums 中找到。3 * 2 = 6 。
• 6 能在 nums 中找到。6 * 2 = 12 。
• 12 能在 nums 中找到。12 * 2 = 24 。
• 24 不能在 nums 中找到。因此，返回 24 。

先遍历一遍nums，用哈希表存一下每个数字的出现情况。然后开始while循环，如果能在哈希表中找到original，就把original*2，然后再去哈希表里找……循环往复，当哈希表中找不到了，就直接返回original。

class Solution {
public:
    int findFinalValue(vector<int>& nums, int original) {
        unordered_map<int,int>mymap;
        for(auto i:nums)
        {
            mymap[i]++;
        }
        while(mymap[original]!=0)
        {
            original*=2;
        }
        return original;
    }
};

5981. 分组得分最高的所有下标

给你一个下标从 0 开始的二进制数组 nums ，数组长度为 n 。nums 可以按下标 i（ 0 <= i <= n ）拆分成两个数组（可能为空）：numsleft 和 numsright 。

numsleft 包含 nums 中从下标 0 到 i - 1 的所有元素（包括 0 和 i - 1 ），而 numsright 包含 nums 中从下标 i 到 n - 1 的所有元素（包括 i 和 n - 1 ）。
如果 i == 0 ，numsleft 为 空 ，而 numsright 将包含 nums 中的所有元素。
如果 i == n ，numsleft 将包含 nums 中的所有元素，而 numsright 为 空 。
下标 i 的 分组得分 为 numsleft 中 0 的个数和 numsright 中 1 的个数之 和 。

返回 分组得分 最高 的 所有不同下标 。你可以按 任意顺序 返回答案。

示例 1：

输入：nums = [0,0,1,0]
输出：[2,4]
解释：按下标分组

• 0 ：numsleft 为 [] 。numsright 为 [0,0,1,0] 。得分为 0 + 1 = 1 。
• 1 ：numsleft 为 [0] 。numsright 为 [0,1,0] 。得分为 1 + 1 = 2 。
• 2 ：numsleft 为 [0,0] 。numsright 为 [1,0] 。得分为 2 + 1 = 3 。
• 3 ：numsleft 为 [0,0,1] 。numsright 为 [0] 。得分为 2 + 0 = 2 。
• 4 ：numsleft 为 [0,0,1,0] 。numsright 为 [] 。得分为 3 + 0 = 3 。
  下标 2 和 4 都可以得到最高的分组得分 3 。
  注意，答案 [4,2] 也被视为正确答案。

超简单一道题结果比赛的时候脑子没转过来脱了我半小时。

先遍历一趟nums，算出nums中0和1的个数zero_num和one_num。然后再遍历一遍nums，从左往右开始枚举分界线。左边的0个数我们记为l，右边的1个数我们记为r，因为分界线一开始在最左边，所以左边一个数都没有，右边的1个数就是nums全部的1个数。所以l初始化为0，r初始化为one_num。我们准备一个哈希表，以分数为key，分界线的下标为val（因为可能有多个相同的分数，所以以数组形式存贮）。

然后枚举分界线就如下操作：
1、判断分界线上的数是0还是1
如果是0，l++。
如果是1，r–。
2、把分数：l+r 作为哈希表的key，把当前分界线的下标存入哈希表中。
3、维护最大分数。

最后根据得到的最大分数从哈希表中取出对应的分界线下标返回即可。

class Solution {
public:
    vector<int> maxScoreIndices(vector<int>& nums) {
        int n=nums.size();
        int zero_num=0,one_num=0;
        unordered_map<int,vector<int>>mymap;
        int score=0;
        for(auto i:nums)
        {
            if(i==0)zero_num++;
            else one_num++;
        }
        int l=0,r=one_num;
        score=l+r;
        mymap[l+r].push_back(0);
        for(int i=1;i<=n;i++)
        {
            if(nums[i-1]==0)l++;
            else r--;
            score=max(score,l+r);
            mymap[l+r].push_back(i);
        }
        return mymap[score];
    }
};

5994. 查找给定哈希值的子串

给定整数 p 和 m ，一个长度为 k 且下标从 0 开始的字符串 s 的哈希值按照如下函数计算：

hash(s, p, m) = (val(s[0]) * p0 + val(s[1]) * p1 + … + val(s[k-1]) * pk-1) mod m.
其中 val(s[i]) 表示 s[i] 在字母表中的下标，从 val(‘a’) = 1 到 val(‘z’) = 26 。

给你一个字符串 s 和整数 power，modulo，k 和 hashValue 。请你返回 s 中 第一个 长度为 k 的 子串 sub ，满足 hash(sub, power, modulo) == hashValue 。

测试数据保证一定 存在 至少一个这样的子串。

子串 定义为一个字符串中连续非空字符组成的序列。

示例 1：

输入：s = “leetcode”, power = 7, modulo = 20, k = 2, hashValue = 0
输出：“ee”
解释：“ee” 的哈希值为 hash(“ee”, 7, 20) = (5 * 1 + 5 * 7) mod 20 = 40 mod 20 = 0 。
“ee” 是长度为 2 的第一个哈希值为 0 的子串，所以我们返回 “ee” 。

一般来说，看到这种在固定长度的区间内计算的时候，就要想到滑动窗口了。
我们用一个长度为k的滑动窗口，遍历字符串s，当滑动窗口的右端点超过s长度时结束遍历。
这题还有一个问题是，power的计算。首先，如果用循环单独来一步步算power，例如算power的20次方，就要循环20此，100次方就要循环100次，费时又费力；但如果用pow函数来算的话，一开始觉着没问题，但很快就会发现这样会爆数据的。给你一个50的50次方，哪怕是long long也存不下来。
首先我们先解决爆数据的问题：
这里其实关于到小学的乘法分配律知识，我们知道：（2+5）*4=2 *4+5 *4=28。
这个分配律对于取模运算也是可以的： （7+5+6）%5=7%5+5%5+6%5=3。（这里其实有点小问题，详情看最底下）
也就是说
hash(s, p, m) = (val(s[0]) * p0 + val(s[1]) * p1 + … + val(s[k-1]) * pk-1) mod m.
可以化为：
(val(s[0]) * p0 % m+ val(s[1]) * p1 % m+ … + val(s[k-1]) * pk-1 % m)
原来要算的 p 就变成了 p%m ,这样就肯定不会爆数据了。

另外一个问题（怎么算power的次幂）就很好解决了：
我们在滑动窗口中遍历的时候同时算power就可以了，拿一个初始值ans=1，因为计算第一位的时候p=1，然后计算下一位的哈希值的时候，直接把ans乘上power即可。这样的话，虽然也是一步步算power，但我们是跟着滑动窗口的遍历一步步算的，这样就省下了算幂的时间（相当于你就在循环中多加了一个乘法运算而已，不占时间的）。
为了防止爆数据，每一步ans*=power后，都要把ans%=m。

最后再判断一下，计算出的哈希总值%m后是否等于hashValue，如果等于我们就把滑动窗口这一段的字符串返回即可。
（前面在算取模运算的分配律时其实有个小问题，这样得到的结果可能是错误的，比如（3+9）%4就不等于3%4+9%4，前者结果是0后者结果是4。但在这里其实没有问题，因为我们计算出的哈希总值最后是要再进行一次取模运算的，这样就是（3%4+9%4）%4）。

class Solution {
public:
    string subStrHash(string s, int power, int modulo, int k, int hashValue) {
        int n=s.size();
        if(n==k)return s;
        int l=0,r=k;
        while(r<=n)
        {
            long long ans=1,res=0;
            if(k>=n)break;
            for(int j=l;j<r;j++)
            {
                res+=(s[j]-'a'+1)*ans;
                ans*=power;
                ans%=modulo;
            }
            if(res%modulo==hashValue)
            {
                string str;
                for(int j=l;j<r;j++)
                    str+=s[j];
                return str;
            }
            l++,r++;
        }
        return {};
    }
};