【并查集】：poj1182，食物链

最新推荐文章于 2022-12-22 21:28:01 发布
最新推荐文章于 2022-12-22 21:28:01 发布
阅读量496 收藏
点赞数 1
分类专栏： 算法与数据结构 文章标签： 并查集 poj1182 食物链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmc2015/article/details/50397351
版权


关键是向量化的关系调整。


下面能过。

注意几点：

FindParent、用scanf别用cin。

# include<iostream>
# include<string.h>
# include<stdio.h>
using namespace std;

# define N 50010
# define K 100005


struct NODE
{
    int parent;
    int relation;
    //0表示和父节点同类，1表示被父节点吃（规定，让y指向x），2表示吃父节点
    //（必须和d-1对应上）
    //若D=1，则表示X和Y是同类。
    //若D=2，则表示X吃Y。
};


NODE node[N];


void MakeSet(int n)
{
    for(int i=1;i<=n;i++)
    {
        node[i].parent=i;
        node[i].relation=0;
    }
}

int FindParent(int x)
{
    if(node[x].parent==x)
    {
        return x;
    }
    else
    {
        /*
        node[x].parent=FindParent(node[x].parent);
        node[x].relation=(node[x].relation+node[node[x].parent].relation)%3; //x->xp->xpp
        */
        //can't use above codes, will WA
        int temp = node[x].parent; //路径压缩
        node[x].parent = FindParent(temp);
        node[x].relation = (node[x].relation + node[temp].relation) % 3; //关系域更新

        return node[x].parent;
    }
}

int Judge(int x, int y, int d)
{
    int xp=FindParent(x);
    int yp=FindParent(y);

    if(xp==yp) //不需要合并，直接判断是否冲突
    {
        if( d==1 && node[x].relation!=node[y].relation )
        {
            return 1;
        }
        if( d==2 && ( (3+node[y].relation-node[x].relation)%3!=(d-1) ) )
        {
            return 1;
        }
    }
    else
    {
        //先合并
        node[yp].parent=xp;
        //再调整关系
        //node[yp].relation=(-node[y].relation-(d-1)+node[x].relation+3)%3;
        node[yp].relation=(3-node[y].relation+(d-1)+node[x].relation)%3;
        //注意是，+(d-1)，因为d-1之后，已经对应y->x的关系了（d表示x->y的关系）
        return 0;
    }
}

int main()
{
    int sum=0;
    int n,k,d,x,y,i;
    cin>>n>>k;

    MakeSet(n);

    for(i=1;i<=k;i++)
    {
        //cin>>d>>x>>y;
        scanf("%d%d%d",&d,&x,&y); //or TLE

        if( (x>n||y>n) || (x==y&&d==2) )
        {
            sum++;
        }
        else
        {
            //sum+=Judge(x,y,d);
            int xp=FindParent(x);
            int yp=FindParent(y);

            if(xp==yp) //不需要合并，直接判断是否冲突
            {
                if( d==1 && node[x].relation!=node[y].relation )
                {
                    //return 1;
                    sum++;
                }
                if( d==2 && ( (3+node[y].relation-node[x].relation)%3!=(d-1) ) )
                {
                    //return 1;
                    sum++;
                }
            }
            else
            {
                //先合并
                node[yp].parent=xp;
                //再调整关系
                //node[yp].relation=(-node[y].relation-(d-1)+node[x].relation+3)%3;
                node[yp].relation=(3-node[y].relation+(d-1)+node[x].relation)%3;
                //注意是，+(d-1)，因为d-1之后，已经对应y->x的关系了（d表示x->y的关系）
                //return 0;
            }
        }
    }

    cout<<sum<<endl;

    return 0;
}



没看出啊下面有什么问题，但是就是不AC。大神看到了指导一下。

# include<iostream>
# include<string.h>
# include<stdio.h>
using namespace std;

# define N 50010
# define K 100005


struct NODE
{
    int parent;
    int relation;
    //0表示和父节点同类，1表示被父节点吃（规定，让y指向x），2表示吃父节点
    //（必须和d-1对应上）
    //若D=1，则表示X和Y是同类。
    //若D=2，则表示X吃Y。
};


NODE node[N];


void MakeSet(int n)
{
    for(int i=1;i<=n;i++)
    {
        node[i].parent=i;
        node[i].relation=0;
    }
}

int FindParent(int x)
{
    if(node[x].parent==x)
    {
        return x;
    }
    else
    {
        /*
        node[x].parent=FindParent(node[x].parent);
        node[x].relation=(node[x].relation+node[node[x].parent].relation)%3; //x->xp->xpp
        */
        //can't use above codes, will WA
        int temp = node[x].parent; //路径压缩
        node[x].parent = FindParent(temp);
        node[x].relation = (node[x].relation + node[temp].relation) % 3; //关系域更新

        return node[x].parent;
    }
}

