ACM ZOJ 1649 (Rescue)

最新推荐文章于 2019-07-07 04:49:19 发布
最新推荐文章于 2019-07-07 04:49:19 发布
阅读量979 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM 搜索技术 图论 最短路 广度优先搜索 文章标签： ACM ZOJ 1649 JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cathaypoplar/article/details/18425073
本文介绍了使用不同寻路算法解决迷宫问题的方法，包括宽度优先搜索(BFS)、迪杰斯特拉(Dijkstra)、贝尔曼-福特(Bellman-Ford)及SPFA算法。通过实例演示了每种算法的应用场景及其优缺点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目链接 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1649

思路一 广度优先搜索，用优先队列实现，从a开始，当遇到r时就停止搜索

思路二 转换成最短路问题，先用一个矩阵存储matrix输入的字符，然后遍历矩阵，找到两个相邻的点：如果两个点中有#，则距离为INF；如果有且仅有1个x，则距离为1.5；如果有两个x，则距离为2；其它情况，距离为1。建立一个超级终点，求a到超级终点的距离。

程序一 宽度优先搜索

import java.util.PriorityQueue;
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 = Integer.parseInt(scn.next());
			Search search = new Search(height, width);
			for (int i = 0; i < height; ++i) {
				String str = scn.next();
				search.setMatrixLine(i, str.toCharArray());
				int position = str.indexOf("a");
				if (-1 != position) {
					search.setStartX(i);
					search.setStartY(position);
				}
			}
			search.beginSearch();
		}
		scn.close();
	}

}

class Search {

	private final int[][] direction = { { -1, 0 }, { 1, 0 }, { 0, -1 },
			{ 0, 1 } };
	private int height;
	private int width;
	private char[][] matrix;
	private int startX;
	private int startY;

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

	public void beginSearch() {
		Queue<Node> queue = new PriorityQueue<Node>();
		queue.offer(new Node(startX, startY, 0));
		matrix[startX][startY] = '#';
		while (!queue.isEmpty()) {
			Node node = queue.poll();
			for (int k = 0; k < 4; ++k) {
				int nextX = node.getX() + direction[k][0];
				int nextY = node.getY() + direction[k][1];
				int nextTime = node.getTime() + 1;
				Node tmp = new Node(nextX, nextY, nextTime);
				if (0 > nextX || nextX >= height || 0 > nextY || nextY >= width
						|| '#' == matrix[nextX][nextY]) {
					continue;
				}
				if ('r' == matrix[nextX][nextY]) {
					System.out.println(nextTime);
					return;
				} else if ('x' == matrix[nextX][nextY]) {
					tmp.setTime(nextTime + 1);
				}
				queue.offer(tmp);
				matrix[nextX][nextY] = '#';
			}
		}
		System.out.println("Poor ANGEL has to stay in the prison all his life.");
	}

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

	public void setStartX(int startX) {
		this.startX = startX;
	}

	public void setStartY(int startY) {
		this.startY = startY;
	}

}

class Node implements Comparable<Node> {

	private int x;
	private int y;
	private int time;

	public Node(int x, int y, int time) {
		this.x = x;
		this.y = y;
		this.time = time;
	}

	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}

	public int getTime() {
		return time;
	}

	public void setTime(int time) {
		this.time = time;
	}

	@Override
	public int compareTo(Node node) {
		if (this.time != node.time) {
			return this.time - node.time;
		} else if (this.x != node.x) {
			return this.x - node.x;
		} else {
			return this.y - node.y;
		}
	}

}

程序二 dijkstra 优先队列优化算法

