6273. 2019.8.4【NOIP提高组A】欠钱 (money)

6273. 2019.8.4【NOIP提高组A】欠钱 (money) 
(File IO): input:money.in output:money.out

Time Limits: 1000 ms  Memory Limits: 524288 KB  Detailed Limits  

Description

 

 

Input

第一行两个整数 n 和 m，表示有 n 只企鹅，m 个操作。
接下来 m 行，有两种可能的格式：
- 0 a b c：修改操作，企鹅 a 向企鹅 b 借了 c 元钱。
- 1 a b：查询操作，询问假如 a 有了 +∞ 元钱，企鹅 b 会净收入多少钱。
本题强制在线，也就是说：对于每个操作输入的变量 a, b, c（如果没有c，那就只有 a, b）
都不是实际的 a, b, c，想获得实际的 a, b, c 应当经过以下操作：

a = (a + lastans) % n + 1;
b = (b + lastans) % n + 1;
c = (c + lastans) % n + 1;

其中，lastans 是上一次询问的答案。如果没有上一次询问，lastans 为0。

Output

对每个询问操作，输出一行一个数表示答案。

Sample Input

5 9
0 1 2 1
0 0 1 2
1 0 1
1 2 4
0 2 1 1
1 2 0
0 3 1 0
1 4 2
1 3 4

Sample Output

3
2
0
1
0

Data Constraint

 

 

 

 

题目大意：

你有棵树 ， 一开始只有n个节点。现在要求在树中加有向边。这期间有若干询问，问x节点到y路径上的最小边权 。

 

题解：

倍增剪枝 + 带权并查集

1.对于题目给定的边 ， 我们并查集将两点连接 ， 更新f、g[][0],f,g分别记的是节点和最小值。

            printf("%d %d %d\n",a,b,c);
			f[a][0] = b;
			g[a][0] = c;
			father[a] = b;
			dep[a]=1;
			mx[a] = 1 ; //下次从1开始即可 

2.对于询问 ， 类似于跳lca 。 只是两点必须在一条链上 （若不在 ， 路径上至少有一条边方向反了，不合题意）。

带权并查集更新深度 ：

int getfather(int x)
{
	if(father[x]==x) return x;
	int fa = getfather(father[x]);
	dep[x] += dep[father[x]];
	father[x] = fa;
	return fa;
}

如果是已经更新过dep了，father也被压缩了 ， dep+=0 ,相当于没加。

红色节点的深度在不变根节点的情况下已经求好，father也压缩好了 ， 然后dep+=dep[father] -> dep+=0

 

