2021-2-4蓝桥杯java-算法训练-网络流裸题

网络流裸题

1.Deque ：接口的大小可变数组的实现。数组双端队列没有容量限制；它们可根据需要增加以支持使用。禁止 null 元素。此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。

2.类 ArrayDeque方法摘要
boolean add(E e) 将指定元素插入此双端队列的末尾。
E poll() 获取并移除此双端队列所表示的队列的头（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。

3.int型的变量，不管是单个的变量，还是数组类型的，在你只定义，不赋值的情况下，他们的默认值都是0，所以你只要定义一个不赋值的二维数组，java会默认他们都是初始化成0的了

我能理解的代码…这应该是EK算法…题目中数据约定：n<=1000 ，m<=10000，所以我的代码虽然输入输出正确，但是只有85分…

import java.util.ArrayDeque;   //类
import java.util.Queue;        //接口
import java.util.Scanner;

public class Main {
	public static int n;
	public static int m;
	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		// 输入结点个数和边的个数
		n = scn.nextInt();
		m = scn.nextInt();
		// 因为第一个结点是1不是0，所以我们多申请一些空间，索引为0的位置就不使用了。从索引为1的位置开始放
		int[][] edge = new int[n + 1][n + 1];
		for (int i = 0; i < m; i++) {
			int vertex1 = scn.nextInt();
			int vertex2 = scn.nextInt();
			int weight = scn.nextInt();
			edge[vertex1][vertex2] += weight;// 一条边可能会出现多次
		}
		// path[i]是第i个结点的父节点。我们通过在BFS(广度优先遍历)中不断更新path[i]里的数，从而保存一条路径。
		int[] path = new int[n + 1];
		int flow = 0;
		while (BFSfindPath(edge, 1, n, path)==1) {
			// 如果能够找到增广路径，那么我们在该路径上能够通过的容量就是这个路径上能通过的最小容量。
			int min = edge[path[n]][n];
			for (int i = path[n]; i != 1; i = path[i]) {
				if (edge[path[i]][i] < min && edge[path[i]][i] > 0) {
					min = edge[path[i]][i];
				}
			}
			flow += min;
			for (int i = n; i != 1; i = path[i]) {
				int j = path[i];
				edge[j][i] -= min;
				edge[i][j] += min;
			}
		}
		System.out.println(flow);
	}

	
	private static int BFSfindPath(int[][] edge, int s, int t, int[] path) {
		// path[]是通过记录每个结点的父节点，从而记录下一条完整的路径。
		for (int i = 0; i < path.length; i++) {
			path[i] = 0;
		}
		int vertex_num = edge.length;
		// 用于标记是否已经访问过该结点
		int[] visited = new int[vertex_num];

		Queue<Integer> q = new ArrayDeque<Integer>();
		q.add(s);    //将指定元素插入此双端队列的末尾
		visited[s] = 1;

		while (!q.isEmpty() ) {
			int w = q.poll();    //获取并移除此双端队列所表示的队列的头
			for (int i = 1; i < vertex_num; i++) {
				if (edge[w][i] > 0 && visited[i] == 0) {
					q.add(i);
					visited[i] = 1;
					path[i] = w;
				}
			}
		}
		return visited[t];
	}

	
}

在网上看到的，这是正确的100分…没有用Scanner输入，用的是类 StreamTokenizer，StreamTokenizer 类获取输入流并将其解析为“标记”，允许一次读取一个标记。
int nextToken() 从此标记生成器的输入流中解析下一个标记。
字段摘要：double nval 如果当前标记是一个数字，则此字段将包含该数字的值。
static int TT_EOF 指示已读到流末尾的常量。

import java.util.ArrayDeque;   //类
import java.util.Queue;        //接口
import java.io.*;
public class Main {
	
	public static void main(String[] args) throws IOException {
		StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		in.nextToken();
		int n=(int)in.nval;
		// 因为第一个结点是1不是0，所以我们多申请一些空间，索引为0的位置就不使用了。从索引为1的位置开始放
		int[][] edge = new int[n + 1][n + 1];
		in.nextToken();
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            int v = (int)in.nval;
            in.nextToken();
            int w = (int)in.nval;
            in.nextToken();
            edge[v][w] += in.nval;
        }
		// path[i]是第i个结点的父节点。我们通过在BFS(广度优先遍历)中不断更新path[i]里的数，从而保存一条路径。
		int[] path = new int[n + 1];
		int flow = 0;
		while (BFSfindPath(edge, 1, n, path)==1) {
			// 如果能够找到增广路径，那么我们在该路径上能够通过的容量就是这个路径上能通过的最小容量。
			int min = edge[path[n]][n];
			for (int i = path[n]; i != 1; i = path[i]) {
				if (edge[path[i]][i] < min && edge[path[i]][i] > 0) {
					min = edge[path[i]][i];
				}
			}
			flow += min;
			for (int i = n; i != 1; i = path[i]) {
				int j = path[i];
				edge[j][i] -= min;
				edge[i][j] += min;
			}
		}
		System.out.println(flow);
	}

	
	 static int BFSfindPath(int[][] edge, int s, int t, int[] path) {
		// path[]是通过记录每个结点的父节点，从而记录下一条完整的路径。
		for (int i = 0; i < path.length; i++) {
			path[i] = 0;
		}
		int vertex_num = edge.length;
		// 用于标记是否已经访问过该结点
		int[] visited = new int[vertex_num];

		Queue<Integer> q = new ArrayDeque<Integer>();
		q.add(s);    //将指定元素插入此双端队列的末尾
		visited[s] = 1;

		while (!q.isEmpty() ) {
			int w = q.poll();    //获取并移除此双端队列所表示的队列的头
			for (int i = 1; i < vertex_num; i++) {
				if (edge[w][i] > 0 && visited[i] == 0) {
					q.add(i);
					visited[i] = 1;
					path[i] = w;
				}
			}
		}
		return visited[t];
	}

	
}