tree(简单并差集)

tree

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 374    Accepted Submission(s): 186

Problem Description

There is a tree(the tree is a connected graph which contains n points and n−1 edges),the points are labeled from 1 to n ,which edge has a weight from 0 to 1,for every point i∈[1,n] ,you should find the number of the points which are closest to it,the clostest points can contain i itself.

 

Input

the first line contains a number T,means T test cases.

for each test case,the first line is a nubmer n ,means the number of the points,next n-1 lines,each line contains three numbers u,v,w ,which shows an edge and its weight.

T≤50,n≤105,u,v∈[1,n],w∈[0,1]

 

Output

for each test case,you need to print the answer to each point.

in consideration of the large output,imagine ansi is the answer to point i ,you only need to output, ans1 xor ans2 xor ans3.. ansn .

 

Sample Input

  
  

   
   1
3
1 2 0
2 3 1
  
  

 

Sample Output

  
  

   
   1

in the sample.

$ans_1=2$

$ans_2=2$

$ans_3=1$

$2~xor~2~xor~1=1$,so you need to output 1.
  
  

 

Source

BestCoder Round #68 (div.2)

题解：　简单并差集，把所有边权为０的边，关联起来就可以了

ＡＣ代码：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <algorithm>
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <string>
#include <stdlib.h>
#include <memory.h>

#define REP(i,a,b) for(int i=(a);i<(b);++i)
#define RREP(i,b,a) for(int i =(b);i >= (a); --i)
#define CLR(a,x) memset(a,x,sizeof(a))
#define ALL(o) o.begin(),o.end()
#define PB push_back

using namespace std;
typedef long long ll;

template<class T>
void read(T & x) {
    char ch = getchar();
    bool sign = false;
    x = 0;
    while (ch < '0' || ch > '9') {
        if (ch == '-') sign = true;
        ch = getchar();
    }
    while ('0' <= ch && ch <= '9') {
        x = 10 * x + ch - '0';
        ch = getchar();
    }
    if (sign) x = -x;
}

template<class T>
void print(T x) {
    if (x > 9) print(x / 10);
    putchar('0' + (x % 10));
}

template<class T>
void println(T x) {
    print(x);
    puts("");
}

template<class T>
inline T sqr(T a) {
    return a * a;
}

struct Fract {
    Fract(ll a = 0, ll b = 1)
        :fenzi(a), fenmu(b) {
        sim();
    }

    Fract(const Fract & b) {
        fenzi = b.fenzi;
        fenmu = b.fenmu;
    }

    Fract & operator = (const Fract & b) {
        fenzi = b.fenzi;
        fenmu = b.fenmu;
        return *this;
    }

    void sim() {
        ll g = __gcd(abs(fenzi), abs(fenmu));
        if (g > 1) {
            fenzi /= g;
            fenmu /= g;
        }
        if (fenmu < 0) {
            fenzi = -fenzi;
            fenmu = -fenmu;
        }
    }

    Fract & operator += (const Fract & b) {
        fenzi = fenzi * b.fenmu + b.fenzi * fenmu;
        fenmu *= b.fenmu;
        sim();
        return *this;
    }

    Fract & operator -= (const Fract & b) {
        fenzi = fenzi * b.fenmu - b.fenzi * fenmu;
        fenmu *= b.fenmu;
        sim();
        return *this;
    }

    Fract & operator *= (const Fract & b) {
        fenzi *= b.fenzi;
        fenmu *= b.fenmu;
        sim();
        return *this;
    }

    Fract & operator /= (const Fract & b) {
        fenzi *= b.fenmu;
        fenmu *= b.fenzi;
        sim();
        return *this;
    }

    Fract operator + (const Fract & b) const {
        Fract result = *this;
        result += b;
        return result;
    }

    Fract operator - (const Fract & b) const {
        Fract result = *this;
        result -= b;
        return result;
    }

    Fract operator * (const Fract & b) const {
        Fract result = *this;
        result *= b;
        return result;
    }

    Fract operator / (const Fract & b) const {
        Fract result = *this;
        result /= b;
        return result;
    }
    ll fenzi, fenmu;
};
//#===============================================
/**
 *
 *
 *
 */

 const int N = 100005;
 int fa[N];
 map<int,int> mp;

 int find(int x) {
    return x == fa[x] ? x : fa[x] = find(fa[x]);
 }

 void Union(int u,int v) {
    fa[find(u)] = find(v);
 }


void solve() {
    int T,n;
    cin>>T;
    while(T--) {
        read(n);
        RREP(i,n,1) fa[i] = i;
        REP(i,0,n - 1) {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            if(!w) Union(u,v);  
        }
        mp.clear();
        RREP(i,n,1) {
            mp[find(i)]++;
        }
        int ans = 0;
        auto it = mp.begin();
        while(it != mp.end()) {
            if(it->second & 1) ans ^= it->second;
            it++;
        }
        println(ans);
    }
}

int main() {
    solve();
    return 0;
}