BNU X-Plosives(并查集） @

X-Plosives

Time Limit: 3000ms

Memory Limit: 131072KB

This problem will be judged on UVALive. Original ID: 3644
64-bit integer IO format: %lld      Java class name: Main

Prev Submit Status Statistics Discuss Next

Font Size: + -

Type:  None Graph Theory     2-SAT     Articulation/Bridge/Biconnected Component     Cycles/Topological Sorting/Strongly Connected Component     Shortest Path         Bellman Ford         Dijkstra/Floyd Warshall     Euler Trail/Circuit     Heavy-Light Decomposition     Minimum Spanning Tree     Stable Marriage Problem     Trees     Directed Minimum Spanning Tree     Flow/Matching         Graph Matching             Bipartite Matching             Hopcroft–Karp Bipartite Matching             Weighted Bipartite Matching/Hungarian Algorithm         Flow             Max Flow/Min Cut             Min Cost Max Flow DFS-like     Backtracking with Pruning/Branch and Bound     Basic Recursion     IDA* Search     Parsing/Grammar     Breadth First Search/Depth First Search     Advanced Search Techniques         Binary Search/Bisection         Ternary Search Geometry     Basic Geometry     Computational Geometry     Convex Hull     Pick's Theorem Game Theory     Green Hackenbush/Colon Principle/Fusion Principle     Nim     Sprague-Grundy Number Matrix     Gaussian Elimination     Matrix Exponentiation Data Structures     Basic Data Structures     Binary Indexed Tree     Binary Search Tree     Hashing     Orthogonal Range Search     Range Minimum Query/Lowest Common Ancestor     Segment Tree/Interval Tree     Trie Tree     Sorting     Disjoint Set String     Aho Corasick     Knuth-Morris-Pratt     Suffix Array/Suffix Tree Math     Basic Math     Big Integer Arithmetic     Number Theory         Chinese Remainder Theorem         Extended Euclid         Inclusion/Exclusion         Modular Arithmetic     Combinatorics         Group Theory/Burnside's lemma         Counting     Probability/Expected Value Others     Tricky     Hardest     Unusual     Brute Force     Implementation     Constructive Algorithms     Two Pointer     Bitmask     Beginner     Discrete Logarithm/Shank's Baby-step Giant-step Algorithm     Greedy     Divide and Conquer Dynamic Programming                   Tag it!

[PDF Link]

 

A secret service developed a new kind of explosive that attain its volatile property only when a specific association of products occurs. Each product is a mix of two different simple compounds, to which we call a binding pair. If N>2, then mixing N different binding pairs containing N simple compounds creates a powerful explosive. For example, the binding pairs A+B, B+C, A+C (three pairs, three compounds) result in an explosive, while A+B, B+C, A+D (three pairs, four compounds) does not.

 

You are not a secret agent but only a guy in a delivery agency with one dangerous problem: receive binding pairs in sequential order and place them in a cargo ship. However, you must avoid placing in the same room an explosive association. So, after placing a set of pairs, if you receive one pair that might produce an explosion with some of the pairs already in stock, you must refuse it, otherwise, you must accept it.

 

An example. Lets assume you receive the following sequence: A+B, G+B, D+F, A+E, E+G, F+H. You would accept the first four pairs but then refuse E+G since it would be possible to make the following explosive with the previous pairs: A+B, G+B, A+E, E+G (4 pairs with 4 simple compounds). Finally, you would accept the last pair, F+H.

 

Compute the number of refusals given a sequence of binding pairs.

 

Input

Instead of letters we will use integers to represent compounds. The input contains several lines. Each line (except the last) consists of two integers (each integer lies between 0 and 10⁵) separated by a single space, representing a binding pair. The input ends in a line with the number –1. You may assume that no repeated binding pairs appears in the input.

 

Output

For each test case, a single line with the number of refusals.

 

Sample Input

1 23 43 53 12 34 12 66 5-1  

Sample Output

3

Source

Regionals 2006, Europe - Southwestern

有一些化合物，每个化合物都由两种元素组成的（每个元素用一个大写字母表示）。你是一个装箱的工人，从实验员那里按照顺序依次把一些简单化合物装到车上。但这里存在一个安全隐患：如果车上存在k个简单的化合物，正好包含k中元素，那么它们将组成一个易爆的混合物。为了安全起见，每当你拿到一个化合物时，如果它和已装的化合物形成易爆混合物，你就应当拒绝装车；否则就应该装车。编程输出有多少个没有装车的化合物

不能存在K个混合物，使有K个元素，即图中不能有环，求不能存在的混合物个数

#include <iostream>#include <cstdio>#include <cstring>#include <cmath>#include <vector>#include <map>#include <queue>#include <algorithm>using namespace std;const int N = 1e5+10;int f[N];int getf(int x){    if(x!=f[x])    {        f[x]=getf(f[x]);        return f[x];    }    return x;}int main(){    int x, y;    while(scanf("%d", &x)==1)    {        for(int i=0;i<=N;i++) f[i]=i;        int cnt=0;        while(x!=-1)        {            scanf("%d", &y);            int t1=getf(x), t2=getf(y);            if(t1==t2) cnt++;            else f[t1]=t2;            scanf("%d", &x);        }        printf("%d\n",cnt);    }    return 0;}