結果

問題 No.1341 真ん中を入れ替えて門松列
ユーザー 37zigen37zigen
提出日時 2019-12-05 04:22:59
言語 Java21
(openjdk 21)
結果
AC  
実行時間 752 ms / 2,000 ms
コード長 4,784 bytes
コンパイル時間 2,267 ms
コンパイル使用メモリ 82,492 KB
実行使用メモリ 66,584 KB
最終ジャッジ日時 2023-10-21 10:50:01
合計ジャッジ時間 10,569 ms
ジャッジサーバーID
（参考情報） 		judge13 / judge11
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 118 ms
56,732 KB
testcase_01 AC 116 ms
57,284 KB
testcase_02 AC 109 ms
56,332 KB
testcase_03 AC 115 ms
57,572 KB
testcase_04 AC 115 ms
57,632 KB
testcase_05 AC 110 ms
56,356 KB
testcase_06 AC 231 ms
61,024 KB
testcase_07 AC 233 ms
61,832 KB
testcase_08 AC 270 ms
62,236 KB
testcase_09 AC 259 ms
61,916 KB
testcase_10 AC 667 ms
66,260 KB
testcase_11 AC 659 ms
66,584 KB
testcase_12 AC 644 ms
65,600 KB
testcase_13 AC 683 ms
65,632 KB
testcase_14 AC 752 ms
65,384 KB
testcase_15 AC 705 ms
64,028 KB
testcase_16 AC 689 ms
65,284 KB
testcase_17 AC 684 ms
63,620 KB
testcase_18 AC 341 ms
62,256 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

// unproved N log^2 N

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

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

	void run() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		long M = sc.nextLong();
		long[][] A = new long[N][2];
		long[] C = new long[N];
		for (int i = 0; i < N; ++i) {
			A[i][0] = sc.nextInt();
			C[i] = sc.nextInt();
			A[i][1] = sc.nextInt();
		}
		String[] ret = solve(N, M, A, C);
		for (String s : ret) {
			System.out.println(s);
		}
	}

	long check(long middle, int N, long M, long[][] A, long[] C, boolean center) {
		for (int i = 0; i < A.length; ++i)
			Arrays.sort(A[i]);
		Arrays.sort(C);
		for (int i = 0; i < N; ++i) {
			long l = binarySearchLeft(A[i][0], C);
			long r = binarySearchRight(A[i][1], C);
			if (!center) {
				l = Math.min(l, middle);
				r = Math.max(r, middle + 1);
			}
			A[i] = new long[] { l, r, A[i][0], A[i][1] };
		}
		Arrays.sort(A, new Comparator<long[]>() {
			@Override
			public int compare(long[] o1, long[] o2) {
				return Long.compare(o1[0], o2[0]);
			}
		});
		PriorityQueue<long[]> pq = new PriorityQueue<>(new Comparator<long[]>() {
			@Override
			public int compare(long[] o1, long[] o2) {
				if (o1[0] != o2[0])
					return Long.compare(o1[0], o2[0]);
				else
					return Long.compare(o1[2], o2[2]);
			}
		});
		int p = 0, maxsz = 0;
		long ans = 0;
		int[] need = new int[N];
		int[] sz = new int[N];
		for (int i = -1; i <= N; ++i) {
			while (p < A.length && A[p][0] <= i) {
				pq.add(new long[] { A[p][1], A[p][2], A[p][3] });
				++p;
				maxsz = Math.max(maxsz, pq.size());
			}
			while (pq.size() > i + 1) {
				long[] v = pq.poll();
				if (v[0] >= N) {
					return -1;
				}
				need[(int) v[0]]--;
			}
			if (0 <= i && i < sz.length)
				sz[i] = pq.size();
		}
		for (int i = 1; i < N; ++i) {
			need[i] = need[i - 1] + need[i];
		}
		boolean ok = true;
		int pnd = 0, cur = 0;
		for (int i = 0; i < N; ++i) {
			pnd += Math.abs(need[i]);
			if (pnd > 0) {
				++cur;
				--pnd;
			}
			need[i] = (i + 1) - cur;
		}
		int max = 0;
		for (int i = N - 1; i >= 0; --i) {
			max = Math.max(max, sz[i]);
			ok &= max >= need[i];
		}
		if (!ok)
			return -1;
		for (int i = N - 1; i >= pq.size(); --i) {
			ans += C[i];
		}
		if (center)
			return pq.size();
		while (!pq.isEmpty()) {
			ans += pq.poll()[2];
		}
		return ans;
	}

	long[][] copy(long[][] A) {
		long[][] Acopy = new long[A.length][A[0].length];
		for (int j = 0; j < A.length; ++j)
			Acopy[j] = Arrays.copyOf(A[j], A[j].length);
		return Acopy;
	}

	String[] solve(int N, long M, long[][] A, long[] C) {
		long ret = -1;
		long center = check(-1, N, M, copy(A), Arrays.copyOf(C, C.length), true);
		if (center == -1)
			return new String[] { "NO" };
		long left, right;
		if (check(-1, N, M, copy(A), Arrays.copyOf(C, C.length), false) > 0) {
			left = -1;
		} else {
			long lng = -1;
			left = center;
			while (left - lng > 1) {
				long middle = (left + lng) / 2;
				if (check(middle, N, M, copy(A), Arrays.copyOf(C, C.length), false) > 0) {
					left = middle;
				} else {
					lng = middle;
				}
			}
		}

		if (check(N, N, M, copy(A), Arrays.copyOf(C, C.length), false) > 0) {
			right = N;
		} else {
			long rng = N;
			right = center;
			while (rng - right > 1) {
				long middle = (rng + right) / 2;
				if (check(middle, N, M, copy(A), Arrays.copyOf(C, C.length), false) > 0) {
					right = middle;
				} else {
					rng = middle;
				}
			}
		} 
		while (right - left > 2) {
			long lm = (right + 2 * left) / 3;// l+(r-l)/3=(r+2l)/3
			long rm = (2 * right + left) / 3;
			long lmv = check(lm, N, M, copy(A), Arrays.copyOf(C, C.length), false);
			long rmv = check(rm, N, M, copy(A), Arrays.copyOf(C, C.length), false);
			if (lmv > rmv)
				right = rm;
			else
				left = lm;
			ret = Math.max(ret, lmv);
			ret = Math.max(ret, rmv);
		}
		for (long i = left; i <= right; ++i)
			ret = Math.max(ret, check(i, N, M, copy(A), Arrays.copyOf(C, C.length), false));
		if (ret >= M)
			return new String[] { "YES", "KADOMATSU!" };
		else if (ret > 0) {
			return new String[] { "YES", "NO" };
		} else {
			return new String[] { "NO" };
		}
	}

	int binarySearchRight(long key, long[] a) {
		int ok = a.length;
		int ng = -1;
		while (ok - ng > 1) {
			int middle = (ok + ng) / 2;
			if (a[middle] > key) {
				ok = middle;
			} else {
				ng = middle;
			}
		}
		return ok;
	}

	int binarySearchLeft(long key, long[] a) {
		int ok = -1;
		int ng = a.length;
		while (ng - ok > 1) {
			int middle = (ok + ng) / 2;
			if (a[middle] < key) {
				ok = middle;
			} else {
				ng = middle;
			}
		}
		return ok;
	}

	void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

}
0