HDU3038~How Many Answers Are Wrongc（带权并查集）

How Many Answers Are Wrong

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 7173    Accepted Submission(s): 2651


Problem Description

TT and FF are ... friends. Uh... very very good friends -________-b

FF is a bad boy, he is always wooing TT to play the following game with him. This is a very humdrum game. To begin with, TT should write down a sequence of integers-_-!!(bored).



Then, FF can choose a continuous subsequence from it(for example the subsequence from the third to the fifth integer inclusively). After that, FF will ask TT what the sum of the subsequence he chose is. The next, TT will answer FF's question. Then, FF can redo
this process. In the end, FF must work out the entire sequence of integers.

Boring~~Boring~~a very very boring game!!! TT doesn't want to play with FF at all. To punish FF, she often tells FF the wrong answers on purpose.

The bad boy is not a fool man. FF detects some answers are incompatible. Of course, these contradictions make it difficult to calculate the sequence.

However, TT is a nice and lovely girl. She doesn't have the heart to be hard on FF. To save time, she guarantees that the answers are all right if there is no logical mistakes indeed.

What's more, if FF finds an answer to be wrong, he will ignore it when judging next answers.

But there will be so many questions that poor FF can't make sure whether the current answer is right or wrong in a moment. So he decides to write a program to help him with this matter. The program will receive a series of questions from FF together with the
answers FF has received from TT. The aim of this program is to find how many answers are wrong. Only by ignoring the wrong answers can FF work out the entire sequence of integers. Poor FF has no time to do this job. And now he is asking for your help~(Why
asking trouble for himself~~Bad boy)

 

Input

Line 1: Two integers, N and M (1 <= N <= 200000, 1 <= M <= 40000). Means TT wrote N integers and FF asked her M questions.

Line 2..M+1: Line i+1 contains three integer: Ai, Bi and Si. Means TT answered FF that the sum from Ai to Bi is Si. It's guaranteed that 0 < Ai <= Bi <= N.

You can assume that any sum of subsequence is fit in 32-bit integer.

 

Output

A single line with a integer denotes how many answers are wrong.

 

Sample Input

10 5
1 10 100
7 10 28
1 3 32
4 6 41
6 6 1

 

Sample Output

1

 

Source

2009 Multi-University Training
Contest 13 - Host by HIT

 

Recommend

gaojie   |   We have carefully selected several similar problems for you:  3033 3035 3036 3037 3031 

初写并查集，感觉不看题解是无论如何也不会的，但很多题解都解释的都不太清楚，我汇总了一下，费了好多时间，不过总算搞明白了，此处有个技巧，如果已知[1,4],[5,6],[7,10]三个区间的距离，求[1,10]的距离，此时w[1,3]+w[5,6]

+w[7,10]=w[1,10],但是这几个区间并不衔接，无法直接联系起来，此时只需将左区间-1，即[0,4],[4,6],[6,10],此时区间就衔接起来了；

#include <iostream>
#include <iomanip>
#include<stdio.h>
#include<string.h>
#include<stack>
#include<stdlib.h>
#include<queue>
#include<math.h>
#include<algorithm>
#include<vector>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int maxn=200000+10;
int n,m;
int r[maxn],f[maxn];
int fun(int x,int y)
{
if(x>y)return x-y;
else return y-x;
}
void init()
{
for(int i=0;i<=n;i++)
{
f[i]=i;
r[i]=0;
}
}
int getf(int x)
{
if(f[x]==x)
return f[x];
int t=getf(f[x]);
//注意，此处不直接将h[x]=getf(f[x])，若直接=，则f[x]的值会变为根节点的值，下一步r[x]+=r[f[x]]等价于r[x]+0
//此时r[x]没有任何变化，无法再用中间点(父节点)计算到根节点的距离
//r[x]表示x到p[x]的距离，由于路径已经压缩，r[f[x]]表示f[x]到根节点的距离
r[x]+=r[f[x]];
//此时r[x]表示x到根节点的距离
f[x]=t;
//r[x]计算完毕，将此点的父节点变为根结点
return f[x];
}
int mix(int u,int v,int w)
{
int t1=getf(u);
int t2=getf(v);
if(t1==t2)
{
if(fun(r[u],r[v])==w)
return 0;
else
return 1;
}
else
{
//将u与v连在同一个根节点上
f[t1]=t2;
//计算u的原根节点到改变后的根节点的距离
//最后贴出个例子，加深理解，就不写在代码里面了
r[t1]=r[v]-r[u]+w;
return 0;
}

}
int main()
{

while(~scanf("%d%d",&n,&m))
{
int x,y,z,sum=0;
init();
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&x,&y,&z);
x--;
if(mix(x,y,z))
sum++;
}
printf("%d\n",sum);
}
return 0;
}

有1     2     3      4这4个点，2的根节点是1;3的根节点是4，设w[1,2]=x,w[3,4]=y;

当输入2 3 10，即w[2,3]=10，的时候

由于r[t1]=t2，所以从小到大为正方向

这段代码r[t1]=r[v]-r[u]+w在这个例子中的计算过程为：

r[t1]是2原本的根节点1，到3原本的根节点的4的权值=w[1,4];

r[v]是3到其根节点4的权值y；

r[u]是2到其原本根节点的权值x,由于从小到大为正方向，r[u]=-x;;

所以r[t1]=r[3]-r[2]+w[2,3]=x+y+10;

第一次写这么长注释。。。