HDU 3038 - How Many Answers Are Wrong - [经典带权并查集]

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3038

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

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

题意：

现给出n个数字组成的序列，编号为1~n；

给出m个查询，每个查询的答案由a,b,s三个数组成，表示从第a个数加到第b个数的和为s；

但是其中有一些是有矛盾的（或者说错误的），求错误的查询答案有多少个。

题解：

经典的带权并查集问题；

我们设sum[x]是这n个数的前缀和数组，那么就可以把所有的 a+…+b = s 都变成 sum[b] - sum[a-1] = s；

那么我们就可以利用带权并查集进行进行建树，照例par[x]代表了节点x的父亲节点，而val[x]代表了sum[x] - sum[par[x]]；

首先是find()函数，我们在原来最基础的并查集find函数中，是有一种类似于把x的父亲节点par[x]变成par[par[x]]这样的，将节点沿着树枝往上移动的操作，

那么相应的，我们每次做将par[x]变成par[par[x]]这样的操作时，val[x]也要修改为val[x]+val[par[x]]；

其次，我们对于每次查询的结果a,b,s，令 t1 = find(a)，t2 = find(b)，那么对应的s,val[a],val[b],val[t2]就可以如下图的向量所示：

　　　　　　　　　　

向量的方向相当重要（因为这个WA了两发= =）：对于任何的从x指向y的向量都代表了sum[x] - sum[y]；

那么很显然的有：

①若a,b还不是一个集合内，那么就要unite他们，即令par[t2]=t1；

　那么同时，根据向量的加减法，val[t2]也要跟随着par[t2]的变动，转变成sum[t2] - sum[t1]；所以根据向量加减的规则就有val[t2] = - val[b] + s + val[a]；

②若a,b已经是一个集合内的，那么就要判断是否有矛盾；

　显然此时t1=t2，那么如果s是正确的话，就应该有 - val[b] + s = val[a]，否则，s就是一个与前面产生矛盾的、有错误的查询结果；

AC代码：

#include<bits/stdc++.h>
const int maxn=+;

int n,m;

int par[maxn],val[maxn];
void init(int l,int r){for(int i=l;i<=r;i++) par[i]=i,val[i]=;}
int find(int x)
{
    if(par[x]==x) return x;
    else
    {
        int root=find(par[x]);
        val[x]+=val[par[x]];
        return par[x]=root;
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init(,n);
        int ans=;
        for(int i=,a,b,s;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&s); a--;

            int t1=find(a),t2=find(b);
            if(t1!=t2)
            {
                par[t2]=t1;
                val[t2]=-val[b]+s+val[a];
            }
            else
            {
                if(val[a]+s!=val[b]) ans++;
            }
        }
        printf("%d\n",ans);
    }
}