import java.util.Arrays;
import java.util.PriorityQueue;
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 = Integer.parseInt(scn.next());
			int pointsNumber = height * width + 2;
			int edgesNumber = 5 * width * height - 2 * (height + width);
			char[][] matrix = new char[height][width];
			for (int i = 0; i < height; i++) {
				matrix[i] = scn.next().toCharArray();
			}
			Dijkstra dijkstra = new Dijkstra(pointsNumber, edgesNumber);
			int initStart = -1;
			int initEnd = height * width + 1;
			for (int i = 0; i < height - 1; ++i) {
				for (int j = 0; j < width - 1; ++j) {
					int start = i * width + j + 1;
					int end = i * width + j + 1 + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i][j + 1]) {
							distance += 0.5;
						}
						dijkstra.addEdge(start, end, distance);
						dijkstra.addEdge(end, start, distance);
					}
					end = (i + 1) * width + j + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i + 1][j]) {
							distance += 0.5;
						}
						dijkstra.addEdge(start, end, distance);
						dijkstra.addEdge(end, start, distance);
					}
					if ('a' == matrix[i][j]) {
						initStart = i * width + j + 1;
					}
					if ('r' == matrix[i][j]) {
						dijkstra.addEdge(i * width + j + 1, initEnd, 0);
					}
				}
			}
			for (int i = height - 1, j = 0; j < width - 1; ++j) {
				int start = i * width + j + 1;
				int end = i * width + j + 1 + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i][j + 1]) {
						distance += 0.5;
					}
					dijkstra.addEdge(start, end, distance);
					dijkstra.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					dijkstra.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			for (int j = width - 1, i = 0; i < height - 1; ++i) {
				int start = i * width + j + 1;
				int end = (i + 1) * width + j + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i + 1][j]) {
						distance += 0.5;
					}
					dijkstra.addEdge(start, end, distance);
					dijkstra.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					dijkstra.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			if ('a' == matrix[height - 1][width - 1]) {
				initStart = height * width;
			}
			if ('r' == matrix[height - 1][width - 1]) {
				dijkstra.addEdge(height * width, initEnd, 0);
			}
			double distance = dijkstra.calculateDistance(initStart, initEnd);
			if (dijkstra.hasMinDistance()) {
				System.out.println(String.format("%.0f", distance));
			} else {
				System.out.println("Poor ANGEL has to stay in the prison all his life.");
			}
		}
		scn.close();
	}

}

class Dijkstra {

	private final double INF = Double.MAX_VALUE / 2;
	private int pointsNumber;
	private int edgesNumber;
	private double[] edgesDistance;
	private int[] edgesEnd;
	private int[] nextStart;
	private int[] startMax;
	private boolean[] visit;
	private double[] resultDistance;
	private int[] prePoint;
	private double resultMinDistance;

	public Dijkstra(int pointsNumber, int edgesNumber) {
		this.pointsNumber = pointsNumber;
		this.edgesNumber = 0;
		edgesDistance = new double[edgesNumber];
		edgesEnd = new int[edgesNumber];
		nextStart = new int[edgesNumber];
		startMax = new int[pointsNumber];
		Arrays.fill(startMax, -1);
		visit = new boolean[pointsNumber];
		resultDistance = new double[pointsNumber];
		prePoint = new int[pointsNumber];
		resultMinDistance = INF;
	}

	public void addEdge(int start, int end, double distance) {
		edgesDistance[edgesNumber] = distance;
		edgesEnd[edgesNumber] = end;
		nextStart[edgesNumber] = startMax[start];
		startMax[start] = edgesNumber++;
	}

	public double calculateDistance(int initStart, int initEnd) {
		Arrays.fill(visit, false);
		Arrays.fill(resultDistance, INF);
		Arrays.fill(prePoint, -1);
		visit[initStart] = true;
		resultDistance[initStart] = 0;
		int currentPoint = initStart;
		Queue<Node> queue = new PriorityQueue<Node>();
		for (int i = 1; i < pointsNumber; ++i) {
			for (int j = startMax[currentPoint]; j != -1; j = nextStart[j]) {
				int k = edgesEnd[j];
				if (!visit[k]
						&& resultDistance[currentPoint] < resultDistance[k]
								- edgesDistance[j]) {
					resultDistance[k] = resultDistance[currentPoint]
							+ edgesDistance[j];
					queue.offer(new Node(k, resultDistance[k]));
					prePoint[k] = currentPoint;
				}
			}
			while (!queue.isEmpty()) {
				Node tmp = queue.peek();
				if (visit[tmp.getPoint()]) {
					queue.poll();
				} else {
					break;
				}
			}
			if (queue.isEmpty()) {
				break;
			}
			currentPoint = queue.poll().getPoint();
			visit[currentPoint] = true;
			if (currentPoint == initEnd) {
				break;
			}
		}
		resultMinDistance = resultDistance[initEnd];
		return resultDistance[initEnd];
	}

