結果

問題 No.177 制作進行の宮森あおいです!
ユーザー schwarzahlschwarzahl
提出日時 2017-12-23 15:38:44
言語 Java21
(openjdk 21)
結果
AC  
実行時間 287 ms / 2,000 ms
コード長 6,451 bytes
コンパイル時間 3,488 ms
コンパイル使用メモリ 81,092 KB
実行使用メモリ 45,360 KB
最終ジャッジ日時 2024-05-09 22:14:20
合計ジャッジ時間 7,696 ms
ジャッジサーバーID
(参考情報)
judge3 / judge2
このコードへのチャレンジ
(要ログイン)

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 162 ms
41,816 KB
testcase_01 AC 165 ms
41,380 KB
testcase_02 AC 160 ms
41,564 KB
testcase_03 AC 199 ms
42,252 KB
testcase_04 AC 186 ms
42,144 KB
testcase_05 AC 243 ms
42,756 KB
testcase_06 AC 249 ms
43,972 KB
testcase_07 AC 184 ms
42,252 KB
testcase_08 AC 237 ms
42,472 KB
testcase_09 AC 271 ms
45,188 KB
testcase_10 AC 287 ms
45,360 KB
testcase_11 AC 272 ms
44,872 KB
testcase_12 AC 281 ms
44,880 KB
testcase_13 AC 144 ms
41,420 KB
testcase_14 AC 147 ms
41,344 KB
testcase_15 AC 143 ms
41,244 KB
権限があれば一括ダウンロードができます

ソースコード

diff #

package practice;

import java.util.HashSet;
import java.util.Optional;
import java.util.Scanner;
import java.util.Set;

public class Main {
	public static void main(String[] args) {
		Main main = new Main();
		main.solveC();
	}

	private void solveC() {
		Scanner sc = new Scanner(System.in);
		int W = sc.nextInt();
		int N = sc.nextInt();
		int[] J = new int[N + 1];
		for (int i = 1; i <= N; i++) {
			J[i] = sc.nextInt();
		}
		int M = sc.nextInt();
		int[] C = new int[M + 1];
		for (int i = 1; i <= M; i++) {
			C[i] = sc.nextInt();
		}
		final int SOURCE = 0;
		final int VERTEX_NUM = N + M + 2;
		final int TARGET = VERTEX_NUM - 1;
		Graph graph = new ArrayGraph(VERTEX_NUM);
		for (int i = 1; i <= N; i++) {
			graph.link(SOURCE, i, J[i]);
		}
		for (int i = 1; i <= M; i++) {
			graph.link(N+i, TARGET, C[i]);
		}
		for (int i = 1; i <= M; i++) {
			int Q = sc.nextInt();
			Set<Integer> set = new HashSet<>();
			for (int j = 1; j <= Q; j++) {
				set.add(sc.nextInt());
			}
			for (int j = 1; j <= N; j++) {
				if (!set.contains(j)) {
					graph.link(j, N+i, Integer.MAX_VALUE / 3);
				}
			}
		}
		FlowResolver fr = new BfsFlowResolver(graph);
		int cut = fr.maxFlow(SOURCE, TARGET);
		System.err.println(cut);
		if (cut >= W) {
			System.out.println("SHIROBAKO");
		} else {
			System.out.println("BANSAKUTSUKITA");
		}
	}

	private void solveB() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int[] B = new int[N];
		int[] C = new int[N];
		for (int i = 0; i < N; i++) {
			B[i] = sc.nextInt();
			C[i] = sc.nextInt();
		}
		int M = sc.nextInt();
		int[] D = new int[M];
		int[] E = new int[M];
		for (int i = 0; i < M; i++) {
			D[i] = sc.nextInt();
			E[i] = sc.nextInt();
		}

		final int VERTEX_NUM = 2 * N + 2;
		final int SOURCE = 0;
		final int TARGET = VERTEX_NUM - 1;
		int sum = 0;
		Graph graph = new ArrayGraph(VERTEX_NUM);
		for (int i = 0; i < N; i++) {
			graph.link(SOURCE, i+1, B[i]);
			graph.link(i+1, N+i+1, B[i] + C[i]);
			graph.link(N+i+1, TARGET, C[i]);
			sum += B[i] + C[i];
		}
		for (int i = 0; i < M; i++) {
			graph.link(N+1+D[i], 1+E[i], Integer.MAX_VALUE / 3);
		}

