ACM HDOJ 1045 (Fire Net)

最新推荐文章于 2018-06-17 21:21:00 发布
最新推荐文章于 2018-06-17 21:21:00 发布
阅读量766 收藏 1
点赞数
分类专栏： ACM 图论 二分图 搜索技术 深度优先搜索 文章标签： ACM HDOJ 1045 JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cathaypoplar/article/details/18187177
版权
ACM 同时被 3 个专栏收录
49 篇文章 0 订阅
订阅专栏
图论
24 篇文章 0 订阅
订阅专栏
二分图
7 篇文章 0 订阅
订阅专栏

题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=1045

思路一 深度优先搜索

这个应该最容易想到了，从左上开始，按列搜索，到右下结束，具体的搜索顺序如下图


思路二 二分图的最大匹配

 一行拆成多行，一列拆成多列
 以下图为例
.X..
 ....
XX..
....

按行排号（左集）
1X22
3333
XX44
5555
 
按列排号（右集）
1X56
1356
XX56
2456

找到左集和右集中有交叉的情况
左 -> 右
1 -> 1
2 -> 5
2 -> 6
3 -> 1
3 -> 3
3 -> 5
3 -> 6
4 -> 5
4 -> 6
5 -> 2
5 -> 4
5 -> 5
5 -> 6

然后二分匹配，得到最大匹配为
1 -> 1
2 -> 5
3 -> 3
4 -> 6
5 -> 2

则放置碉堡的结果就是
OXO.
.O..
XX.O
O...

程序一 深度优先搜索

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		while (scn.hasNext()) {
			int height = Integer.parseInt(scn.next());
			int width = height;
			if (0 == height) {
				break;
			}
			Search search = new Search(height, width, 0, 0);
			for (int i = 0; i < height; ++i) {
				search.setMatrixLine(i, scn.next().toCharArray());
			}
			search.beginSearch();
			System.out.println(search.getMaxNumber());
		}
		scn.close();
	}

}

class Search {

	private int height;
	private int width;
	private char[][] matrix;
	private int startX;
	private int startY;
	private int maxNumber;

	public Search(int height, int width, int startX, int startY) {
		this.height = height;
		this.width = width;
		matrix = new char[height][width];
		this.startX = startX;
		this.startY = startY;
		maxNumber = 0;
	}

	public void beginSearch() {
		dfs(startX, startY, 0);
	}

	private void dfs(int x, int y, int number) {
		if (x == height - 1 && y == width - 1) {
			if ('.' == matrix[x][y] && isValid(x, y)) {
				++number;
			}
			if (number > maxNumber) {
				maxNumber = number;
			}
			return;
		}
		if ('X' == matrix[x][y] || !isValid(x, y)) {
			if (y < width - 1) {
				dfs(x, y + 1, number);
			} else {
				dfs(x + 1, 0, number);
			}
		} else {
			matrix[x][y] = '*';
			if (y < width - 1) {
				dfs(x, y + 1, number + 1);
			} else {
				dfs(x + 1, 0, number + 1);
			}
			matrix[x][y] = '.';
			if (y < width - 1) {
				dfs(x, y + 1, number);
			} else {
				dfs(x + 1, 0, number);
			}
		}
		return;
	}

	private boolean isValid(int x, int y) {
		for (int i = x - 1; i >= 0; --i) {
			if ('X' == matrix[i][y]) {
				break;
			}
			if ('*' == matrix[i][y]) {
				return false;
			}
		}
		for (int j = y - 1; j >= 0; --j) {
			if ('X' == matrix[x][j]) {
				break;
			}
			if ('*' == matrix[x][j]) {
				return false;
			}
		}
		return true;
	}

	public void setMatrixLine(int line, char[] ch) {
		matrix[line] = ch;
	}

	public int getMaxNumber() {
		return maxNumber;
	}

}