int Judge(int x, int y, int d)
{
    int xp=FindParent(x);
    int yp=FindParent(y);

    if(xp==yp) //不需要合并，直接判断是否冲突
    {
        if( d==1 && node[x].relation!=node[y].relation )
        {
            return 1;
        }
        if( d==2 && ( (3+node[y].relation-node[x].relation)%3!=(d-1) ) )
        {
            return 1;
        }
    }
    else
    {
        //先合并
        node[yp].parent=xp;
        //再调整关系
        //node[yp].relation=(-node[y].relation-(d-1)+node[x].relation+3)%3;
        node[yp].relation=(3-node[y].relation+(d-1)+node[x].relation)%3;
        //注意是，+(d-1)，因为d-1之后，已经对应y->x的关系了（d表示x->y的关系）
        return 0;
    }
}

int main()
{
    int sum=0;
    int n,k,d,x,y,i;
    cin>>n>>k;

    MakeSet(n);

    for(i=1;i<=k;i++)
    {
        //cin>>d>>x>>y;
        scanf("%d%d%d",&d,&x,&y); //or TLE

        if( (x>n||y>n) || (x==y&&d==2) )
        {
            sum++;
        }
        else
        {
            sum+=Judge(x,y,d);
            /*
            int xp=FindParent(x);
            int yp=FindParent(y);

            if(xp==yp) //不需要合并，直接判断是否冲突
            {
                if( d==1 && node[x].relation!=node[y].relation )
                {
                    //return 1;
                    sum++;
                }
                if( d==2 && ( (3+node[y].relation-node[x].relation)%3!=(d-1) ) )
                {
                    //return 1;
                    sum++;
                }
            }
            else
            {
                //先合并
                node[yp].parent=xp;
                //再调整关系
                //node[yp].relation=(-node[y].relation-(d-1)+node[x].relation+3)%3;
                node[yp].relation=(3-node[y].relation+(d-1)+node[x].relation)%3;
                //注意是，+(d-1)，因为d-1之后，已经对应y->x的关系了（d表示x->y的关系）
                //return 0;
            }
            */
        }
    }

    cout<<sum<<endl;

    return 0;
}


又做了一遍，过了：

#include <iostream>
#include <stdio.h>
using namespace std;

#define N 50005

struct NODE
{
    int par;
    int rel;
    //d=1，x和y同类
    //d=2，x吃y
    //转换为d-1：
    //d-1=0，x和y同类
    //d-1=1，父亲吃儿子（令y是x的儿子）
    //d-1=2，儿子吃父亲（令y是x的儿子）
};

NODE node[N];

int FindPar(int x)
{
    if(node[x].par==x)
    {
        return x;
    }
    else
    {
        int temp=node[x].par;
        node[x].par=FindPar(temp);
        node[x].rel=(node[x].rel+node[temp].rel)%3;
        return node[x].par;
    }
}


int main()
{
    int n,k,d,x,y,i,sum=0;

    cin>>n>>k;

    for(i=1;i<=n;i++)
    {
        node[i].par=i;
        node[i].rel=0;
    }

    for(i=1;i<=k;i++)
    {
        scanf("%d%d%d",&d,&x,&y);

        if( (x>n || y>n) || (d==2 && x==y) )
        {
            sum++;
        }
        else
        {
            int xp=FindPar(x);
            int yp=FindPar(y);
            if(xp==yp)
            {
                if( d==1 && (node[x].rel!=node[y].rel) )
                {
                    sum++;
                }
                if( d==2 && (3+node[y].rel-node[x].rel)%3 != (d-1) )
                {
                    sum++;
                }
            }
            else
            {
                node[yp].par=xp;
                node[yp].rel=(3-node[y].rel+(d-1)+node[x].rel)%3;
            }
        }
    }

    cout<<sum<<endl;

    return 0;
}


