图论练习4

于 2024-02-03 17:31:05 发布
阅读量1k 收藏 10
点赞数 4
分类专栏： 图论 文章标签： 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xing_ke/article/details/136009477
版权

内容：染色划分，带权并查集，扩展并查集

Arpa’s overnight party and Mehrdad’s silent entering

题目链接

题目大意

  • 2n个点围成一圈，分为n对，对内两点不同染色
  • 同时，相邻3个点之间必须有两个点不同染色
  • 问构造出一种染色方案

解题思路 

  •  将每对进行的连边看作一类边
  • 将为满足相邻3个点必须有两个点不同染色的边，看作二类边
  • 满足构造方案，即将2n个点形成一个二分图，无奇环
  • 对于只有一类边，形不成环，端点不同
  • 对于二类边与一类边组合才能形成环
  • 将二类边定义为2_i\leftrightarrow 2_i+1
  • 成环的情况只能，如下图
  • 由于一类边不可能相连，中间必然是二类边，一类边交换，所以环上的点数为二类边的总点数，一定为偶数，只能形成偶环，构造成立
  • 利用带权并查集实现

import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Vector;




public class Main{
	
	static int find(int x,int[] fa,int[] relation) {
		if(x==fa[x])return x;
		else {
			int f=fa[x];
			fa[x]=find(fa[x], fa, relation);
			relation[x]=(relation[x]+relation[f])%2;
			return fa[x];
		}
	}

	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int n=input.nextInt();
	    int[] fa=new int[2*n+1];
	    int[] relation=new int[2*n+1];
	    for(int i=1;i<=2*n;++i)fa[i]=i;
	    int[] a=new int[n+1];
	    int[] b=new int[n+1];
	    for(int i=1;i<=n;++i) {
	    	int x=input.nextInt();
	    	int y=input.nextInt();
	    	a[i]=x;b[i]=y;
	    	int fx=find(x, fa, relation);
	    	int fy=find(y, fa, relation);
	    	if(fx==fy)continue;
	    	fa[fx]=fy;
	    	relation[fx]=(relation[y]+1-relation[x]+2)%2;
	    }
	    for(int i=1;i<=n;++i) {//一圈
	    	int x=2*i;
	    	int y=i==n?1:2*i+1;
	    	int fx=find(x, fa, relation);
	    	int fy=find(y, fa, relation);
	    	if(fx==fy)continue;
	    	fa[fx]=fy;
	    	relation[fx]=(relation[y]+1-relation[x]+2)%2;
	    }
	    for(int i=1;i<=n;++i) {
	    	find(a[i], fa, relation);
	    	find(b[i], fa, relation);
	    	int x=relation[a[i]]+1;
	    	int y=relation[b[i]]+1;
	    	out.println(x+" "+y);
	    }
 	    out.flush();
	    out.close();
	}
	static
	class AReader{
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;

	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}

食物链 

题目链接 

题目大意

  • n个点，k对关系
  • 每个点可能为A/B/C类，它们之间满足A吃B，B吃C，C吃A
  • k对关系中，1,x,y表示x,y同类，2,x,y表示x吃y
  • 依次处理k对关系，若当前关系与之前的关系矛盾，则视为错误
  • x>n,y>n,(2,x,y)x=y（自己吃自己），均视为错误
  • 问有多少对错误

解题思路

  • 对n个点进行3种颜色的染色划分
  • 类似黑白染色
  • 利用带权并查集或扩展并查集实现
  • 详见图论笔记 

扩展并查集 

 
import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Vector;
 
 
 
 
public class Main{
	