	public boolean hasMinDistance() {
		if (INF <= resultMinDistance) {
			return false;
		} else {
			return true;
		}
	}

}

class Node implements Comparable<Node> {

	private int point;
	private double distance;

	public Node(int point, double distance) {
		this.point = point;
		this.distance = distance;
	}

	public int getPoint() {
		return point;
	}

	public double getDistance() {
		return distance;
	}

	@Override
	public int compareTo(Node qnode) {
		if (this.distance > qnode.distance) {
			return 1;
		} else if (this.distance < qnode.distance) {
			return -1;
		} else {
			return this.point - qnode.point;
		}
	}

}

程序三 bellman-ford 算法

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 = Integer.parseInt(scn.next());
			int pointsNumber = height * width + 2;
			int edgesNumber = 5 * width * height - 2 * (height + width);
			char[][] matrix = new char[height][width];
			for (int i = 0; i < height; i++) {
				matrix[i] = scn.next().toCharArray();
			}
			BellmanFord bellmanFord = new BellmanFord(pointsNumber, edgesNumber);
			int initStart = -1;
			int initEnd = height * width + 1;
			for (int i = 0; i < height - 1; ++i) {
				for (int j = 0; j < width - 1; ++j) {
					int start = i * width + j + 1;
					int end = i * width + j + 1 + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i][j + 1]) {
							distance += 0.5;
						}
						bellmanFord.addEdge(start, end, distance);
						bellmanFord.addEdge(end, start, distance);
					}
					end = (i + 1) * width + j + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i + 1][j]) {
							distance += 0.5;
						}
						bellmanFord.addEdge(start, end, distance);
						bellmanFord.addEdge(end, start, distance);
					}
					if ('a' == matrix[i][j]) {
						initStart = i * width + j + 1;
					}
					if ('r' == matrix[i][j]) {
						bellmanFord.addEdge(i * width + j + 1, initEnd, 0);
					}
				}
			}
			for (int i = height - 1, j = 0; j < width - 1; ++j) {
				int start = i * width + j + 1;
				int end = i * width + j + 1 + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i][j + 1]) {
						distance += 0.5;
					}
					bellmanFord.addEdge(start, end, distance);
					bellmanFord.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					bellmanFord.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			for (int j = width - 1, i = 0; i < height - 1; ++i) {
				int start = i * width + j + 1;
				int end = (i + 1) * width + j + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i + 1][j]) {
						distance += 0.5;
					}
					bellmanFord.addEdge(start, end, distance);
					bellmanFord.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					bellmanFord.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			if ('a' == matrix[height - 1][width - 1]) {
				initStart = height * width;
			}
			if ('r' == matrix[height - 1][width - 1]) {
				bellmanFord.addEdge(height * width, initEnd, 0);
			}
			double distance = bellmanFord.calculateDistance(initStart, initEnd);
			if (bellmanFord.hasMinDistance()) {
				System.out.println(String.format("%.0f", distance));
			} else {
				System.out.println("Poor ANGEL has to stay in the prison all his life.");
			}
		}
		scn.close();
	}

}

class BellmanFord {

	private final double INF = Double.MAX_VALUE / 2;
	private int pointsNumber;
	private int edgesNumber;
	private Edge[] edge;
	private double[] resultDistance;
	private int[] prePoint;
	private double resultMinDistance;

	private boolean relax(int start, int end, double distance) {
		if (resultDistance[end] - distance > resultDistance[start]) {
			resultDistance[end] = resultDistance[start] + distance;
			prePoint[end] = start;
			return true;
		} else {
			return false;
		}
	}

	public BellmanFord(int pointsNumber, int edgesNumber) {
		this.pointsNumber = pointsNumber;
		this.edgesNumber = 0;
		edge = new Edge[edgesNumber];
		resultDistance = new double[pointsNumber];
		prePoint = new int[pointsNumber];
		resultMinDistance = INF;
	}

	public void addEdge(int start, int end, double distance) {
		edge[edgesNumber++] = new Edge(start, end, distance);
	}

