結果

問題 No.1211 円環はお断り
ユーザー CuriousFairy315CuriousFairy315
提出日時 2020-08-30 17:30:59
言語 Java21
(openjdk 21)
結果
AC  
実行時間 1,176 ms / 2,000 ms
コード長 9,672 bytes
コンパイル時間 4,825 ms
コンパイル使用メモリ 95,904 KB
実行使用メモリ 73,340 KB
最終ジャッジ日時 2023-08-15 10:08:37
合計ジャッジ時間 27,412 ms
ジャッジサーバーID
（参考情報） 		judge11 / judge14
このコードへのチャレンジ（β）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 62 ms
50,464 KB
testcase_01 AC 60 ms
50,768 KB
testcase_02 AC 66 ms
51,568 KB
testcase_03 AC 63 ms
51,400 KB
testcase_04 AC 62 ms
51,892 KB
testcase_05 AC 60 ms
50,780 KB
testcase_06 AC 63 ms
51,396 KB
testcase_07 AC 69 ms
51,260 KB
testcase_08 AC 61 ms
50,964 KB
testcase_09 AC 76 ms
52,724 KB
testcase_10 AC 67 ms
51,328 KB
testcase_11 AC 76 ms
52,592 KB
testcase_12 AC 64 ms
51,252 KB
testcase_13 AC 565 ms
67,956 KB
testcase_14 AC 607 ms
69,188 KB
testcase_15 AC 830 ms
69,728 KB
testcase_16 AC 1,078 ms
73,340 KB
testcase_17 AC 296 ms
59,364 KB
testcase_18 AC 578 ms
69,856 KB
testcase_19 AC 287 ms
58,796 KB
testcase_20 AC 304 ms
57,612 KB
testcase_21 AC 347 ms
57,872 KB
testcase_22 AC 600 ms
67,140 KB
testcase_23 AC 775 ms
68,808 KB
testcase_24 AC 565 ms
66,224 KB
testcase_25 AC 169 ms
58,204 KB
testcase_26 AC 797 ms
69,996 KB
testcase_27 AC 413 ms
66,412 KB
testcase_28 AC 811 ms
70,048 KB
testcase_29 AC 615 ms
68,996 KB
testcase_30 AC 833 ms
70,440 KB
testcase_31 AC 349 ms
64,900 KB
testcase_32 AC 939 ms
72,748 KB
testcase_33 AC 1,055 ms
65,628 KB
testcase_34 AC 1,138 ms
67,500 KB
testcase_35 AC 1,148 ms
65,808 KB
testcase_36 AC 1,152 ms
67,000 KB
testcase_37 AC 1,176 ms
68,020 KB
testcase_38 AC 941 ms
66,952 KB
testcase_39 AC 914 ms
67,232 KB
testcase_40 AC 148 ms
54,856 KB
testcase_41 AC 62 ms
51,576 KB
testcase_42 AC 63 ms
51,500 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.BitSet;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args) {
		new Main();
	}

	public Main() {
		InputChecker ic = new InputChecker(System.in);
		java.io.PrintWriter out = new java.io.PrintWriter(System.out);
		solve(ic, out);
		out.flush();
	}

	public void solve(InputChecker ic, java.io.PrintWriter out) {
		int N = ic.nextInt(1, exponent10(1, 5));
		ic.nextChar(' ');
		int K = ic.nextInt(1, exponent10(1, 5));
		if (K > N) throw new AssertionError();
		ic.readNewLine();
		int[] A = new int[N];
		A[0] = ic.nextInt(1, exponent10(1, 9));
		for (int i = 1;i < N;++ i) {
			ic.nextChar(' ');
			A[i] = ic.nextInt(1, exponent10(1, 9));
		}
		ic.readNewLine();
		ic.checkEOF();

		if (K == 1) {
			out.println(Arrays.stream(A).mapToLong(i -> i).sum());
			return;
		}

		long min = 1, max = Arrays.stream(A).mapToLong(i -> i).sum() - Arrays.stream(A).max().getAsInt() + 1, mid, halfDiff;
		while((halfDiff = max - min >> 1) != 0) {
			mid = min + halfDiff;
			int[][] doubling = new int[18][N];
			for (int[] i : doubling) Arrays.fill(i, -1);
			{
				int[] function = doubling[0];
				long sum = 0;
				for (int l = 0, r = 0;l < N;++ l) {
					while(sum < mid) {
						sum += A[r];
						r = (r + 1) % N;
					}
					function[l] = r;
					sum -= A[l];
				}
			}
			{
				for (int i = 1;i < 18;++ i) {
					for (int j = 0;j < N;++ j) {
						int half = doubling[i - 1][j];
						if (half < 0 || doubling[i - 1][half] < 0) continue;
						int next = doubling[i - 1][half];
						if (dist(j, half, N) + dist(half, next, N) > N) continue;
						doubling[i][j] = next;
					}
				}
			}
			boolean can = false;
			cont: for (int i = 0;i < N;++ i) {
				int dist = 0, now = i;
				for (int j = 17;j >= 0;-- j) {
					if ((K >> j & 1) != 0) {
						if (doubling[j][now] < 0) continue cont;
						dist += dist(now, doubling[j][now], N);
						now = doubling[j][now];
					}
				}
				can |= dist <= N;
				if (can) break;
			}
			if (can) min = mid;
			else max = mid;
		}
		out.println(min);
	}

	private static int dist(int a, int b, int N) {
		if (a == b) return N;
		return a < b ? b - a : N - a + b;
	}

	public static int exponent10(int n, int e) {
		return n * pow(10, e);
	}

	public static long exponent10L(int n, int e) {
		return n * pow(10L, e);
	}

	public static int pow(int a, int b) {
		int ans = 1;
		for (int mul = a;b > 0;b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
		return ans;
	}

	public static long pow(long a, long b) {
		long ans = 1;
		for (long mul = a;b > 0;b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
		return ans;
	}

	public static class CharSet {
		private final BitSet set = new BitSet(256);

		public void add(char... c) {
			for (char i : c) set.set(i);
		}

		public void add(CharSet... s) {
			for (CharSet i : s) set.or(i.set);
		}

		public boolean contains(char... c) {
			for (char i : c) if (!set.get(i)) return false;
			return true;
	 	}

		public boolean contains(String s) {
			return contains(s.toCharArray());
	 	}

		private static final class Chars extends CharSet {
			public Chars(char... c) {
				super.add(c);
			}
			public Chars(CharSet... s) {
				super.add(s);
			}
			@Override
			public void add(char... c) {
				throw new UnsupportedOperationException();
			}
			@Override
			public void add(CharSet... s) {
				throw new UnsupportedOperationException();
			}
		}

		public static final CharSet NUMBER = new Chars('0','1','2','3','4','5','6','7','8','9');
		public static final CharSet LOWER = new Chars('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z');
		public static final CharSet UPPER = new Chars('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
		public static final CharSet ALPHABET = new Chars(LOWER, UPPER);

	}
	public static class InputChecker {
		private InputStream in;
		private final byte[] buffer = new byte[1024];
		private final byte[] undo = new byte[1024];
		private int undoSize = 0;
		private int read = 0;
		private int length = 0;

		public InputChecker(InputStream in) {
			this.in = in;
		}

		public final void setInputStream(InputStream in) {
			this.in = in;
		}

		public final void setInputStream(File in) {
			try {
				this.in = new FileInputStream(in);
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		private boolean hasNextByte() {
			if (undoSize > 0) return true;
			if (read < length) return true;
			read = 0;
			try {
				length = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			return length > 0;
		}

		private byte readByte() {
			if (hasNextByte()) return undoSize > 0 ? undo[--undoSize] : buffer[read++];
			throw new NoSuchElementException();
		}

		private void undo(byte b) {
			undo[undoSize ++] = b;
		}

		private void undo(char c) {
			if ((c & 0xFF80) == 0) {
				undo((byte)c);
				return;
			}
			undo((byte)(c & 0x3F | 0x80));
			if ((c & 0xF800) == 0) {
				undo((byte)(c >> 6 & 0x1F | 0xC0));
			} else {
				undo((byte)(c >> 6 & 0x3F | 0x80));
				undo((byte)(c >> 12 | 0xE0));
			}
		}

		public final boolean hasNext() {
			return hasNextByte();
		}

		public final char nextChar() {
			byte b = readByte();
			if ((b & 0x80) == 0) return (char)b;
			if ((b & 0x20) == 0) return (char)((b & 0x1F) << 6 | (readByte() & 0x3F));
			return (char)((b & 0xF) << 12 | (readByte() & 0x3F) << 6 | (readByte() & 0x3F));
		}

		public final char nextChar(char estimate) {
			char c = nextChar();
			if (estimate == c) return estimate;
			undo(c);
			throw new AssertionError();
		}

		public final char nextChar(CharSet estimate) {
			char c = nextChar();
			if (estimate.contains(c)) return c;
			undo(c);
			throw new AssertionError();
		}

		public final void readNewLine() {
			char c = nextChar();
			if (c == '\r') {
				c = nextChar();
				if (c != '\n') undo(c);
				return;
			} else if (c == '\n') return;
			undo(c);
			throw new AssertionError();
		}

		public final void checkEOF() {
			if (hasNextByte()) throw new AssertionError();
		}

		public final String next(CharSet contains) {
			StringBuilder sb = new StringBuilder();
			try {
				do {
					char c = nextChar();
					if (!contains.contains(c)) {
						undo(c);
						return sb.toString();
					}
					sb.append(c);
				} while(true);
			} catch (NoSuchElementException e) {
				if (sb.length() <= 0) throw new AssertionError();
				return sb.toString();
			}
		}

		public final int nextInt() {
			byte b = readByte();
			int n = 0;
			if (b == '-') {
				if (!isNumber(b = readByte())) {
					undo(b);
					throw new NumberFormatException();
				}
				try {
					if (b == '0') {
						if (!isNumber(b = readByte())) {
							undo(b);
							return 0;
						}
						throw new NumberFormatException();
					}
					do n = Math.addExact(Math.multiplyExact(n, 10), '0' - b); while(isNumber(b = readByte()));
					undo(b);
				} catch (NoSuchElementException e) {
				}
				return n;
			}
			if (!isNumber(b)) {
				undo(b);
				throw new NumberFormatException();
			}
			try {
				if (b == '0') {
					if (!isNumber(b = readByte())) {
						undo(b);
						return 0;
					}
					throw new NumberFormatException();
				}
				do n = Math.addExact(Math.multiplyExact(n, 10), b - '0'); while(isNumber(b = readByte()));
				undo(b);
			} catch (NoSuchElementException e) {
			}
			return n;
		}

		public final int nextInt(int min, int max) {
			int n = nextInt();
			if (min <= n && n <= max) return n;
			throw new NumberFormatException();
		}

		private static boolean isNumber(byte c) {
			return '0' <= c && c <= '9';
		}

		public final long nextLong() {
			byte b = readByte();
			long n = 0;
			if (b == '-') {
				if (!isNumber(b = readByte())) {
					undo(b);
					throw new NumberFormatException();
				}
				try {
					if (b == '0') {
						if (!isNumber(b = readByte())) {
							undo(b);
							return 0;
						}
						throw new NumberFormatException();
					}
					do n = Math.addExact(Math.multiplyExact(n, 10), '0' - b); while(isNumber(b = readByte()));
					undo(b);
				} catch (NoSuchElementException e) {
				}
				return n;
			}
			if (!isNumber(b)) {
				undo(b);
				throw new NumberFormatException();
			}
			try {
				if (b == '0') {
					if (!isNumber(b = readByte())) {
						undo(b);
						return 0;
					}
					throw new NumberFormatException();
				}
				do n = Math.addExact(Math.multiplyExact(n, 10), b - '0'); while(isNumber(b = readByte()));
				undo(b);
			} catch (NoSuchElementException e) {
			}
			return n;
		}

		public final long nextLong(long min, long max) {
			long n = nextLong();
			if (min <= n && n <= max) return n;
			throw new NumberFormatException();
		}

		public final double nextDouble() {
			StringBuilder sb = new StringBuilder();
			byte b = readByte();
			if (b == '-') {
				sb.append(b);
				b = readByte();
			}
			if (b == '0') {
				sb.append(b);
				b = readByte();
			} else {
				while(isNumber(b)) {
					sb.append(b);
					b = readByte();
				}
			}
			if (b == '.') {
				sb.append(b);
				b = readByte();
				while(isNumber(b)) {
					sb.append(b);
					b = readByte();
				}
			}
			if (b == 'e' || b == 'E') {
				sb.append(b);
				b = readByte();
				if (b == '-' || b == '+') {
					sb.append(b);
					b = readByte();
				}
				while(isNumber(b)) {
					sb.append(b);
					b = readByte();
				}
			}
			undo(b);
			return Double.parseDouble(sb.toString());
		}
	}
}
0