hihocoder 1181 : 欧拉路·二

最新推荐文章于 2018-09-04 11:26:20 发布

zs709379096

最新推荐文章于 2018-09-04 11:26:20 发布

阅读量285

点赞数

分类专栏： ACM

本文链接：https://blog.csdn.net/zs709379096/article/details/77161998

版权

ACM 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

在上一回中小Hi和小Ho控制着主角收集了分散在各个木桥上的道具，这些道具其实是一块一块骨牌。

主角继续往前走，面前出现了一座石桥，石桥的尽头有一道火焰墙，似乎无法通过。

小Hi注意到在桥头有一张小纸片，于是控制主角捡起了这张纸片，只见上面写着：

将M块骨牌首尾相连放置于石桥的凹糟中，即可关闭火焰墙。切记骨牌需要数字相同才能连接。
——By 无名的冒险者

小Hi和小Ho打开了主角的道具栏，发现主角恰好拥有M快骨牌。

小Ho：也就是说要把所有骨牌都放在凹槽中才能关闭火焰墙，数字相同是什么意思？

小Hi：你看，每一块骨牌两端各有一个数字，大概是只有当数字相同时才可以相连放置，比如：

小Ho：原来如此，那么我们先看看能不能把所有的骨牌连接起来吧。

提示：Fleury算法求欧拉路径

输入

第1行：2个正整数，N,M。分别表示骨牌上出现的最大数字和骨牌数量。1≤N≤1,000，1≤M≤5,000

第2..M+1行：每行2个整数，u,v。第i+1行表示第i块骨牌两端的数字(u,v)，1≤u,v≤N

输出

第1行：m+1个数字，表示骨牌首尾相连后的数字

比如骨牌连接的状态为(1,5)(5,3)(3,2)(2,4)(4,3)，则输出"1 5 3 2 4 3"

你可以输出任意一组合法的解。

样例输入

样例输出

1 5 3 4 2 3

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

public class Main {
	//Fluery算法
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int num=scan.nextInt();
		int[][] map=new int[num][num];
		int cc=scan.nextInt();
		int start=0;
		for(int i=0;i<cc;i++){
			int x=scan.nextInt()-1;
			int y=scan.nextInt()-1;
			map[x][y]++;
			map[y][x]++;
		}
		int nn=0;
		for(int i=0;i<num;i++){
			int count=0;
			for(int j=0;j<num;j++){
				if(map[i][j]>0) count+=map[i][j];
			}
			if(count%2==1){
				nn++;
				start=i;
			} 
		}
		if(nn!=2&&nn!=0){
			System.out.println("no urler");
		}else{
			List<Integer> re=flery(start,map);
			for(int i=0;i<re.size();i++){
				System.out.print(re.get(i)+1+" ");
			}
		}
	}
	private static List<Integer> flery(int start,int[][] map) {
		List<Integer> re=new ArrayList<Integer>();
		Stack<Integer> stack=new Stack<Integer>();
		stack.push(start);
		while(!stack.isEmpty()){
			boolean hasBridge=false;
			for(int i=0;i<map.length;i++){
				if(map[stack.peek()][i]>0){
					hasBridge=true;break;
				}
			}
			if(!hasBridge){
				re.add(0,stack.pop());
			}else{
				dfs(stack.pop(),stack,map);
			}
		}
		return re;
	}
	
	public static void dfs(int start,Stack<Integer> stack,int[][] map){
		stack.push(start);
		for(int i=0;i<map.length;i++){
			if(map[start][i]>0){
				map[start][i]--;
				map[i][start]--;
				dfs(i,stack,map);
				break;
			}
		}
	}
}
/*
5 5
1 2
2 5
2 4
4 3
3 2
*/

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class Main2 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int num=scan.nextInt();
		int[] degree=new int[num+1];
		int count=scan.nextInt();
		HashMap<Integer,LinkedList<Integer>> map=new HashMap<>();
		for(int i=1;i<=num;i++) map.put(i,new LinkedList<Integer>());
		for(int i=0;i<count;i++){
			int x=scan.nextInt();
			int y=scan.nextInt();
			degree[x]++;degree[y]++;
			map.get(x).add(y);
			map.get(y).add(x);
		}
		int start=1;
		for(int i=1;i<=num;i++){
			if(degree[i]%2==1){
				start=i;break;
			}
		}
		List<Integer> re=fluery(map,start);
		for(Integer a:re){
			System.out.print(a+" ");
		}
	}
	private static List<Integer> fluery(HashMap<Integer, LinkedList<Integer>> map, int start) {
		List<Integer> re=new LinkedList<Integer>();
		if(map.isEmpty()) return re;
		dfs(map,start,re);
	    return re;
	}
	
	public static void dfs(HashMap<Integer,LinkedList<Integer>> map,int start,List<Integer> re){
		while(!map.get(start).isEmpty()){
			LinkedList<Integer> list=map.get(start);
			Integer a=list.remove(0);
			if(list.size()==0) map.remove(list);
			map.get(a).remove((Integer)start);
			if(map.get(a).isEmpty()) map.remove(map.get(a));
			dfs(map,a,re);
		}
		re.add(0,start);
	}
}