PKU ACM 1087(A Plug for UNIX)的两种解法：最大流和最大二分匹配(JAVA实现)

最新推荐文章于 2024-06-12 10:00:23 发布
最新推荐文章于 2024-06-12 10:00:23 发布
阅读量112 收藏
点赞数
文章标签： Java Unix J# 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heweirick/article/details/83742525
版权

最大流算法(Shortest Augmenting Path)：

 

package problem1087;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class MainMaxFlow_SAP {
		
	static int recptNum;
	static int [] recpt;
	static int deviceNum;
	static int [] device;
	static int adapterNum;
	static int typeNum;
	static int nodeNum;
	static int pluggedIn = 0;
	static int [] prev;
	static int [][] capaMat;
	static final int INFINITE = 100000;
	static ArrayList<String> type = new ArrayList<String>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		
		recptNum = scanner.nextInt();
		recpt = new int[recptNum];
		String s = scanner.nextLine();
		for(int i = 0; i < recptNum; i++)
		{
			s = scanner.nextLine().trim();
			recpt[i] = findType(s);
		}
		
		deviceNum = scanner.nextInt();
		device = new int[deviceNum];
		
		s = scanner.nextLine();
		for(int i = 0; i < deviceNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			device[i] = findType(temp[1]);
		}
		
		adapterNum = scanner.nextInt();
		s = scanner.nextLine();
		int [] indexArr = new int[2  * adapterNum];
		
		for(int i = 0; i < adapterNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			
			indexArr[2 * i] = findType(temp[0]);
			indexArr[2 * i + 1] = findType(temp[1]);
		}
		
		typeNum = type.size();
		nodeNum = 2 + typeNum + deviceNum;//s, typeNum, deviceNum, t		
		capaMat = new int[nodeNum][nodeNum];
		prev = new int[nodeNum];
		
		initCapaMat(indexArr);
		SAP();
		
		System.out.println(deviceNum - pluggedIn);
	}
	
	static int findType(String s)
	{
		if(type.contains(s))
			return type.indexOf(s);
		else
		{
			type.add(s);
			return type.size() - 1;
		}
	}
	
	static void initCapaMat(int [] indexArr)
	{		
		for(int i = 0; i < nodeNum; i++)
		{
			for(int j = 0; j < nodeNum; j++)
				capaMat[i][j] = 0;
		}
		
		//from t to all receptacles
		for(int i = 0; i < recptNum; i++)
		{
			capaMat[0][1 + recpt[i]]++;
		}
		
		//from all devices to t && from receptacles to devices
		for(int i = 0; i < deviceNum; i++)
		{
			capaMat[1 + device[i]][1 + typeNum + i] = INFINITE;
			capaMat[1 + typeNum + i][nodeNum - 1] = 1;			
		}
		
		//conversion from one receptacle to another
		for(int i = 0; i < adapterNum; i++)
		{
			capaMat[1 + indexArr[2 * i + 1]][1 + indexArr[2 * i]] = INFINITE;
		}
	}
	
	static void SAP()
	{		
		 while(true)
		 {
			 int augmented = BFS();
			 if(augmented == 0)
				 break;
			 else				 
				 augment(augmented);
		 }
	}
	
	static void augment(int augmented)
	{
		pluggedIn += augmented;
		int startIndex = prev[nodeNum - 1];
		int endIndex = nodeNum - 1;
		while(true)
		{
			capaMat[startIndex][endIndex] -= augmented;
			capaMat[endIndex][startIndex] += augmented;
			
			if(startIndex == 0)
				return;
			
			endIndex = startIndex;
			startIndex = prev[startIndex];
		}
	}
	
	static int BFS()
	{
		int augmented = 0;
		
		resetPrev();
		LinkedList<Integer> queue = new LinkedList<Integer>();
		queue.addLast(0);
		
		while(queue.size() > 0)
		{
			int fromIndex = queue.remove();
			for(int i = 0; i < nodeNum; i++)
			{
				if((capaMat[fromIndex][i] > 0 ) && prev[i] == -1)
				{					
					queue.addLast(i);
					prev[i] = fromIndex;
					if(augmented == 0)
						augmented = capaMat[fromIndex][i];
					else
						augmented = Math.min(augmented, capaMat[fromIndex][i]);
					if(i == nodeNum - 1)
						return augmented;
				}
			}
		}
		return 0;
	}
	
	static void resetPrev()
	{
		for(int i = 0; i < prev.length; i++)
			prev[i] = -1;
	}
}

最大流算法(Improved Shortest Augmenting Path)：