	static int find(int x,int[] fa) {
		if(x==fa[x])return x;
		else return fa[x]=find(fa[x], fa);
	}
	
	
	
	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int n=input.nextInt();
	    int k=input.nextInt();
	    int[] fa=new int[3*n+1];
	    for(int i=1;i<=3*n;++i)fa[i]=i;
	    int ans=0;
	    for(int i=1;i<=k;++i) {
	    	int op=input.nextInt();
	    	int x=input.nextInt();
	    	int y=input.nextInt();
	    	if(x>n||y>n) {
	    		ans++;
	    		continue;
	    	}
	    	if(op==1) {
	    		if(find(x, fa)==find(y+n, fa)||find(y, fa)==find(x+n, fa)) {
	    			//x吃y或y吃x
	    			//x吃y=>xA->yB,xB->yC,xC->yA
	    			//y吃x=>yA->xB,yB->xC->yC->xA
	    			ans++;
	    			continue;
	    		}
	    		fa[find(x, fa)]=find(y, fa);
	    		fa[find(x+n, fa)]=find(y+n, fa);
	    		fa[find(x+2*n, fa)]=find(y+2*n, fa);
	    	}else {
	    		if(x==y) {
	    			ans++;
	    			continue;
	    		}
	    		if(find(x, fa)==find(y, fa)||find(y, fa)==find(x+n, fa)) {
	    			//x和y是同类,y吃x
	    			ans++;
	    			continue;
	    		}
	    		fa[find(x, fa)]=find(y+n, fa);
	    		fa[find(x+n, fa)]=find(y+2*n, fa);
	    		fa[find(x+2*n, fa)]=find(y, fa);
	    	}
	    }
	    out.print(ans);
 	    out.flush();
	    out.close();
	}
	static
	class AReader{
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;
 
	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}

 带权并查集

 
import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Vector;
 
 
 
 
public class Main{
	
	static int find(int x,int[] fa,int[] relation) {
		if(x==fa[x])return x;
		else {
			int f=fa[x];
			fa[x]=find(fa[x], fa, relation);
			relation[x]=(relation[x]+relation[f])%3;
			return fa[x];
		}
	}
	
	
	
	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    int n=input.nextInt();
	    int k=input.nextInt();
	    int ans=0;
	    int[] fa=new int[n+1];
	    int[] relation=new int[n+1];
	    for(int i=1;i<=n;++i) fa[i]=i;
	    for(int i=1;i<=k;++i) {
	    	int op=input.nextInt();
	    	int x=input.nextInt();
	    	int y=input.nextInt();
	    	if(x>n||y>n) {
	    		ans++;
	    		continue;
	    	}
	    	if(op==1) {
	    		int fx=find(x, fa, relation);
	    		int fy=find(y, fa, relation);
	    		if(fx==fy) {
	    			if(relation[x]!=relation[y]) {
	    				ans++;
	    				continue;
	    			}
	    		}else {
	    			fa[fx]=fy;
	    			relation[fx]=(relation[y]+0-relation[x]+3)%3;
	    		}
	    	}else {
	    		if(x==y) {
	    			ans++;
	    			continue;
	    		}
	    		int fx=find(x, fa, relation);
	    		int fy=find(y, fa, relation);
	    		if(fx==fy) {//0吃1，1吃2，2吃0
	    			if(relation[x]==0&&relation[y]==1||
	    					relation[x]==1&&relation[y]==2||
	    					relation[x]==2&&relation[y]==0)continue;
	    			ans++;
	    			continue;
	    		}else {
	    			fa[fx]=fy;
	    			relation[fx]=(relation[y]+2-relation[x]+3)%3;
	    		}
	    	}
	    }
	    out.println(ans);
 	    out.flush();
	    out.close();
	}
	static
	class AReader{
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;
 
	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}

