食物链问题(并查集)

简介: 食物链问题(并查集)

题目描述


动物王国中有三类动物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个动物,用上述两种说法,一句接一句地说出K句话,这K句话有的是真的,有的是假的。


当一句话满足下列三条之一时,这句话就是假话,否则就是真话。


1) 当前的话与前面的某些真的话冲突,就是假话;


2) 当前的话中X或Y比N大,就是假话;


3) 当前的话表示X吃X,就是假话。


你的任务是根据给定的N和K句话,输出假话的总数。


输入格式


第一行是两个整数N和K,以一个空格分隔。


以下K行每行是三个正整数 D,X,Y,两数之间用一个空格隔开,其中D表示说法的种类。


若D=1,则表示X和Y是同类。


若D=2,则表示X吃Y。


输出格式


只有一个整数,表示假话的数目。


样例:


输入样例:100 71 101 12 1 22 2 32 3 31 1 32 3 11 5 5输出样例:3


思路分析:


首先讲一下这个题目的意思,ABBCCA

如果按被吃的方向来画,那么C->B->A A->C,这样就形成了一个闭环,也正是生物圈能量的循环

我们这题采用并查集的思想


约定:


食物链绕不开 A->C B->A C->B

因此,利用边的权重,即当前点到根节点的距离作为约束条件

假设根为a(也可以是b,c,因为这是闭环)

有以下三种情况:

1. a和b b->a b到根节点a的距离为1,表示b能被a吃

2. a和c c->b->a c到根节点a的距离为2,表示c能吃a,且c被b吃

3. a和a a->c->b->a a到根节点a的距离为3, 表示a和a是同类


所以我们创建两个集合,一个存放动物,另外一个存放其到父节点的距离

我们将距离对3取余,如果结果为1,则是第一种情况,为2则是第二种情况,为0则是第三种情况


核心算法:


  private static int find(int x) {;
        if(p[x]!=x){
           int tmp=find(p[x]); //开始递归;最终用tmp储存根节点
           d[x]+=d[p[x]]; //递归结束后为该点到根节点的距离
           p[x]=tmp;  //将每个点的父节点设为根节点
        }
        return p[x];   //返回父节点
    }


完整代码:


import java.io.*;
public class Main {
    static int N=50010;
    static int []p=new int[N];  //存放动物
    static int []d=new int[N];  //存放每个节点到父节点的距离
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String []s=br.readLine().split(" ");
        int n=Integer.parseInt(s[0]),k=Integer.parseInt(s[1]);
        for (int i = 1; i <=n; i++) {  //初始化动物堆
            p[i]=i;
        }
        int res=0;   //最后结果
        while (k-->0){
            String []fir=br.readLine().split(" ");
            int D=Integer.parseInt(fir[0]);
            int x=Integer.parseInt(fir[1]);
            int y=Integer.parseInt(fir[2]);
            if(x>n || y>n){
                res++;
            }else {
                //px,py分别储存根节点
                int px=find(x);  int py=find(y);
               if(D==1){
                   //如果x和y在同一个集合中,但是距离差不为0则说明不是同类是假话
                   if(px==py && (d[x]-d[y])%3!=0) {
                       res++;
                   } else if(px!=py){
                       //如果不在同一个集合则让x的根节点的父节点变为y的根节点
                      p[px]=py;
                       //(d[x]+d[px]-d[y])%3==0
                      d[px]=d[y]-d[x];
                   }
               }else {
                   //如果x和y在同一个集合中,但是距离差不为1则说明不是被吃的关系是假话
                  if(px==py && (d[x]-1-d[y])%3!=0){
                      res++;
                  }else if(px!=py){
                      p[px]=py;
                      //(d[x]+d[px]-d[y]-1)%3==0
                      d[px]=d[y]+1-d[x];
                  }
               }
            }
        }
        System.out.println(res);
    }
    private static int find(int x) {;
        if(p[x]!=x){
           int tmp=find(p[x]); //开始递归;最终用tmp储存根节点
           d[x]+=d[p[x]]; //递归结束后为该点到根节点的距离
           p[x]=tmp;  //将每个点的父节点设为根节点
        }
        return p[x];   //返回父节点
    }
}
相关文章
|
算法 测试技术 C++
C++算法:美丽塔O(n)解法单调栈
C++算法:美丽塔O(n)解法单调栈
|
6月前
|
算法
讲课:拓扑排序、最短路算法
讲课:拓扑排序、最短路算法
|
6月前
|
算法 测试技术 C#
【欧拉回路】【图论】【并集查找】765. 情侣牵手
【欧拉回路】【图论】【并集查找】765. 情侣牵手
|
6月前
|
安全 算法 测试技术
【动态规划】【广度优先】LeetCode2258:逃离火灾
【动态规划】【广度优先】LeetCode2258:逃离火灾
|
C++
【LeetCode343】剪绳子(动态规划)
(1)确定状态 dp[i]是将正整数i拆成2个及其以上的正整数后,求所有数的乘积值。
140 0
【LeetCode343】剪绳子(动态规划)
|
机器学习/深度学习
剑指offer 13. 剪绳子
剑指offer 13. 剪绳子
73 0
|
人工智能 算法 容器
从六道leetcode题掌握双指针
双指针从广义上来说,是指用两个变量在线性结构上遍历而解决的问题。狭义上说, 对于数组,指两个变量在数组上相向移动解决的问题; 对于链表,指两个变量在链表上同向移动解决的问题,也称为「快慢指针」问题。 双指针算法通常不难,双指针算法是基于暴力解法的优化,它们是很好的学习算法的入门问题
LeetCode每日一题(11)——太平洋大西洋水流问题(递归,深度优先遍历实例)
大西洋太平洋水流问题 1.题目 2.示例 3.思路 理解题目 解题思路 4.代码
144 0
LeetCode每日一题(11)——太平洋大西洋水流问题(递归,深度优先遍历实例)
|
机器学习/深度学习 算法
<<算法很美>>——(六)——回溯算法(下)—N皇后问题
<<算法很美>>——(六)——回溯算法(下)—N皇后问题
<<算法很美>>——(六)——回溯算法(下)—N皇后问题
|
存储 C语言 C++
二叉树遍历就是这么简单(必杀)
二叉树遍历就是这么简单(必杀)
二叉树遍历就是这么简单(必杀)