package problem1087;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class MainMaxFlow_ISAP {
		
	static int recptNum;
	static int [] recpt;
	static int deviceNum;
	static int [] device;
	static int adapterNum;
	static int typeNum;
	static int nodeNum;
	static int pluggedIn = 0;
	static int [] prev;
	static int [] d;
	static int [] currentArc;
	static int [][] capaMat;
	static int currentNode;	
	static final int INFINITE = 100000;
	static ArrayList<String> type = new ArrayList<String>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		
		recptNum = scanner.nextInt();
		recpt = new int[recptNum];
		String s = scanner.nextLine();
		for(int i = 0; i < recptNum; i++)
		{
			s = scanner.nextLine().trim();
			recpt[i] = findType(s);
		}
		
		deviceNum = scanner.nextInt();
		device = new int[deviceNum];
		
		s = scanner.nextLine();
		for(int i = 0; i < deviceNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			device[i] = findType(temp[1]);
		}
		
		adapterNum = scanner.nextInt();
		s = scanner.nextLine();
		int [] indexArr = new int[2  * adapterNum];
		
		for(int i = 0; i < adapterNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			
			indexArr[2 * i] = findType(temp[0]);
			indexArr[2 * i + 1] = findType(temp[1]);
		}
		
		typeNum = type.size();
		nodeNum = 2 + typeNum + deviceNum;//s, typeNum, deviceNum, t		
		capaMat = new int[nodeNum][nodeNum];
		prev = new int[nodeNum];
		d = new int[nodeNum];
		currentArc = new int[nodeNum];
		
		initCapaMat(indexArr);
		ISAP();
		
		System.out.println(deviceNum - pluggedIn);
	}
	
	static int findType(String s)
	{
		if(type.contains(s))
			return type.indexOf(s);
		else
		{
			type.add(s);
			return type.size() - 1;
		}
	}
	
	static void initCapaMat(int [] indexArr)
	{		
		for(int i = 0; i < nodeNum; i++)
		{
			for(int j = 0; j < nodeNum; j++)
				capaMat[i][j] = 0;
		}
		
		//from t to all receptacles
		for(int i = 0; i < recptNum; i++)
		{
			capaMat[0][1 + recpt[i]]++;
		}
		
		//from all devices to t && from receptacles to devices
		for(int i = 0; i < deviceNum; i++)
		{
			capaMat[1 + device[i]][1 + typeNum + i] = INFINITE;
			capaMat[1 + typeNum + i][nodeNum - 1] = 1;			
		}
		
		//conversion from one receptacle to another
		for(int i = 0; i < adapterNum; i++)
		{
			capaMat[1 + indexArr[2 * i + 1]][1 + indexArr[2 * i]] = INFINITE;
		}
	}
	
	static void ISAP()
	{		
		currentNode = 0;
		for(int i = 0; i < nodeNum; i++)
		{
			currentArc[i] = 1;
		}
		resetPrev();		
		revBFS();
		
		while(d[0] < nodeNum)
		{
			int i;
			for(i = currentArc[currentNode]; i < nodeNum; i++)
			{
				if(d[currentNode] - d[i] == 1 && capaMat[currentNode][i] > 0)
				{
					break;
				}
			}
			if(i < nodeNum)
			{
				currentArc[currentNode] = i;
				advance(i);
				if(currentNode == nodeNum - 1)
				{
					augment();
					currentNode = 0;
				}
			}
			else
			{
				currentArc[currentNode] = 1;
				retreat();
			}
		}
	}
	
	private static void retreat() {
		d[currentNode] = nodeNum;
		for(int i = 0; i < nodeNum; i++)
		{
			if(capaMat[currentNode][i] > 0)
			{
				d[currentNode] = Math.min(d[currentNode], d[i] + 1);
			}
		}
		if(currentNode != 0)
		{
			currentNode = prev[currentNode];
		}
	}
	
	private static void advance(int nextNode) {
		prev[nextNode] = currentNode;
		currentNode = nextNode;
	}

	static void augment()
	{
		int startIndex = prev[nodeNum - 1];
		int endIndex = nodeNum - 1;		
		int min = INFINITE + 1;
		
		while(true)
		{
			min = Math.min(min, capaMat[startIndex][endIndex]);
						
			if(startIndex == 0)
				break;
			
			endIndex = startIndex;
			startIndex = prev[startIndex];
		}
		
		pluggedIn += min;
		startIndex = prev[nodeNum - 1];
		endIndex = nodeNum - 1;
		
		while(true)
		{
			capaMat[startIndex][endIndex] -= min;
			capaMat[endIndex][startIndex] += min;
						
			if(startIndex == 0)
				break;
			
			endIndex = startIndex;
			startIndex = prev[startIndex];
		}
	}
	
	static void revBFS()
	{
		for(int i = 0; i < nodeNum; i++)
			d[i] = nodeNum;
		
		d[nodeNum - 1] = 0;
		LinkedList<Integer> queue = new LinkedList<Integer>();
		queue.addLast(nodeNum - 1);
		
		while(queue.size() > 0)
		{
			int fromIndex = queue.remove();
			for(int i = 0; i < nodeNum; i++)
			{
				if((capaMat[i][fromIndex] > 0) && (d[i] == nodeNum))
				{
					d[i] = d[fromIndex] + 1;
					queue.addLast(i);
				}
			}
		}
	}
	
	static void resetPrev()
	{
		for(int i = 0; i < prev.length; i++)
			prev[i] = -1;
	}
} 

 