	public double calculateDistance(int initStart, int initEnd) {
		Arrays.fill(resultDistance, INF);
		Arrays.fill(prePoint, -1);
		resultDistance[initStart] = 0;
		for (int i = 1; i < pointsNumber; ++i) {
			Boolean flag = false;
			for (int j = 0; j < edgesNumber; ++j) {
				if (relax(edge[j].getStart(), edge[j].getEnd(),
						edge[j].getDistance())) {
					flag = true;
				}
			}
			if (!flag) {
				break;
			}
		}
		for (int i = 0; i < edgesNumber; ++i) {
			if (relax(edge[i].getStart(), edge[i].getEnd(),
					edge[i].getDistance())) {
				resultMinDistance = -INF;
				return -INF;
			}
		}
		resultMinDistance = resultDistance[initEnd];
		return resultDistance[initEnd];
	}

	public boolean hasMinDistance() {
		if (hasNegativeRing() || INF <= resultMinDistance) {
			return false;
		} else {
			return true;
		}
	}

	public boolean hasNegativeRing() {
		if (-INF >= resultMinDistance) {
			return true;
		} else {
			return false;
		}
	}

}

class Edge {

	private int start;
	private int end;
	private double distance;

	public Edge(int start, int end, double distance) {
		this.start = start;
		this.end = end;
		this.distance = distance;
	}

	public int getStart() {
		return start;
	}

	public int getEnd() {
		return end;
	}

	public double getDistance() {
		return distance;
	}

}

程序四 spfa 算法

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 = Integer.parseInt(scn.next());
			int pointsNumber = height * width + 2;
			int edgesNumber = 5 * width * height - 2 * (height + width);
			char[][] matrix = new char[height][width];
			for (int i = 0; i < height; i++) {
				matrix[i] = scn.next().toCharArray();
			}
			Spfa spfa = new Spfa(pointsNumber, edgesNumber);
			int initStart = -1;
			int initEnd = height * width + 1;
			for (int i = 0; i < height - 1; ++i) {
				for (int j = 0; j < width - 1; ++j) {
					int start = i * width + j + 1;
					int end = i * width + j + 1 + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i][j + 1]) {
							distance += 0.5;
						}
						spfa.addEdge(start, end, distance);
						spfa.addEdge(end, start, distance);
					}
					end = (i + 1) * width + j + 1;
					if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
						double distance = 1;
						if ('x' == matrix[i][j]) {
							distance += 0.5;
						}
						if ('x' == matrix[i + 1][j]) {
							distance += 0.5;
						}
						spfa.addEdge(start, end, distance);
						spfa.addEdge(end, start, distance);
					}
					if ('a' == matrix[i][j]) {
						initStart = i * width + j + 1;
					}
					if ('r' == matrix[i][j]) {
						spfa.addEdge(i * width + j + 1, initEnd, 0);
					}
				}
			}
			for (int i = height - 1, j = 0; j < width - 1; ++j) {
				int start = i * width + j + 1;
				int end = i * width + j + 1 + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i][j + 1]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i][j + 1]) {
						distance += 0.5;
					}
					spfa.addEdge(start, end, distance);
					spfa.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					spfa.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			for (int j = width - 1, i = 0; i < height - 1; ++i) {
				int start = i * width + j + 1;
				int end = (i + 1) * width + j + 1;
				if ('#' != matrix[i][j] && '#' != matrix[i + 1][j]) {
					double distance = 1;
					if ('x' == matrix[i][j]) {
						distance += 0.5;
					}
					if ('x' == matrix[i + 1][j]) {
						distance += 0.5;
					}
					spfa.addEdge(start, end, distance);
					spfa.addEdge(end, start, distance);
				}
				if ('a' == matrix[i][j]) {
					initStart = i * width + j + 1;
				}
				if ('r' == matrix[i][j]) {
					spfa.addEdge(i * width + j + 1, initEnd, 0);
				}
			}
			if ('a' == matrix[height - 1][width - 1]) {
				initStart = height * width;
			}
			if ('r' == matrix[height - 1][width - 1]) {
				spfa.addEdge(height * width, initEnd, 0);
			}
			double distance = spfa.calculateDistance(initStart, initEnd);
			if (spfa.hasMinDistance()) {
				System.out.println(String.format("%.0f", distance));
			} else {
				System.out.println("Poor ANGEL has to stay in the prison all his life.");
			}
		}
		scn.close();
	}

}