mmc2015
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【并查集】POJ 1182 食物链
小酷Miki的专栏
05-15 337
POJ 1182 : 食物链 由于题目中的N个动物都是A,B,C三类中的其中一种。题目有两种操作方式，【1】”1 X Y”，表示X和Y是同类，这个操作就是并查集中的【并】操作，【2】”2 X Y”，表示X吃Y，这个操作实际上是维护了森林中树之间的关系（类似有向图，此时树类比成一个顶点）。题目求这两个操作不成功的个数，假设为ans。 问题拆分 【1】进行1 X Y表示X和Y是同类...
1093: 并查集2（删边问题）
TanYC的博客
07-25 913
1093: 并查集2（删边问题） 时间限制: 1 Sec 内存限制: 128 MB 题目描述 【题目描述】 读入一个无向图（可能含有多个连通分支），输出最多能删掉多少条边，而不改变这个图任意两点的连通性（原来连通的两个点依然连通，不连通的依然不连通）。 【输入格式】 第一行为图的顶点数N（1≤N≤1000）和边数M（0≤M ≤(N*(N+1)/2) )，它们之间用一个空格隔开，
hdu 4496 并查集的变形
风华绝代
04-26 914
D-City Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 1055    Accepted Submission(s): 404 Problem Description Luxer is a really ba
并查集：POJ 1182 食物链 复习
豆子
03-08 111
并查集：POJ 1182 食物链 复习 #include <iostream> #include <algorithm> #include <cstring> #include <cstdlib> #include <cstdio> using namespace std; ...
POJ1182 食物链（并查集）
最新发布
qq_53038151的博客
12-22 238
并查集的简单应用。
并查集：POJ1182-食物链（并查集比较高端的应用）
二营长的意大利炮友
07-30 300
食物链Time Limit: 1000MS Memory Limit: 10000KDescription动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。 有人用两种说法对这N个动物所构成的食物链关系进行描述： 第一种说法是”1 X Y”，
poj1182食物链(并查集)
RPG_Zero的博客
07-14 164
食物链 Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 105281 Accepted: 31875 Description 动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。 有人用两...
（并查集）POJ1182 食物链
05-12 271
  Description 动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。  现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。  有人用两种说法对这N个动物所构成的食物链关系进行描述：  第一种说法是"1 X Y"，表示X和Y是同类。  第二种说法是"2 X Y"，表示X吃Y。  此人对N个动物，用上述...
【并查集】poj 1182 食物链
Gzbgreat的博客
07-31 302
膜
poj2492并查集应用的扩展
04-25
poj2492 A Bug's Life并查集应用的扩展，希望可以给大家带来用处
poj 食物链
11-18
poj 食物链代码.带权并查集,关键是找到其中的一些关系式.
并查集板子加例题
01-06
//http://poj.org/problem?id=1611 #include using namespace std; const int maxn = 30010; int f[maxn],num[maxn],n,m; int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); } int main() { while(cin...
POJ 1988 简单并查集，
03-18
POJ 1988 并查集。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
1089_bingchaji.rar_1089_bingchaji.rar _并查集
09-19
在给定的标题“1089_bingchaji.rar_1089_bingchaji.rar _并查集”和描述“POJ1089 并查集可以解决 并查集加路径压缩”中，我们可以看到这是一个关于使用并查集解决特定问题的案例，可能来自于编程竞赛或练习。...
（子）图同构算法VF2实现（1）
热门推荐
mmc2015的专栏
11-11 1万+
子图同构问题本质上就是一种匹配，VF2算法加了很多feasibility rules，保证了算法的高效性。这里只是实现最基本的判断子图同构的算法： 参考文献有（其实google一把就能出来这些）： http://stackoverflow.com/questions/8176298/vf2-algorithm-steps-with-example http://www.zhihu
（子）图同构算法VF2实现（2）——源代码与具体实现
mmc2015的专栏
11-14 7603
上一篇关于VF2的博客写的太水了，http://blog.csdn.net/mmc2015/article/details/49777447。而且错误百出。 这里给出真正需要注意的地方 1）数据结构： //每个邻接边的结构，注意，该结构不单独使用，必须和某个点一起使用 struct EDGE { int id2; //边的另一端的点的id int id2Label; //注意，两
【贪心算法，最小延迟调度】：poj***，***
mmc2015的专栏
05-03 6392
暂时没在poj上找到对应的题目，不过思想非常简单。 一堆任务，每个任务有最晚完成时间di，和需要持续的时间ti。 真实安排这些任务时，每个任务有真是的开始时间si和结束时间fi。称一个任务的延迟时间为fi-di。 目的：找一个安排任务的方案，使所有任务的总的延迟最小。 贪心算法：最早截止时间优先。 # include # include using
【网络流】最大流：求最小割值、求（边）不交路径数量、求二分匹配最大匹配数
mmc2015的专栏
11-05 4634
1）最大流等于最小割： P249，定理7.13，每个流网络中，一个s-t 流的最大值等于一个s-t 割的最小容量。 即，求s-t 的最小割，可以转换为求 s-t 的最大流。 2）有向图和无向图中的 （边）不相交路径： 说一组路径边不相交，指所有路径不共享任何一条边，但是可以共享节点。 有向边不交路径问题是，在有向图G中找到边不交的 s-t 路径的最大数目；无向边不交路径问题是，在
并查集应用解析与题目推荐
本文主要介绍了并查集这一数据结构，并列举了多个基于并查集的编程题目，包括POJ 2524、POJ 1611、POJ 1703、POJ 2236、POJ 2492、POJ 1988和POJ 1182，用于逐步提升对并查集的理解和应用能力。并查集主要用于处理不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值