最大二分匹配：

 

package problem1087;
import java.util.ArrayList;
import java.util.Scanner;

public class MainMaximalMatching {
		
	static int recptNum;
	static int [] recpt;
	static int deviceNum;
	static int [] device;
	static boolean [] used;
	static int [] link;
	static int typeNum;
	static int [][] connMat;
	static ArrayList<String> type = new ArrayList<String>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		
		recptNum = scanner.nextInt();
		recpt = new int[recptNum];
		String s = scanner.nextLine();
		for(int i = 0; i < recptNum; i++)
		{
			s = scanner.nextLine().trim();
			recpt[i] = findType(s);
		}
		
		deviceNum = scanner.nextInt();
		device = new int[deviceNum];
		used = new boolean[deviceNum];
		link = new int[deviceNum];
		
		s = scanner.nextLine();
		for(int i = 0; i < deviceNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			device[i] = findType(temp[1]);
		}
		
		int adapterNum = scanner.nextInt();
		s = scanner.nextLine();
		int [] indexArr = new int[2  * adapterNum];
		
		for(int i = 0; i < adapterNum; i++)
		{
			s = scanner.nextLine().trim();
			String [] temp = s.split(" ");
			
			indexArr[2 * i] = findType(temp[0]);
			indexArr[2 * i + 1] = findType(temp[1]);
		}
		
		buildConnMat();
		for(int i = 0; i < adapterNum; i++)
		{
			int recptIndex = indexArr[2 * i];
			int plugIndex = indexArr[2 * i + 1];
			connMat[plugIndex][recptIndex] = 1;
		}
		
		FloydWarshall();
		
		Hungary();
		
