#poj：P1955 [NOI2015] 程序自动分析

**

poj：P1955 [NOI2015] 程序自动分析

**

#题目描述

#看到题就能想到是并查集了 但是想的复杂了 还以为是一般的带权并查集 想了好久没做出来
#与其判断相等和不相等交替的传递性问题 不如直接到就将相等的联系起来 因为相等有传递性 把不相等看作一次查询 如果这两个点在一个并查集里就错了

#知识点
并差集 离散化

#代码
第一次用权并查集来写 并没有真正的带上权 过了个50 想优化但就是写不出来了

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<stdio.h>
#include<cstring>
#define maxn 1000050
using namespace std;
typedef long long int LL;
int t,n,bp;
LL a,b;
LL relat[maxn];
LL root[maxn];
void init()
{
    for(int i=1; i<=n; i++)
    {
        root[i] = i;
        relat[i] = 0;///自己同自己相同
    }
}
LL Find(LL a)
{
    if(a == root[a])
        return a;
    else
    {
        LL temp = root[a];
        root[a] = Find(root[a]);
        //relat[a] = (relat[a]+relat[temp]+2)%2;
        relat[a] = relat[a] + relat[temp];
        return root[a];
    }
}
void add(LL a,LL b)
{
    LL ra = Find(a);
    LL rb = Find(b);
    root[ra] = rb;
}
int main()
{
    cin >> t;
    while(t--)
    {
        cin >> n;
        init();
        int flag = 1;
        for(int i=1; i<=n; i++)
        {
            cin >> a >>b >> bp;
            if(flag == 0)
            {
                continue;
            }
            if(bp == 1)
            {
                if(relat[a] + relat[b] == 1)//仅仅变换一次 还能相等是错的
                {
                    flag = 0;
                }else
                {
                    add(a,b);
                }
            }else
            {
                if(relat[a] + relat[b] == 0)//所有都是相等的 出现不相等就错了
                {
                    flag = 0;
                }else
                {
                    add(a,b);
                }
            }
        }
        if(flag == 0)
        {
            cout << "NO" <<endl;
        }else
        {
            cout << "YES" <<endl;
        }
    }
    return 0;
}

第二次换了种想法 过了 但没完全过 因为i j 两个点多数据范围太大了 但是范围内的数据个数远远没有这么多 学了手 离散化处理来优化 不处理的话编译器来不了这么大的数据范围

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<stdio.h>
#define maxn 1000009
using namespace std;
int t;
int n,a,b,cnt,ep,temp;
int num[maxn],lsh[maxn];
int root[maxn];
struct node
{
    int a;
    int b;
    int ep;
}data[maxn];
void init()
{
    for(int i=1;i<=temp;i++)
    {
        root[i] = i;
    }
}
int Find(int a)
{
    if(a == root[a])
        return a;
    else
    {
        root[a] = Find(root[a]);
        return root[a];
    }
}
void add(int a,int b)
{
    int ra = Find(a);
    int rb = Find(b);
    root[ra] = rb;
}
int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        cin >> n;
        cnt = 0;
        for(int i=1;i<=n;i++)
        {
            cin >> a >> b >> ep;
            num[++cnt] = a;
            lsh[cnt] = a;
            num[++cnt] = b;
            lsh[cnt] = b;
            data[i].a = a;
            data[i].b = b;
            data[i].ep = ep;
        }
        sort(lsh+1,lsh+1+cnt);
        temp = unique(lsh+1,lsh+1+cnt)-lsh-1;//去重后的真实数据个数
        init();
        for(int i = 1;i<=n;i++)
        {
            if(data[i].ep == 1)
            {
                a = lower_bound(lsh+1,lsh+1+temp,data[i].a) - lsh;
                b = lower_bound(lsh+1,lsh+1+temp,data[i].b) - lsh;
                add(a,b);
            }
        }
        int flag = 1;
        for(int i =1;i<=n;i++)///要先将数据都先输入了再来查询
        {
            if(data[i].ep == 0 && flag == 1)//有错误了就不再来算了
            {
                a = lower_bound(lsh+1,lsh+1+temp,data[i].a) - lsh;
                b = lower_bound(lsh+1,lsh+1+temp,data[i].b) - lsh;
                if(Find(a) == Find(b))
                {
                    flag = 0;
                }
            }
        }
        if(flag == 1)
        {
            cout << "YES" <<endl;
        }else
        {
            cout << "NO" <<endl;
        }

    }
    return 0;
}

#总结
很多东西都没有想的那么复杂 先简单的过一遍 试试没什么 （蒟蒻又不差那点罚时 (⊙ˍ⊙)）