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

最新推荐文章于 2022-03-02 15:39:00 发布

原创最新推荐文章于 2022-03-02 15:39:00 发布 · 227 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

acm训练题专栏收录该内容

36 篇文章

订阅专栏

这篇博客主要探讨了POJ P1955题目的解决方案，涉及并查集的数据结构。作者首先尝试使用带权并查集，后来改为简化思路，通过并查集实现相等关系的传递性判断，避免了复杂的状态管理。在第二版代码中，采用了离散化处理以优化大范围数据的查询效率。博客强调了在解决问题时不应过度复杂化，而应先尝试简单方法。

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;
}