		int ctr = 0;
		for(int i = 0; i < deviceNum; i++)
		{
			if(link[i] == -1)
				ctr++;
		}
		System.out.println(ctr);
	}
	
	static int findType(String s)
	{
		if(type.contains(s))
			return type.indexOf(s);
		else
		{
			type.add(s);
			return type.size() - 1;
		}
	}
	
	static void Hungary()
	{
		for(int i = 0; i < deviceNum; i++)
		{
			link[i] = -1;
		}
		for(int i = 0; i < recptNum; i++)
		{
			for(int j = 0; j < deviceNum; j++)
				used[j] = false;
			
			findPath(i);
		}
	}
	
	static boolean findPath(int index)
	{
		for(int i = 0; i < deviceNum; i++)
		{
			if(connMat[recpt[index]][device[i]] == 1 && !used[i])
			{
				used[i] = true;
				if(link[i] == -1 || findPath(link[i]))
				{
					link[i] = index;
					return true;
				}
			}
		}
		
		return false;
	}
	
	static void FloydWarshall()
	{
		for(int k = 1; k < typeNum; k++)
		{			
			for(int i = 0; i < typeNum; i++)
			{
				if(connMat[i][k] == 0)
					continue;
				for(int j = 0; j < typeNum; j++)
				{
					if(connMat[k][j] == 0)
						continue;
					connMat[i][j] = 1;
				}
			}
		}
	}
	
	static void buildConnMat()
	{
		typeNum = type.size();
		connMat = new int[typeNum][typeNum];
		for(int i = 0; i < typeNum; i++)
		{
			for(int j = 0; j < typeNum; j++)
			{
				if(i == j)
					connMat[i][j] = 1;
				else
					connMat[i][j] = 0;
			}
		}
	}
}
heweirick
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图的匹配问题与最大流问题（三）——最大流问题Ford-Fulkerson方法Java实现
smartxxyx的专栏
07-10 1万+
上篇文章主要介绍了Ford-Fulkerson方法的理论基础，本篇给出一种Java的实现。改写一下，原来的太冗余了。
ford-fulkerson算法求网络最大流(java实现)
12-10
采用ford-fulkerson算法计算网络最大流，java语言实现
java8 stream 最大值_JDK8-Stream流常用方法
weixin_39654322的博客
02-25 4842
Stream流的使用流操作是Java8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的 API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引入到Java中，能 让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，...
网络流模板 Dinic ISAP HLPP 最小费用最大流 最小割 建图技巧
xiji333的博客
10-30 674
参考博客： https://blog.csdn.net/Calix_Guo/article/details/80554268 最大流模板： #include<iostream> #include<cstdio> #include<cstring> #include<queue> #define INF 0x3f3f3f3f using namespa...
最大流，最小割，二分匹配，题目列表
Grit_ICPC的博客
10-04 599
转自：http://blog.csdn.net/shahdza/article/details/7779537 【HDU】 1532 Drainage Ditches(入门)    [最大流] 3549 Flow Problem(入门)    [最大流] 3572 Task Schedule(基础)    [最大流]任务分配,判断满流 2732 Leapin' Liza
pku acm 题目分类
moxiaomomo的专栏
09-27 1662
1.搜索　//回溯2.DP（动态规划）　3.贪心　北大ACM题分类2009-01-27 14.图论　//Dijkstra、最小生成树、网络流5.数论　//解模线性方程6.计算几何　//凸壳、同等安置矩形的并的面积与周长sp; 7.组合数学　//Polya定理8.模拟　9.数据结构　//并查集、堆sp; 10.博弈论　1、 排序sp; 1423, 1694, 1723, 1727, 1763, 1788, 1828, 1838, 1840, 2201, 2376, 2377, 2380, 1318, 1877
acm之pku题目分类
09-25 962
acm之pku题目分类 对ACM有兴趣的同学们可以看看 DP:  1011   NTA                 简单题  1013   Great Equipment     简单题  1024   Calendar Game       简单题  1027   Human Gene Functions   简单题  1037   Gridland           
ACM PKU 题目分类(完整整理版本)
保持对编程的热情！
03-06 3411
DP:  1011   NTA                 简单题  1013   Great Equipment     简单题  1024   Calendar Game       简单题  1027   Human Gene Functions   简单题  1037   Gridland            简单题  1052   Algernon s Noxi
ACM PKU　题目分类(完整整理版本)
ddj0002的博客
02-04 545
DP:1011 NTA 简单题1013 Great Equipment 简单题1024 Calendar Game 简单题1027 Human Gene Functions 简单题1037 Gridland 简单题1052 Algernon s Noxious Emissio...
PKU+ACM.rar_ACM_PKU_acm pku_acm 北大_site:www.pudn.com
09-21
实在没什么好东西，就找了以前在北大ACM上做的一些题 比较适合于初学程序设计和算法的同学
ACM.rar_ACM_ACM Hwang .p_ACM java_pku 1689 rubbery_ppt
09-19
ACM的重要PPT资料,对初学者非常有益处
ACM.rar_PKU_acm pku_pku 1709 crossword_pku acm_visual c
09-14
PKU ACM大量题目的源代码,具有学习价值
acm_pku_code.zip_Code p_acm pku_acm pku pu_acm.pku_pku acm
09-23
acmer pku入门题 初学acm和大一学生适合 附原题
PKU-ACM.rar_PKU_acm 题目
09-21
北大ACM生命周期题目的经典解法。 北大ACM生命周期题目的经典解法。 北大ACM生命周期题目的经典解法。
（转）acm之pku题目分类
wadefall的专栏
10-18 238
acm之pku题目分类 对ACM有兴趣的同学们可以看看 DP: 1011 NTA 简单题 1013 Great Equipment 简单题 1024 Calendar Game 简单题 1027 Human Gene Functions 简单题 1037 Gridland 简单...
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 482
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 392
【代码】力扣LCP 08.剧情触发时间。
day31||第八章 贪心算法 part01● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和
xburner01的博客
06-09 249
思路没问题，代码仔细想想吧。尽可能把大饼干给大胃口的人，先排序是关键。
做不同商品的销售量的可视化输出。要求：选择两种统计图分别完成
06-11
您可以使用下面两种常见的统计图来可视化不同商品的销售量。 1. 条形图 条形图适用于比较不同类别之间的数量或频率。您可以按照以下步骤创建条形图： - 在 x 轴上放置商品名称，y 轴表示销售量。 - 在图表中添加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值