LA3644 X-Plosives 并查集(维护连通分量，判断有无环)

Albafica

墨衍会员 · AI 创作全网分发码龄15年

关注

原创最新推荐文章于 2017-01-13 18:18:25 发布 1k 阅读 AI 写同款· GEO 优化 ›

AI权益加码！Claude Code、Cursor等20+工具免费用！购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！阅读详情

一个元素当做一个节点，一个物品由两个节点之间的一条边（因为一个物品由2个元素组成），让元素相连产生一个环的时候会产生危险

现在给我们很多个物品，要我们输出剔除多少个物品，能够保证安全

做法：用并查集维护一个图的连通分量几个，每次得到化合物（x，y）时，检查x和y是否在一个集合中，如果是则需要拒绝当前化合物，（因为x，y在一个连通分量中，此时图尚不存在环，可以说是一棵树，但当边x-y加入到该连通分量的时候显然就产生了一个环）

X-Plosives

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. Let’s 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

The input will contain several test cases, each of them as described below. Consecutive test cases are separated by a single blank line.

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 2

3 4

3 5

3 1

2 3

4 1

2 6

6 5

-1

Sample Output

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>


using namespace std;

#define MAXN 100010

int set[MAXN];

void init()
{
    for(int i=0;i<MAXN;i++)
        set[i]=i;
}

int find(int a)
{
    int root=a;
    int tmp;
    while(set[root]!=root)
        root=set[root];
    while(set[a]!=root)
    {
        tmp=a;
        a=set[a];
        set[tmp]=root;
    }
    return root;
}

bool merge(int a,int b)
{
    int x=find(a);
    int y=find(b);
    if(x==y)
        return false;
    set[x]=y;
    return true;
}

int main()
{
    int a,b;
    int ans;
    while(~scanf("%d%d",&a,&b))
    {
        init();
        ans=0;
        merge(a,b);
        while(~scanf("%d",&a) && a!=-1)
        {
            scanf("%d",&b);
            if(find(a)==find(b))
                ans++;
            else
                merge(a,b);
        }
        printf("%d\n",ans);
    }
    return 0;
}

收录于