class Spfa {

	private final double INF = Double.MAX_VALUE / 2;
	private int pointsNumber;
	private int edgesNumber;
	private double[] edgesDistance;
	private int[] edgesEnd;
	private int[] nextStart;
	private int[] startMax;
	private boolean[] visit;
	private double[] resultDistance;
	private int[] prePoint;
	private int[] count;
	private double resultMinDistance;

	private boolean relax(int start, int end, double distance) {
		if (resultDistance[end] - distance > resultDistance[start]) {
			resultDistance[end] = resultDistance[start] + distance;
			prePoint[end] = start;
			return true;
		} else {
			return false;
		}
	}

	public Spfa(int pointsNumber, int edgesNumber) {
		this.pointsNumber = pointsNumber;
		this.edgesNumber = 0;
		edgesDistance = new double[edgesNumber];
		edgesEnd = new int[edgesNumber];
		nextStart = new int[edgesNumber];
		startMax = new int[pointsNumber];
		Arrays.fill(startMax, -1);
		visit = new boolean[pointsNumber];
		resultDistance = new double[pointsNumber];
		prePoint = new int[pointsNumber];
		count = new int[pointsNumber];
		resultMinDistance = INF;
	}

	public void addEdge(int start, int end, double distance) {
		edgesDistance[edgesNumber] = distance;
		edgesEnd[edgesNumber] = end;
		nextStart[edgesNumber] = startMax[start];
		startMax[start] = edgesNumber++;
	}

	public double calculateDistance(int initStart, int initEnd) {
		Arrays.fill(visit, false);
		Arrays.fill(resultDistance, INF);
		Arrays.fill(prePoint, -1);
		Arrays.fill(count, 0);
		visit[initStart] = true;
		resultDistance[initStart] = 0;
		++count[initStart];
		Queue<Integer> queue = new LinkedList<Integer>();
		queue.offer(initStart);
		while (!queue.isEmpty()) {
			int start = queue.poll();
			visit[start] = false;
			for (int i = startMax[start]; i != -1; i = nextStart[i]) {
				int end = edgesEnd[i];
				if (relax(start, end, edgesDistance[i]) && !visit[end]) {
					queue.offer(end);
					visit[end] = true;
					if ((++count[end]) > pointsNumber) {
						resultMinDistance = -INF;
						return -INF;
					}
				}
			}
		}
		resultMinDistance = resultDistance[initEnd];
		return resultDistance[initEnd];
	}

	public boolean hasMinDistance() {
		if (hasNegativeRing() || INF <= resultMinDistance) {
			return false;
		} else {
			return true;
		}
	}

	public boolean hasNegativeRing() {
		if (-INF >= resultMinDistance) {
			return true;
		} else {
			return false;
		}
	}

}

 

