【Leetcode】周赛203 查找大小为M的最新分组

最新推荐文章于 2020-10-06 09:50:22 发布

EagleEyeKestrel

最新推荐文章于 2020-10-06 09:50:22 发布

阅读量138

点赞数

分类专栏： Leetcode 并查集

本文链接：https://blog.csdn.net/u014156276/article/details/108191002

版权

Leetcode 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

并查集

3 篇文章 0 订阅

订阅专栏

查找大小为M的最新分组

这是第203场周赛的第三题，也可以说是一道比较有区分度的题。快的人很快就做完了，慢的人迟迟没有思路。我自己也是卡在了这道题上，没有想到什么快捷的方法，到四十几分钟才写出来，然后调bug花了十几分钟，直接心态给搞炸了。题目是这样的：

给你一个数组 arr ，该数组表示一个从 1 到 n 的数字排列。有一个长度为 n 的二进制字符串，该字符串上的所有位最初都设置为 0 。

在从 1 到 n 的每个步骤 i 中（假设二进制字符串和 arr 都是从 1 开始索引的情况下），二进制字符串上位于位置 arr[i] 的位将会设为 1 。

给你一个整数 m ，请你找出二进制字符串上存在长度为 m 的一组 1 的最后步骤。一组 1 是一个连续的、由 1 组成的子串，且左右两边不再有可以延伸的 1 。

返回存在长度恰好为 m 的一组 1 的最后步骤。如果不存在这样的步骤，请返回 -1 。

示例1:

输入：arr = [3,5,1,2,4], m = 1
输出：4
解释：
步骤 1："00100"，由 1 构成的组：["1"]
步骤 2："00101"，由 1 构成的组：["1", "1"]
步骤 3："10101"，由 1 构成的组：["1", "1", "1"]
步骤 4："11101"，由 1 构成的组：["111", "1"]
步骤 5："11111"，由 1 构成的组：["11111"]
存在长度为 1 的一组 1 的最后步骤是步骤 4 。

示例2:

输入：arr = [3,1,5,4,2], m = 2
输出：-1
解释：
步骤 1："00100"，由 1 构成的组：["1"]
步骤 2："10100"，由 1 构成的组：["1", "1"]
步骤 3："10101"，由 1 构成的组：["1", "1", "1"]
步骤 4："10111"，由 1 构成的组：["1", "111"]
步骤 5："11111"，由 1 构成的组：["11111"]
不管是哪一步骤都无法形成长度为 2 的一组 1 。

示例3:

输入：arr = [1], m = 1
输出：1

示例4:

输入：arr = [2,1], m = 2
输出：2

提示：

n == arr.length
1 <= n <= 10^5
1 <= arr[i] <= n
arr 中的所有整数互不相同
1 <= m <= arr.length

题目的意思看一下大概就知道了，给一个排列，对一串全零的字符串每次把一个位置变成1，问仍然存在着连续m个1的最后一个时刻(步骤)。显然按着题面意思模拟，每次更新一个然后数连续的1是 $O(n^2)$ 的，肯定超时，所以要想想怎么优化。

抛砖引玉，先说说我想到的笨办法。我们知道要存在对于某个连续m个1，他存在的条件应该是，假设这个连续m个1是处于 $i,i+1,\cdots,i+m-1$ 这m个位置，那么i-1以及i+m两个位置的1出现时刻(在arr里的索引)要大于 $i,i+1,\cdots,i+m-1$ 这m个位置的数的索引的最大值。然后出现的最后时刻才是 $m i n (a r r . f i n d (i - 1), a r r . f i n d (i + m))$ 。

由于这里的数都是互不相等的，所以先预处理一下每个数在arr里的索引。然后预处理大小为n的串中，n-m+1个(连续m个数字在arr里对应索引的最大值(修改的最晚的时刻))。这样我们就知道了所有长度为m的串，里面最晚的1是什么时候修改的了。这其实就是一个滑动窗口最大值的问题了，当时一反应过来这个就觉得肯定是对了。代码如下，有几个注意点：

必须得用unordered_map，我用了map超时。。一度以为算法不行，但换成哈希就过了，说明logn和常数还是有差距
前半部分是滑动窗口最大值的模版，双向队列里存储的是最大值的序号。
后半部分分情况讨论了一下，先判断该长度为m的串是否成立，特殊讨论了一下边界情况。然后更新res。

class Solution {
public:
    int findLatestStep(vector<int>& arr, int m) {
        int n=arr.size();
        unordered_map<int,int> mp;
        for(int i=0;i<n;i++) mp[arr[i]]=i+1;
        deque<int> q;
        vector<int> maxv;
        for(int i=1;i<=n;i++){
            if(!q.empty()&&q.front()==i-m) q.pop_front();
            while(!q.empty()&&mp[i]>mp[q.back()]) q.pop_back();
            q.push_back(i);
            if(i>=m) maxv.push_back(mp[q.front()]);
        }
        
        int res=-1;
        for(int i=1;i<=n-m+1;i++){
            int val=maxv[i-1];
            if((i==1||mp[i-1]>val)&&(i==n-m+1||mp[i+m]>val)){
                if(i==1&&i==n-m+1){
                    res=n;
                    break;
                }
                if(i==1) res=max(res,mp[i+m]-1);
                else if(i==n-m+1) res=max(res,mp[i-1]-1);
                else{
                    res=max(res,min(mp[i+m],mp[i-1])-1);
                }
            }
        }
        return res;
    }
};

这个做法其实个人认为还行，但是直观上不是很容易想？可能还是我太菜了。后来看别人做的代码，发现用并查集是真的容易想呀。

fa是父数组，cnt表示该段的长度，sum统计某个长度的个数
merge的时候把长度累加上去，更新cnt和sum即可

class Solution {
public:
    int fa[100010];
    int cnt[100010];
    int sum[100010];
    int findp(int x){
        if(fa[x]!=x){
            fa[x]=findp(fa[x]);
        }
        return fa[x];
    }
    void merge(int l,int r,int newp){
        if(cnt[l]) fa[l]=newp;
        if(cnt[r]) fa[r]=newp;
        cnt[newp]=1+cnt[l]+cnt[r];
        sum[1+cnt[l]+cnt[r]]++;
    }
    int findLatestStep(vector<int>& arr, int m) {
        int n=arr.size();
        for(int i=0;i<n+2;i++) fa[i]=i;
        memset(cnt,0,sizeof(cnt));
        memset(sum,0,sizeof(sum));
        int res=-1;
        for(int i=0;i<n;i++){
            int l=findp(arr[i]-1),r=findp(arr[i]+1);
            sum[cnt[l]]--;
            sum[cnt[r]]--;
            merge(l,r,arr[i]);
            if(sum[m]>0) res=i+1;
        }
        return res;
    }
};