LeetCode 1562. 查找大小为 M 的最新分组---并查集+标记状态数目

1562. 查找大小为 M 的最新分组

给你一个数组 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开始），然后初始字符串都为0，每次在位置arr[i]会变成1，一直操作下去，问连续为1的子串长度恰好为m，问这样操作下去最后一次出现连续为1的子串长度恰好为m的哪个步骤，返回。

比如样例1，第4步构成的1的子串为"1"和"111"，存在长度为1的(此时m=1)，而到第5步，只有一个"11111"，没有长度为1的了，所以答案为4。

这个题目利用并查集处理，因为我们时刻在更新，比如
“00110001”
此时位置3和4对应的字符串长度都为2，如果下一步在位置5进行操作，得到：
“00111001”
那么此时位置3和位置4和位置5对应的字符串长度都为3，但是不可能每次跑一遍循环进行更新吧，严重超时了都，于是我们想到并查集，比如一开始是先把位置3进行了更新，然后是位置4，然后是位置5。
那么就是ans[3]=1，f[3]=3；
4来了，发现vis[4-1]==true表示之前被操作过，然后，拉拢一下，找到f[4-1]得到3，于是ans[3]++，f[4]=3；
5来了，发现vis[5-1]==true表示位置4之前被操作过，然后，拉拢一下，找到f[5-1]=f[4]=3，于是ans[3]++，f[5]=3，一直更新下去，于是我们访问某个位置对应的连续子串长度就为ans[f[x]]；

这样实现了我们快速访问某个位置的连续子串长度，现在解决怎么判断某个操作后是否有字串长度恰好为m的子串存在呢？不可能每次遍历访问吧，于是我们再开一个数组sum[maxn]表示每个对应长度对应的子串的数目，于是ans[3]++,就有了sum[ans[3]]++；最后再判断sum[m]>0就行了，就比较简单高效。

AC代码

class Solution {
public:
//f[x]表示位置x的父亲位置，ans[f[x]]表示位置x对应的子串长度 
//sum[len]表示子串长度为len的子串数目  
int f[100100],ans[100100],sum[100100];
bool vis[100100];
int fin(int x)
{
	if(f[x]==x)return x;
	f[x]=fin(f[x]);
	return f[x];
}
int findLatestStep(vector<int>& arr, int m) 
{
	for(int i=1;i<=arr.size();i++)
	f[i]=i,ans[i]=0,vis[i]=0,sum[i]=0;
	int res=-1;
	for(int i=0;i<arr.size();i++)
	{
		int x=arr[i];
		if(vis[x-1]==false&&vis[x+1]==false)
		{
			ans[x]=1;
			sum[ans[x]]++;
		}
		else if(vis[x-1]==false&&vis[x+1]==true)
		{
			int fx=fin(x+1);
			sum[ans[fx]]--;//减去原来的区间长的个数 
			ans[fx]++;
			sum[ans[fx]]++;//累计当前区间长的个数 
			f[x]=fx;
		}
		else if(vis[x-1]==true&&vis[x+1]==false)
		{
			int fx=fin(x-1);
			sum[ans[fx]]--; 
			ans[fx]++;
			sum[ans[fx]]++;
			f[x]=fx;
		}
		else if(vis[x-1]==true&&vis[x+1]==true)
		{
			int fx1=fin(x-1);
			int fx2=fin(x+1);
			sum[ans[fx1]]--;
			sum[ans[fx2]]--;
			ans[fx2]+=ans[fx1];
			ans[fx2]++;
			f[fx1]=fx2;
			f[x]=fx2;
			sum[ans[fx2]]++;
		}
		if(sum[m]>0)res=i+1;
		vis[x]=true;
	}
	return res;
}
};