ACM-BFS之Rescue——hdu1242
继续激情，继续奋斗。
04-09 1688
ACM BFS Rescue hdu1242 优先队列
“Rescue（营救），ZOJ1649”的一种解法和疑惑
PosPro的专栏
05-29 1756
本文给出了“Rescue（营救），ZOJ1649”的一种解法，使用的是BFS思想。同时也提出了一些自己的疑惑，希望得到高人点拨。
BFS zoj 1649
weixin_34205076的博客
12-06 135
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1649 //hnldyhy(303882171) 11:12:46 // zoj 1649 //bfs +优先队列 #include <stdio.h> #include <iostream> #include &...
ZOJ(1649)Rescue
weixin_30362801的博客
07-07 158
#include <iostream> #include <stdio.h> #include <string> #include <string.h> #include <algorithm> #include <stdlib.h> #include <math.h> #include <...
ZOJ 1649
weixin_30767835的博客
07-17 255
这题要用BFS去做，要注意的是’x‘，这里可以有优先队列去做，会很简单； 另一个要注意的是，a只有一个，r可能有很多个，所以可以用a去找最接近的r； #include <iostream>#include <queue>#include "string.h"using namespace std;struct step{ int x,y,t;...
ZOJ-1649
宇哥的博客
05-24 565
-------------------------------------------------------------------------------- Time Limit: 2 Seconds      Memory Limit: 65536 KB ---------------------------------------------------------------
ZOJ.zip_Jugs A_ZOJ NTA_zoj acm_zoj acm 1216_zoj code
09-20
【ZOJ.zip】是一个压缩包，里面包含了与ZOJ（Zhejiang Online Judge）相关的ACM（International Collegiate Programming Contest）题解。ZOJ是一个在线编程竞赛平台，它为参赛者提供了一系列算法题目进行练习，以...
ACM zoj题目 源代码
03-22
标题 "ACM zoj题目 源代码" 提供了我们即将探讨的知识点核心：ACM竞赛中的编程问题和解题策略，以及所使用的编程语言——C++。这些源代码是学习算法和准备面试机考的重要资源。描述进一步强调了这些代码覆盖了常见的...
浙大acm zoj 1259
12-15
浙大ACM1259的实现代码，C实现的，但还没去ac过，参考参考哈
zoj1204.rar_acm 1204_zoj1204
09-20
标题中的"zoj1204.rar_acm 1204_zoj1204"指的是浙江大学在线判题系统ZOJ（Zhejiang University Online Judge）上的第1204题，这是一个针对ACM/ICPC（国际大学生程序设计竞赛）训练的问题。在ACM/ICPC中，参赛者需要...
ZOJ1649
woot forever woot
08-13 632
一个迷宫，许多个r，主人公在a，坏人在x，走到坏人的格子里需要
zoj 1649
qq_35692873的博客
07-14 253
Description Angel was caught by the MOLIGPY! He was put in prison by Moligpy. The prison is described as a N * M (N, M <= 200) matrix. There are WALLs, ROADs, and GUARDs in the prison. Angel's
zoj --1649
荒野孤鹰
07-17 628
//使用了优先队列 #include #include #include using namespace std; int x[]={-1,1,0,0},y[]={0,0,-1,1}; int visited[220][220],n,m,x2,y2,ok,min1; char map[220][220]; typedef struct node1 { int x,y,t; }Q; Q n
ACM水题－Rescue LK(AC，迷宫问题，DFS求解)
劉俊的专栏
05-13 2948
Rescue LK Time Limit:1000MS  Memory Limit:65536K Total Submit:83 Accepted:42 Description ziliang loves LK. But LK was kidnapped by Monster.oyy,and was put in a labyrinth. After thousands of hard
ZOJ-1649-Rescue
z309241990的专栏
05-16 682
BFS题，由于其存在可以消灭警卫的问题，所以其需要求出地图中每个方格的最小步数。更新的时候应该是如果当前值小于 格子的值才进行更新操作，否则是不用更新的。 代码： #include #include #include #include using namespace std; const int maxn=205; struct node { int x; int y;
ZOJ-1649 Rescue BFS (HDU 1242)
weixin_30553837的博客
10-21 143
看题传送门： ZOJhttp://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1649 HDUhttp://acm.hdu.edu.cn/showproblem.php?pid=1242 题目大意初始位置在r，要求到达a的地点，地图上"."通过需要1s，“x"代表守卫，通过耗时2s，“#”不能走。 BFS的应...
ZOJ 1649 BFS
For free
06-16 603
搜索最短路径，那么用深搜肯定就不行了，深搜只能用来搜索可行解，但是答案并不一定是最优的，所以这里就用广搜了 #include #include #include #include using namespace std; #define LEN 201 #define INF 10000000 int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}
ZOJ——1649（宽度搜索）
luoshenzhisi
08-03 653
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1649 源代码： #include #include #include #include using namespace std; int m,n; int x[4]={-1,0,1,0}; int y[4]={0,1,0,-1}; ch
ACM ZOJ题解代码离线包下载
首先，ZOJ（Zhejiang University Online Judge）是一个在线评测系统，主要用于信息学奥林匹克竞赛（ACM/ICPC）和相关编程竞赛。编程竞赛选手可以在ZOJ平台上提交代码，系统会自动对代码进行测试，并给出是否通过测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值