[BZOJ]4569 [SCOI2016] 萌萌哒 并查集神题

4569: [Scoi2016]萌萌哒

Time Limit: 10 Sec   Memory Limit: 256 MB
Submit: 1101   Solved: 523
[ Submit][ Status][ Discuss]

Description

一个长度为n的大数，用S1S2S3...Sn表示，其中Si表示数的第i位,S1是数的最高位，告诉你一些限制条件，每个条

件表示为四个数，l1，r1，l2，r2，即两个长度相同的区间，表示子串Sl1Sl1+1Sl1+2...Sr1与Sl2Sl2+1Sl2+2...S

r2完全相同。比如n=6时，某限制条件l1=1，r1=3，l2=4，r2=6，那么123123，351351均满足条件，但是12012，13

1141不满足条件，前者数的长度不为6，后者第二位与第五位不同。问满足以上所有条件的数有多少个。

Input

第一行两个数n和m，分别表示大数的长度，以及限制条件的个数。接下来m行，对于第i行,有4个数li1，ri1，li2

，ri2，分别表示该限制条件对应的两个区间。

1≤n≤10^5，1≤m≤10^5，1≤li1,ri1,li2,ri2≤n；并且保证ri1-li1=ri2-li2。

Output

 一个数，表示满足所有条件且长度为n的大数的个数，答案可能很大，因此输出答案模10^9+7的结果即可。

Sample Input

4 2
1 2 3 4
3 3 3 3

Sample Output

90

HINT

Source

[ Submit][ Status][ Discuss] 

HOME Back

 这道题的想法很妙， 暴力做法就是一个一个对应的加入并查集里面. 又一个并查集神题...感觉并查集的使用是无穷尽的.

优化就是考虑将两个区间相同的分成log块， 然后两个区间的块分别对应着加入并查集. 也就是说把id[i][j]表示从i开始2^j的一块看成一个点， 然后id[l1][j]和id[l2][j]加入一个并查集. 然后最后统一处理， 处理每一个块， 把块从大到小的划分下去. 什么意思呢?就是指j先从17开始for， 也就是说for块的大小， 从大开始for,  然后枚举每一个i开始那么大的块， 然后找到id[i][j]的fa -- s， 将当前j这个块划分开， id[i][j - 1] 与 id[s][j - 1]合并， 剩下的半块各自又合并. 最后答案就是id[i][0](即当前这个点)fa为自己的有多少个(即多少个集合).， 以10次幂相乘即可， 因为每个就是10种可能性.  这样一共外层for log次， 内层for n次， 时间复杂度nlogn.

接下来我们对这种做法的正确性进行分析. 他是怎么样优化的呢 ? 感觉不知不觉中就优化了复杂度， 有种说不清道不明的感觉. 我们先想想原来1， 1匹配去合并并查集的做法， 这样不优的原因是， 一个点被重复合并多次， 状态太多了. 而这种方法有点离线的味道， 我全部分好块了再一并处理. 状态压缩就是个问题， 比如说id[i][0]， 即i本身， 他可能在多个限制条件的区间里出现， 它所出现的状态很多 ... 但是i这个点被包含在id[i][0]里， id[i][1]里...id[s][?]里 ... (从s走2^j可以走过i)而这些状态又都包含了其他状态， 比如说刚刚举例的id[i][1]， 他又包含了id[i+1][0]这个状态. 所以我们把状态打包， 如果id[i][6] 和id[s][6]是一个并查集里的, 那么id[i][0]与id[s][0]的配对就一定会在id[i][6]不断划分中最终for到j等于0的时候终于处理到. 所以说总体思路就是状态打包， 一起处理. 刚刚举例的id[i][6]包含了很多状态， 但是我们把他们一起打包处理 -- id[i][6]划分下去处理了id[i][0], id[i + 1][0], di[i + 2][0]..... 这就是打包处理， 每个id[i][j]一共log次划分却处理了很多东西.还有一种理解方式是跟记忆化搜索数位dp或者状压dp一样,， 状态有多少复杂度就是多少. 譬如数位dp里用dp[i][mod]表示最高位第i位数% 13 余 mod的数有多少个. 这些数很多， 各自不一样， 但是我们把他们压缩成 一个dp[i][mod]， 打包处理(虽然记忆化搜索是打包记录答案， 而不是打包处理问题...但有异曲同工之妙).

注意第1位只能有9种选择(无前导0).

#include<stdio.h>
const int P = 18;
const int maxn = 100005;
const int mod  = 1e9 + 7;
typedef long long dnt;
dnt ans;
int fa[maxn * P], id[maxn][P], pw[P], mp[maxn * P], n, m, tot, l1, l2, r1, r2, cnt;
inline const int read(){  
    register int x = 0;  
    register char ch = getchar();  
    while(ch < '0' || ch > '9') ch = getchar();  
    while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();  
    return x;  
}
int find(int x) { return (fa[x] == x) ? x : fa[x] = find(fa[x]);}
int main(){
	n = read(), m = read();
	pw[0] = 1;
	for(int i = 1; i <= 17; ++i) pw[i] = pw[i - 1] * 2;
	for(register int i = 1; i <= n; ++i)
		for(int j = 0; j <= 17 && i + pw[j] - 1 <= n; ++j) id[i][j] = ++tot, mp[tot] = i;
	for(register int i = 1; i <= tot; ++i) fa[i] = i;
	for(register int i = 1; i <= m; ++i){
		l1 = read(), r1 = read(), l2 = read(), r2 = read();
		for(int j = 17; ~j; --j)
			if(l1 + pw[j] - 1 <= r1)
				fa[find(id[l1][j])] = find(id[l2][j]), l1 += pw[j],  l2 += pw[j];
	}
	for(register int j = 17; j; --j)
		for(register int i = 1; i + pw[j] - 1 <= n; ++i){
			int k = find(id[i][j]), s = mp[k];
			if(k == s) continue;
			fa[find(id[i][j - 1])] = find(id[s][j - 1]);
			fa[find(id[i + pw[j - 1]][j - 1])] = find(id[s + pw[j - 1]][j - 1]);
		}
	for(register int i = 1; i <= n; ++i)
		if(fa[id[i][0]] == id[i][0]) cnt++;
	ans = 9;
	for(register int i = 1; i < cnt; ++i) ans = ans * 10 % mod;
	printf("%lld", ans);
}