		FlowResolver fr = new DfsFlowResolver(graph);
		System.out.println(sum - fr.maxFlow(SOURCE, TARGET));
	}

	interface Graph {
		void link(int from, int to, int cost);
		Optional<Integer> getCost(int from, int to);
		int getVertexNum();
	}

	interface FlowResolver {
		int maxFlow(int from, int to);
	}

	/**
	 * グラフの行列による実装
	 * 接点数の大きいグラフで使うとMLEで死にそう
	 */
	class ArrayGraph implements Graph {
		private Integer[][] costArray;
		private int vertexNum;

		public ArrayGraph(int n) {
			costArray = new Integer[n][];
			for (int i = 0; i < n; i++) {
				costArray[i] = new Integer[n];
			}
			vertexNum = n;
		}

		@Override
		public void link(int from, int to, int cost) {
			costArray[from][to] = new Integer(cost);
		}

		@Override
		public Optional<Integer> getCost(int from, int to) {
			return Optional.ofNullable(costArray[from][to]);
		}

		@Override
		public int getVertexNum() {
			return vertexNum;
		}
	}

	class BfsFlowResolver implements FlowResolver {
		private Graph graph;
		public BfsFlowResolver(Graph graph) {
			this.graph = graph;
		}
		public int maxFlow(int from, int to) {
			boolean finish = false;
			while (!finish) {
				Integer[] flows = new Integer[graph.getVertexNum()];
				flows[from] = Integer.MAX_VALUE / 3;
				Integer[] froms = new Integer[graph.getVertexNum()];
				boolean[] isPassed = new boolean[graph.getVertexNum()];
				finish = false;
				while (!finish) {
					finish = true;
					for (int id = 0; id < graph.getVertexNum(); id++) {
						if (flows[id] != null) {
							if (flow(id, flows, froms)) {
								finish = false;
							}
						}
					}
					if (flows[to] != null) {
						int to_i = to;
						while (froms[to_i] != null) {
							graph.link(froms[to_i], to_i, graph.getCost(froms[to_i], to_i).get() - flows[to]);
							graph.link(to_i, froms[to_i], graph.getCost(to_i, froms[to_i]).orElse(0) + flows[to]);
							to_i = froms[to_i];
						}
						finish = false;
						break;
					}
				}
			}
			int sum = 0;
			for (int id = 0; id < graph.getVertexNum(); id++) {
				sum += graph.getCost(to, id).orElse(0);
			}
			return sum;
		}
		public boolean flow(int from, Integer[] flows, Integer[] froms) {
			boolean change = false;
			for (int next = 0; next < graph.getVertexNum(); next++) {
				Optional<Integer> cost = graph.getCost(from, next);
				if (cost.orElse(0) > 0 && flows[next] == null) {
					int nextFlow = flows[from] < cost.get() ? flows[from] : cost.get();
					flows[next] = nextFlow;
					froms[next] = from;
					change = true;
				}
			}
			return change;
		}
	}

	/**
	 * DFS(深さ優先探索)による実装
	 * 計算量はO(E*MaxFlow)のはず (E:辺の数, MaxFlow:最大フロー)
	 */
	class DfsFlowResolver implements FlowResolver {
		private Graph graph;
		public DfsFlowResolver(Graph graph) {
			this.graph = graph;
		}

		/**
		 * 最大フロー(最小カット)を求める
		 * @param from 始点(source)のID
		 * @param to 終点(target)のID
		 * @return 最大フロー(最小カット)
		 */
		public int maxFlow(int from, int to) {
			int sum = 0;
			int currentFlow;
			do {
				currentFlow = flow(from, to,Integer.MAX_VALUE / 3, new boolean[graph.getVertexNum()]);
				sum += currentFlow;
			} while (currentFlow > 0);
			return sum;
		}

		/**
		 * フローの実行 グラフの更新も行う
		 * @param from 現在いる節点のID
		 * @param to 終点(target)のID
		 * @param current_flow ここまでの流量
		 * @param passed 既に通った節点か否かを格納した配列
		 * @return 終点(target)に流した流量/戻りのグラフの流量
		 */
		private int flow(int from, int to, int current_flow, boolean[] passed) {
			passed[from] = true;
			if (from == to) {
				return current_flow;
			}
			for (int id = 0; id < graph.getVertexNum(); id++) {
				if (passed[id]) {
					continue;
				}
				Optional<Integer> cost = graph.getCost(from, id);
				if (cost.orElse(0) > 0) {
					int nextFlow = current_flow < cost.get() ? current_flow : cost.get();
					int returnFlow = flow(id, to, nextFlow, passed);
					if (returnFlow > 0) {
						graph.link(from, id, cost.get() - returnFlow);
						graph.link(id, from, graph.getCost(id, from).orElse(0) + returnFlow);
						return returnFlow;
					}
				}
			}
			return 0;
		}
	}
}
0