Xing_ke309
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图论基本算法练习
weixin_43823539的博客
06-12 258
图论基本算法练习 小呆要去位于 A 市的皮球家。小呆来到 A 市的车站，买了一张 A 市的地图，他发现这里的地形非常的复杂。A 市的街道一共有 N 个路口，M 条道路，每条道路连接着两个路口，并且有各自的长度。目前，小呆所在的车站位于编号为 1 的路口，而皮球家所在的路口编号为 N，小呆准备打出租车去，当然，路程越小，付的钱就越少。问题摆在眼前：请帮助小呆寻找一条最短路径，使得他可以花最少的钱到达皮球家。 输入 第一行有两个整数 N, M (N≤1000) 分别代表路口数和街道数。以下有 M 行用以描述各个
图论练习迪杰斯特拉算法测试数据
04-12
图论练习迪杰斯特拉算法测试数据
图论练习题
yoongrui
06-24 4114
习题来源：《图论》王树禾著
图论练习1
最新发布
Xing_ke的博客
02-01 1090
内容：Tuopu，拆点，分层，传递，带限制的最小生成树
图论练习题（存起来练）
既然弱小，就只顾变强就是了
10-26 1643
=============================以下是最小生成树+并查集======================================  【HDU】  1213 How Many Tables 基础并查集★  1272 小希的迷宫 基础并查集★  1325&amp;&amp;poj1308 Is It A Tree? 基础并查集★  1856 More is better ...
图论练习
Minoz的博客
03-07 519
这几天和潘学长 达成了一起刷题的协议，然后潘学长带着我们想图论开始发起进攻（ 冲鸭ヾ(≧O≦)〃嗷~） A - How Many Tables 戳这戳这~http://acm.hdu.edu.cn/showproblem.php?pid=1213 Today is Ignatius' birthday. He invites a lot of friends. Now it's din...
图论练习专题
m0_51531927的博客
07-19 432
图论专题练习，大部分题目从算法竞赛进阶指南选
离散数学图论的练习题详解
缘友一世的博客
12-23 1588
2×2+1×3+3×4+x=2(2+1+3+x−1)解得：x=9n(n⩾)，mn:结点数m:边数r:面数r=m−n+22m≥3r，解得r≤32​m。m−n+2≤32​mm≤3n−6m⩽3n−67+3×3+4×x=2(7+3+x−1)x=1G162×x=16×2x=16D=V,EV1​。
图论练习册
卡尔
09-01 614
转自http://blog.csdn.net/allenjy123/article/details/6627248 一、最短路 POJ 2449 Remmarguts' Date(中等) http://acm.pku.edu.cn/JudgeOnline/problem?id=2449 题意：经典问题：K短路 解法：dijkstra+A*(rec)，方法很多 相
图论综合练习
weixin_48528036的博客
11-01 159
开始刷的第一场图论专题 效率略低，但是好歹在秋假之前刷完了这一场了，理解果然变的更深了，要是还有时间刷就好了 Omkar and Last Class of Math CodeForces - 1372B 题意：1300的数论题，故意找的简单的数论题，数论起步一下吧，题面就是给定两数之和，求两数lcm最小值 思路：偶数就不说了，答案就是n/2,奇数就是暴力试一下能不能除尽3.5.7.9……之类的，能除尽答案就是剩下大的那个数 AC代码 #include <bits/stdc++.h> usi
图论练习题.docx
03-13
图论是离散数学的一个重要分支，主要研究点与点之间相互连接的结构。上述题目涉及到了图论中的几个核心概念，包括...以上是对图论练习题中涉及的知识点的详细解释，这些概念和算法在图论和网络优化等领域中有广泛应用。
图论练习题.pdf
03-13
图论是离散数学的一个重要分支，主要研究...总结起来，这些练习题涵盖了图论的基础知识，如完全图、树、连通性、最小生成树算法、最短路径算法以及最大流问题。理解和掌握这些概念对于深入学习图论和网络优化至关重要。
图论练习题 (2).pdf
03-13
4. **割边与割点**：在图论中，割边是如果删除它就会导致图不再连通的边。割点是如果删除它及其关联的所有边，也会导致图不再连通的顶点。在一个连通图中，如果每条边都不是割边，那么这个图就不是树，因为它包含...
图论练习题 (2).docx
03-13
图论是离散数学的一个重要分支，主要研究图的结构、性质及其在各种问题中的应用。以下是基于题目给出的部分内容的图论知识点详解： 1. 完全图：完全图是一个图，其中任意两个不同的顶点之间都有一条边相连。对于5个...
图论的学习
02-13
图论的练习。
图论简明教程
01-11
图论是一门应用范围非常广泛的科学，本书针对初学者编写，采用实例、示意图、课后练习等手段，逐步揭示图论中的典型问题，解决策略以及重要应用。
程序员的数学4：图论入门.pptx
10-14
《程序员的数学4：图论入门》是一本非常适合程序员阅读的数学书籍，它介绍了图论的基本概念和应用，并提供了很多实例和练习题帮助读者理解和应用所学知识。这本书不仅可以提高程序员的数学素养，还可以帮助程序员更...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值