oj.uz

Submission #246383

# Submission time Handle Problem Language Result Execution time Memory
246383 2020-07-09T02:14:40 Z Ort Birmingham (COCI20_birmingham) Java 11
35 / 70
 1000 ms 70880 KB 
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;


public class birmingham {
	
	static InputStream is;
	static PrintWriter out;
	static String INPUT = "";
	
	public static int maxN = 200005;
	public static ArrayList<Integer>[] Graph = new ArrayList[maxN];
	public static int Dist[] = new int[maxN];
	public static int Ans[] = new int[maxN];
	public static boolean Visited[] = new boolean[maxN];
	
	public static void main(String[] args) {
		
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);
		
		for(int i = 0; i < maxN; i++) Graph[i] = new ArrayList<Integer>();
		
		int n = ni();
		int m = ni();
		int q = ni();
		int k = ni();
		
		Queue<Integer> Q = new ArrayDeque<>();
		
		for(int i = 0; i < q; i++) {
			int source = ni();
			Q.add(source);
			Visited[source] = true;
		}
		
		for(int i = 0; i < m; i++) {
			int a = ni();
			int b = ni();
			Graph[a].add(b);
			Graph[b].add(a);
		}
		
		while(!Q.isEmpty()) {
			int curr = Q.poll();
			
			for(int nxt : Graph[curr]) {
				if(Visited[nxt] == true) continue;
				Visited[nxt] = true;
				Dist[nxt] = Dist[curr] + 1;
				Q.add(nxt);
			}
				
		}
		
		int pt = 1;
		int f = 1;
		while (pt < n) {
		    for(int i = pt; i < (pt + f * k); i++)
		    	if(i < n) Ans[i] = f;
		    pt += f * k;
		    f++;
		}
			
		for(int i = 1; i <= n; i++) {
			System.out.print(Ans[Dist[i]]);
			System.out.print(" ");
		}
		
	}
	
	private static boolean eof() {
		if (lenbuf == -1)
			return true;
		int lptr = ptrbuf;
		while (lptr < lenbuf)
			if (!isSpaceChar(inbuf[lptr++]))
				return false;

		try {
			is.mark(1000);
			while (true) {
				int b = is.read();
				if (b == -1) {
					is.reset();
					return true;
				} else if (!isSpaceChar(b)) {
					is.reset();
					return false;
				}
			}
		} catch (IOException e) {
			return true;
		}
	}

	private static byte[] inbuf = new byte[1024];
	public static int lenbuf = 0, ptrbuf = 0;

	private static int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private static boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private static int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	private static double nd() {
		return Double.parseDouble(ns());
	}

	private static char nc() {
		return (char) skip();
	}

	private static String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private static char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private static char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private static int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static void tr(Object... o) {
		if (INPUT.length() != 0)
			System.out.println(Arrays.deepToString(o));
	}

}

Compilation message

Note: birmingham.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 109 ms 18104 KB Output is correct
2 Correct 104 ms 18260 KB Output is correct
3 Correct 100 ms 18176 KB Output is correct

Subtask #2
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 101 ms 18092 KB Output is correct
2 Correct 106 ms 17844 KB Output is correct
3 Correct 106 ms 18316 KB Output is correct

Subtask #3
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 101 ms 18348 KB Output is correct
2 Correct 102 ms 18284 KB Output is correct
3 Correct 100 ms 18060 KB Output is correct

Subtask #4
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 102 ms 18188 KB Output is correct
2 Correct 111 ms 18268 KB Output is correct
3 Correct 105 ms 18212 KB Output is correct

Subtask #5
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 105 ms 18284 KB Output is correct
2 Correct 105 ms 18072 KB Output is correct
3 Correct 112 ms 18600 KB Output is correct
4 Correct 105 ms 18208 KB Output is correct

Subtask #6
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 109 ms 18220 KB Output is correct
2 Correct 107 ms 18288 KB Output is correct
3 Correct 102 ms 17856 KB Output is correct
4 Correct 105 ms 18072 KB Output is correct

Subtask #7
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 105 ms 18336 KB Output is correct
2 Correct 113 ms 18212 KB Output is correct
3 Correct 110 ms 18540 KB Output is correct
4 Correct 110 ms 18316 KB Output is correct

Subtask #8
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1097 ms 68268 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #9
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1127 ms 70880 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #10
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1082 ms 68036 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #11
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1079 ms 67640 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #12
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1037 ms 67732 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #13
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1079 ms 68028 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #14
0 / 5.0

# Verdict Execution time Memory Grader output
1 Execution timed out 1059 ms 68344 KB Time limit exceeded
2 Halted 0 ms 0 KB -