Knight Tournament CodeForces - 357C

Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event.

As for you, you’re just a simple peasant. There’s no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows:

There are n knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to n.
The tournament consisted of m fights, in the i-th fight the knights that were still in the game with numbers at least li and at most ri have fought for the right to continue taking part in the tournament.
After the i-th fight among all participants of the fight only one knight won — the knight number xi, he continued participating in the tournament. Other knights left the tournament.
The winner of the last (the m-th) fight (the knight number xm) became the winner of the tournament.
You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number b was conquered by the knight number a, if there was a fight with both of these knights present and the winner was the knight number a.

Write the code that calculates for each knight, the name of the knight that beat him.

Input
The first line contains two integers n, m (2 ≤ n ≤ 3·105; 1 ≤ m ≤ 3·105) — the number of knights and the number of fights. Each of the following m lines contains three integers li, ri, xi (1 ≤ li < ri ≤ n; li ≤ xi ≤ ri) — the description of the i-th fight.

It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle.

Output
Print n integers. If the i-th knight lost, then the i-th number should equal the number of the knight that beat the knight number i. If the i-th knight is the winner, then the i-th number must equal 0.

Examples
Input
4 3
1 2 1
1 3 3
1 4 4
Output
3 1 4 0
Input
8 4
3 5 4
3 7 6
2 8 8
1 8 1
Output
0 8 4 6 4 8 6 1
Note
Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won.

题意：有n个人，有m场比赛，每场比赛在第L个人到第R个人中进行，每场比赛有一个获胜者X，该场比赛中所有人都是X击败的，问每个人都被是谁击败的。

思路：我们知道，并查集是一个树形结构，可以把元素分为不同的集合，每个集合都有一个代表元素。我们可以把每个查询区间用一个并查集合并起来，然后集合的代表元素设置为该场比赛胜利的人，并用一个ans数组记录答案，合并完所有集合后ans数组的值就是答案。

有一个关键：用并查集合并区间的时候，如果暴力合并，一定会超时，我们考虑到，当一段区间查询完之后，就不必查询了，只需要把这个区间的代表元素加入到下一个查询区间的合并中。

for(int i=l;i<=r;i=tmp)
		{
			union1(i,x);
			tmp=next[i];
			next[i]=next[r];
		}

我们可以通过next数组实现，next[i]数组的含义是查询完第i个元素之后下一个应该查询的元素，初始化next[i]=i+1，表示第i个元素的下一个查询元素为第i+1个元素，每次查询完第i个元素之后，我们就把next[i]的值设置为next[r]的值。当我们再一次查询区间扫描到该元素时，我们接下来的部分元素就不用扫描了，下一次直接从r+1开始，节省了很多时间。这个思想很重要

#include<cstdio>
using namespace std;
int pre[300009],ans[300009],next[300009];
int find(int x)
{
	if(x!=pre[x])
		pre[x]=find(pre[x]);
	return pre[x];
}
void union1(int x,int y)
{
	int fx=find(x),fy=find(y);
	ans[fx]=y;
	if(fx!=fy)
		pre[fx]=fy;
}
int main()
{
	int n,m,l,r,x,tmp;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		pre[i]=i;
		ans[i]=0;
		next[i]=i+1;
	}
	while(m--)
	{
		scanf("%d%d%d",&l,&r,&x);
		for(int i=l;i<=r;i=tmp)
		{
			union1(i,x);
			tmp=next[i];
			next[i]=next[r];
		}
	}
	for(int i=1;i<=n-1;i++)
	if(ans[i]!=i)
		printf("%d ",ans[i]);
	else
		printf("0 ");
	if(ans[n]!=n)
		printf("%d\n",ans[n]);
	else
		printf("0\n");
}