如果是没更新过的(绿色） ， 会加上更新过的 dep ， 也就是自己没压缩的father的dep ， 由于一开始dep[a] = 1（见上），加上之后即可。

如图：

没更新过的(绿色）

查5的深度，5递归到3

3到1

1到根,dep[1]+=0,father[1] = 0 ,回去

dep[3]+=dep[1]->dep[3]+=1 - >dep[3] = 2 ， father[3]=1 ，回去

dep[5]+=dep[3]->dep[5]+=2->dep[5] = 3 ,father[5]=1 ，找完了！

 

只需并查集求出两点深度 ， 然后倍增（若你要使用f[i][j]，但是f[i][j]没更新  ，那么暴力递归更新f[i][j]）， 注意判断不合题意的情况。

void updata(int x,int i)
{
//	calc f[x][i] = f[f[x][i-1]][i-1] = f[f[f[x][i-2]][i-2]][i-1] ... dfs.
	if(i-1 >= mx[x]) updata(x,i-1); 
	if(i-1 >= mx[f[x][i-1]]) updata(f[x][i-1],i-1);
	f[x][i] = f[f[x][i-1]][i-1] ; g[x][i] = min(g[x][i-1] , g[f[x][i-1]][i-1]);
	mx[x] = i+1;
}

这里mx[i]记录f[i]最多更新到f[i][mx[i]-1]了。

 

 

代码：

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define mcy(a,b) memcpy(a,b,sizeof(a))
#define ll long long
#define re register
#pragma GCC optimize(3)
#define inf 2000000000
#define N 200010
#define open(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout)
using namespace std;

int n,m,i,j,t,a,b,c,lastans,ans;
int f[N][30] , dep[N] , g[N][30] , mx[N] , father[N] ,bz[N];
//const int la[5] = {3,2,0,1,0};

int getfather(int x)
{
	if(father[x]==x) return x;
	int fa = getfather(father[x]);
	dep[x] += dep[father[x]];
	father[x] = fa;
	return fa;
}


void updata(int x,int i)
{
//	calc f[x][i] = f[f[x][i-1]][i-1] = f[f[f[x][i-2]][i-2]][i-1] ... dfs.
	if(i-1 >= mx[x]) updata(x,i-1); 
	if(i-1 >= mx[f[x][i-1]]) updata(f[x][i-1],i-1);
	f[x][i] = f[f[x][i-1]][i-1] ; g[x][i] = min(g[x][i-1] , g[f[x][i-1]][i-1]);
	mx[x] = i+1;
}

inline void M (int &ans , int x)
{ans = min(ans,x);}


void findans(int x,int y)
{
	//lca
	int fx = getfather(x) ,fy = getfather(y);
	if(fx!=fy) {ans=0;return ;}
	int maxn = (int)log2(max(dep[x] , dep[y]));
	
	if(dep[x] < dep[y]){ans=0;return;}
	int h = dep[x] - dep[y];
	for(int i=maxn;i>=0;i--) if((1<<i) & h) 
	{
//		if(dep[x]<=dep[y]) 
//		{
//			ans=0;
//			return ;
//		}
		if(i >= mx[x]) 
			updata(x,i);
		 M(ans,g[x][i]),x = f[x][i];
		 
	}
	if(x!=y) 
	{
		ans=0;
		return ;
	}
	return ;
/*	for(int i=maxn;i>=0;i--) 
	{
		if(i >= mx[x]) updata(x,i);
		if(i >= mx[y]) updata(y,i);
		if(f[x][i] != f[y][i])
		{
			M(ans,gSs[x][i]) , x = f[x][i];
			M(ans,g[y][i]) , y = f[y][i];
		}
	}
	
	M(ans,g[x][0]) ;
	M(ans,g[y][0]) ; 
	return ;*/
		
}

int main()
{
	open("money");
	scanf("%d%d",&n,&m);
//	int cnt=0;
	for(i=1;i<=n;i++) father[i] = i;
	for(i=1;i<=m;i++)
	{
//		if(i==9)
//		{
//			i=9;
//			break;
//		}
		int opt=0;
		scanf("%d",&opt);
		if(opt) 
		{
			scanf("%d%d",&a,&b);
//			lastans = cnt==-1  ? 0 : la[cnt];
			a = (a + lastans) % n + 1;
			b = (b + lastans) % n + 1;
//			printf("%d %d\n",a,b);
//			
//			++cnt;
//			
//			if(cnt==4)
//			{
//				cnt=4;
//			}
			
			ans=inf;
			findans(a,b);
			printf("%d\n",cnt);
			printf("%d\n",ans);
			lastans = ans ;
		}
		else
		{
			scanf("%d%d%d",&a,&b,&c);
//			lastans = cnt==-1  ? 0 : la[cnt];
			a = (a + lastans) % n + 1;
			b = (b + lastans) % n + 1;
			c = (c + lastans) % n + 1; 
//			printf("%d %d %d\n",a,b,c);
			f[a][0] = b;
			g[a][0] = c;
			father[a] = b;
			dep[a]=1;
			mx[a] = 1 ; //下次从1开始即可 
			
		}
	}
	return 0;
}

O(m log n + n log n) 

前面一项容易理解 ， 后面一项的意思，就是更新f数组的总复杂度。

因为我们记录了mx的原因每个点最多更新log次 ， n个点n logn