程序二 匈牙利算法 DFS

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		while (scn.hasNext()) {
			int height = Integer.parseInt(scn.next());
			int width = height;
			if (0 == height) {
				break;
			}
			char[][] city = new char[height][width];
			int[][] left = new int[height][width];
			for (int i = 0; i < height; ++i) {
				city[i] = scn.next().toCharArray();
			}
			int leftSetNumber = 0;
			for (int i = 0; i < height; ++i) { // 按行
				if ('.' == city[i][0]) {
					left[i][0] = ++leftSetNumber;
				} else {
					++leftSetNumber;
				}
				boolean flag = true;
				for (int j = 1; j < width; ++j) {
					if ('.' == city[i][j]) {
						if (flag) {
							left[i][j] = leftSetNumber;
						} else {
							left[i][j] = ++leftSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			int rightSetNumber = 0;
			int[][] right = new int[height][width];
			for (int j = 0; j < height; ++j) { // 按列
				if ('.' == city[0][j]) {
					right[0][j] = ++rightSetNumber;
				} else {
					++rightSetNumber;
				}
				boolean flag = true;
				for (int i = 1; i < width; ++i) {
					if ('.' == city[i][j]) {
						if (flag) {
							right[i][j] = rightSetNumber;
						} else {
							right[i][j] = ++rightSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			Hungary hungary = new Hungary(leftSetNumber, rightSetNumber);
			for (int i = 0; i < height; ++i) {
				for (int j = 0; j < width; ++j) {
					if (0 != left[i][j] && 0 != right[i][j]) {
						hungary.addEdge(left[i][j] - 1, right[i][j] - 1);
					}
				}
			}
			System.out.println(hungary.maxMatch());
		}
		scn.close();
	}

}

class Hungary {

	private int leftSetNumber;
	private int rightSetNumber;
	private boolean[][] matrix;
	private int[] leftResult;
	private int[] rightResult;
	private boolean[] rightUsed;

	private boolean searchPath(int left) {
		for (int right = 0; right < rightSetNumber; ++right) {
			if (matrix[left][right] && !rightUsed[right]) {
				rightUsed[right] = true;
				if (-1 == rightResult[right] || searchPath(rightResult[right])) {
					rightResult[right] = left;
					leftResult[left] = right;
					return true;
				}
			}
		}
		return false;
	}

	public Hungary(int leftSetNumber, int rightSetNumber) {
		this.leftSetNumber = leftSetNumber;
		this.rightSetNumber = rightSetNumber;
		matrix = new boolean[leftSetNumber][rightSetNumber];
		leftResult = new int[leftSetNumber];
		rightResult = new int[rightSetNumber];
		rightUsed = new boolean[rightSetNumber];
	}

	public void addEdge(int left, int right) {
		matrix[left][right] = true;
	}

	public int maxMatch() {
		Arrays.fill(leftResult, -1);
		Arrays.fill(rightResult, -1);
		Arrays.fill(rightUsed, false);
		int count = 0;
		for (int left = 0; left < leftSetNumber; ++left) {
			if (-1 == leftResult[left]) {
				Arrays.fill(rightUsed, false);
				if (searchPath(left)) {
					++count;
				}
			}
		}
		return count;
	}

}

程序三 匈牙利算法 BFS

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		while (scn.hasNext()) {
			int height = Integer.parseInt(scn.next());
			int width = height;
			if (0 == height) {
				break;
			}
			char[][] city = new char[height][width];
			int[][] left = new int[height][width];
			for (int i = 0; i < height; ++i) {
				city[i] = scn.next().toCharArray();
			}
			int leftSetNumber = 0;
			for (int i = 0; i < height; ++i) { // 按行
				if ('.' == city[i][0]) {
					left[i][0] = ++leftSetNumber;
				} else {
					++leftSetNumber;
				}
				boolean flag = true;
				for (int j = 1; j < width; ++j) {
					if ('.' == city[i][j]) {
						if (flag) {
							left[i][j] = leftSetNumber;
						} else {
							left[i][j] = ++leftSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			int rightSetNumber = 0;
			int[][] right = new int[height][width];
			for (int j = 0; j < height; ++j) { // 按列
				if ('.' == city[0][j]) {
					right[0][j] = ++rightSetNumber;
				} else {
					++rightSetNumber;
				}
				boolean flag = true;
				for (int i = 1; i < width; ++i) {
					if ('.' == city[i][j]) {
						if (flag) {
							right[i][j] = rightSetNumber;
						} else {
							right[i][j] = ++rightSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			Hungary hungary = new Hungary(leftSetNumber, rightSetNumber);
			for (int i = 0; i < height; ++i) {
				for (int j = 0; j < width; ++j) {
					if (0 != left[i][j] && 0 != right[i][j]) {
						hungary.addEdge(left[i][j] - 1, right[i][j] - 1);
					}
				}
			}
			System.out.println(hungary.maxMatch());
		}
		scn.close();
	}

}

class Hungary {

	private int leftSetNumber;
	private int rightSetNumber;
	private boolean[][] matrix;
	private int[] leftResult;
	private int[] rightResult;
	private boolean[] rightUsed;
	private int[] preLeft;

	public Hungary(int leftSetNumber, int rightSetNumber) {
		this.leftSetNumber = leftSetNumber;
		this.rightSetNumber = rightSetNumber;
		matrix = new boolean[leftSetNumber][rightSetNumber];
		leftResult = new int[leftSetNumber];
		rightResult = new int[rightSetNumber];
		rightUsed = new boolean[rightSetNumber];
		preLeft = new int[leftSetNumber];
	}

	public void addEdge(int left, int right) {
		matrix[left][right] = true;
	}

	public int maxMatch() {
		Arrays.fill(leftResult, -1);
		Arrays.fill(rightResult, -1);
		Arrays.fill(preLeft, -1);
		int count = 0;
		for (int i = 0; i < leftSetNumber; ++i) {
			if (-1 == leftResult[i]) {
				Queue<Integer> queue = new LinkedList<Integer>();
				queue.offer(i);
				boolean hasAP = false;
				Arrays.fill(rightUsed, false);
				while (!queue.isEmpty() && !hasAP) {
					int left = queue.poll();
					for (int right = 0; right < rightSetNumber && !hasAP; ++right) {
						if (matrix[left][right] && !rightUsed[right]) {
							rightUsed[right] = true;
							queue.offer(rightResult[right]);
							if (0 <= rightResult[right]) {
								preLeft[rightResult[right]] = left;
							} else {
								hasAP = true;
								int currentLeft = left;
								int currentRight = right;
								while (-1 != currentLeft) {
									int lastRight = leftResult[currentLeft];
									leftResult[currentLeft] = currentRight;
									rightResult[currentRight] = currentLeft;
									currentLeft = preLeft[currentLeft];
									currentRight = lastRight;
								}
							}
						}
					}
				}
				if (-1 != leftResult[i]) {
					++count;
				}
			}
		}
		return count;
	}

}

程序四 Hopcroft-Carp 算法

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		while (scn.hasNext()) {
			int height = Integer.parseInt(scn.next());
			int width = height;
			if (0 == height) {
				break;
			}
			char[][] city = new char[height][width];
			int[][] left = new int[height][width];
			for (int i = 0; i < height; ++i) {
				city[i] = scn.next().toCharArray();
			}
			int leftSetNumber = 0;
			for (int i = 0; i < height; ++i) { // 按行
				if ('.' == city[i][0]) {
					left[i][0] = ++leftSetNumber;
				} else {
					++leftSetNumber;
				}
				boolean flag = true;
				for (int j = 1; j < width; ++j) {
					if ('.' == city[i][j]) {
						if (flag) {
							left[i][j] = leftSetNumber;
						} else {
							left[i][j] = ++leftSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			int rightSetNumber = 0;
			int[][] right = new int[height][width];
			for (int j = 0; j < height; ++j) { // 按列
				if ('.' == city[0][j]) {
					right[0][j] = ++rightSetNumber;
				} else {
					++rightSetNumber;
				}
				boolean flag = true;
				for (int i = 1; i < width; ++i) {
					if ('.' == city[i][j]) {
						if (flag) {
							right[i][j] = rightSetNumber;
						} else {
							right[i][j] = ++rightSetNumber;
							flag = true;
						}
					} else {
						flag = false;
					}
				}
			}
			HopcroftCarp hopcroftCarp = new HopcroftCarp(leftSetNumber,
					rightSetNumber);
			for (int i = 0; i < height; ++i) {
				for (int j = 0; j < width; ++j) {
					if (0 != left[i][j] && 0 != right[i][j]) {
						hopcroftCarp.addEdge(left[i][j] - 1, right[i][j] - 1);
					}
				}
			}
			System.out.println(hopcroftCarp.maxMatch());
		}
		scn.close();
	}

}

class HopcroftCarp {

	private final int INF = Integer.MAX_VALUE / 2;
	private int leftSetNumber;
	private int rightSetNumber;
	private boolean[][] matrix;
	private int[] leftResult;
	private int[] rightResult;
	private boolean[] rightUsed;
	private int[] leftGradation;
	private int[] rightGradation;
	private int gradation;

	private boolean searchPath() {
		Arrays.fill(leftGradation, -1);
		Arrays.fill(rightGradation, -1);
		gradation = INF;
		Queue<Integer> queue = new LinkedList<Integer>();
		for (int left = 0; left < leftSetNumber; ++left) {
			if (-1 == leftResult[left]) {
				queue.offer(left);
				++leftGradation[left];
			}
		}
		while (!queue.isEmpty()) {
			int left = queue.poll();
			if (leftGradation[left] > gradation) {
				break;
			}
			for (int right = 0; right < rightSetNumber; ++right) {
				if (matrix[left][right] && -1 == rightGradation[right]) {
					rightGradation[right] = leftGradation[left] + 1;
					if (-1 == rightResult[right]) {
						gradation = rightGradation[right];
					} else {
						leftGradation[rightResult[right]] = rightGradation[right] + 1;
						queue.offer(rightResult[right]);
					}
				}
			}
		}
		return INF != gradation;
	}

	private boolean dfs(int left) {
		for (int right = 0; right < rightSetNumber; right++) {
			if (!rightUsed[right] && matrix[left][right]
					&& rightGradation[right] == leftGradation[left] + 1) {
				rightUsed[right] = true;
				if (-1 != rightResult[right]
						&& rightGradation[right] == gradation) {
					continue;
				}
				if (-1 == rightResult[right] || dfs(rightResult[right])) {
					rightResult[right] = left;
					leftResult[left] = right;
					return true;
				}
			}
		}
		return false;
	}

	public HopcroftCarp(int leftSetNumber, int rightSetNumber) {
		this.leftSetNumber = leftSetNumber;
		this.rightSetNumber = rightSetNumber;
		matrix = new boolean[leftSetNumber][rightSetNumber];
		leftResult = new int[leftSetNumber];
		rightResult = new int[rightSetNumber];
		rightUsed = new boolean[rightSetNumber];
		leftGradation = new int[leftSetNumber];
		rightGradation = new int[rightSetNumber];
		gradation = INF;
	}

	public void addEdge(int left, int right) {
		matrix[left][right] = true;
	}

	public int maxMatch() {
		Arrays.fill(leftResult, -1);
		Arrays.fill(rightResult, -1);
		int count = 0;
		while (searchPath()) {
			Arrays.fill(rightUsed, false);
			for (int left = 0; left < leftSetNumber; ++left) {
				if (-1 == leftResult[left] && dfs(left)) {
					++count;
				}
			}
		}
		return count;
	}

}

CathayPoplar
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浙大oj试题1045代码
07-30
自己写的代码，本人不才，如果发现错误，希望赐教
ACM HDOJ 课件
10-31
【ACM HDOJ 课件】是一套涵盖了多种计算机科学竞赛中常见算法与理论的教育资源，主要针对ACM（国际大学生程序设计竞赛）和HDOJ（华中地区大学生在线编程题库）的训练。这些课件深入浅出地讲解了在解决复杂问题时所需...
杭电ACM1045
执子之手
11-07 902
找的贪心的题目，开始总觉得用穷举法会不行，想不到好的算法，百度找找前辈们的AC，发现穷举法还是可以的，就参考了下 这题给出的图的行列范围较小，所以可以暴力来做。 要解决的问题就是怎样方便的枚举完所有可能的情况，并且得到放置blockhouse的最大值。 这要在dfs上下功夫了。 代码中的dfs原型为dfs(int i,int num)。其中 i  为记录该次搜索已经到达
【ACM】HDOJ 1045 Fire Net
Jerry的安乐说
10-04 872
HDOJ 1045 Fire Net Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 8273    Accepted Submission(s): 4753   题目描述： 一个n*n的地图，请安排blockhouse，要求在
HDOJ 1045 Fire Net
dzyhenry的专栏
04-26 689
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1045 题目大意：对于一个迷宫，其中’X’ 表示wall，‘.’表示空地，可以放置blockhouse，同一条直线上只能有一个blockhouse，除非有wall隔开，问在给出的图中最多能放置多少个blockhouse。   分析题意： 1、  此题有两种解法。第一种：暴力解法。从左往右，从上到
hdoj 1045 Fire Net 【DFS】
shengweisong
08-21 778
题意：如果两个点要放在同一行或者同一列，那么两个点中间要有一个墙，否则的话只能放一个点，最后问你最多能放几个点。 看了一个星期。。 这道题的解法我还是第一次见，就是逐个逐个的来放置每个点，然后每经过一个点都判断一次，详情看代码
[HDOJ1045]Fire Net
weixin_30580943的博客
08-23 73
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1045 Fire Net Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 8147Accepted Submission(s)...
HDU 1045 Fire Net【DFS深搜】
ACMer_Shadow的博客
07-13 1422
Fire Net Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 9880    Accepted Submission(s): 5739 Problem Description Suppose that we h
HDOJ 1045
XMzhou的专栏
04-09 855
Fire Net Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 4291    Accepted Submission(s): 2433 Problem Description Suppose that we h
【HDOJ1045】【DFS】
aiyuneng5167的博客
06-17 85
http://acm.hdu.edu.cn/status.php?user=MekakuCityActors&pid=1045&status=5 Fire Net Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s):...
杭电ACM HDOJ2000~2099 JAVA解题源码
05-28
《杭电ACM HDOJ2000~2099 JAVA解题源码解析》 编程竞赛，特别是ACM（国际大学生程序设计竞赛）是计算机科学领域中的一项重要活动，它锻炼了参赛者的算法设计、编程能力和问题解决能力。杭州电子科技大学（HDEU）的...
HDU.rar_hdoj 2000 2999 chm_hdoj 2000-2099_hdu_hdu acm 20_杭电ACM
最新发布
09-22
“HDOJ”通常指的是杭电的在线判题系统，是众多ACMer进行算法训练和比赛的重要平台。在这个平台上，题目编号通常从1000开始，按照顺序递增。本压缩包聚焦于2000到2099的题目，这些题目涵盖了基础到进阶的各种算法...
HDOJ ACM 课件 part1
02-06
HDOJ ACM 课件 适用于ACM初学者和考研复试者，特别是无良好基础者学习使用
杭电1045 fire net dfs入门
Salvation
03-13 421
题意是有n*n大小的地图，地图上点(.)代表空地，X代表防火墙，在地图上放置碉堡，碉堡可以横向或者竖向扫射，所以同一行或列上只能有一个碉堡，但是防火墙可以阻拦攻击，求最大能放置多少碉堡// HDOJ1042 fire net // 思维是主要靠深搜#include <iostream> using namespace std; int visit[5][5]; // visit数组是用来存放状
ACM HDOJ 2066 (一个人的旅行)
陈青杨
01-17 1114
题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=2066 思路 添加超级始点和超级终点，求超级始点到超级终点的最短路 程序一 dijkstra 算法 import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(S
ACM HDOJ 1026(Ignatius and the Princess I)
陈青杨
01-18 956
题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=1026 import java.util.PriorityQueue; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class Main { public static vo
ACM POJ 2001 (Shortest Prefixes)
陈青杨
01-19 956
题目链接 http://poj.org/problem?id=2001 import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scn = new
HDOJ ACM入门：从简单数学题到傻瓜型题目解析
"ACM入门课件02，国内著名HDOJ平台的基础训练，适合初学者，内容涵盖简单数学题和编程基础。" 本课件是针对ACM（国际大学生程序设计竞赛）入门学习者设计的，由杭州电子科技大学的刘春英老师主讲，通过电子邮件acm@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值