#947694 (Java21) No.2617 容量3のナップザック

提出ソース

結果

問題	No.2617 容量3のナップザック
ユーザー	uwi
提出日時	2024-02-03 18:01:13
言語	Java21 (openjdk 21)
結果	AC
実行時間	822 ms / 2,000 ms
コード長	14,895 bytes
コンパイル時間	5,408 ms
コンパイル使用メモリ	93,352 KB
実行使用メモリ	79,676 KB
最終ジャッジ日時	2024-09-28 10:56:17
合計ジャッジ時間	25,010 ms
ジャッジサーバーID （参考情報）	judge4 / judge2

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	81 ms 38,188 KB
testcase_01	AC	92 ms 38,068 KB
testcase_02	AC	83 ms 37,980 KB
testcase_03	AC	80 ms 38,168 KB
testcase_04	AC	83 ms 37,832 KB
testcase_05	AC	79 ms 37,892 KB
testcase_06	AC	79 ms 38,040 KB
testcase_07	AC	83 ms 38,108 KB
testcase_08	AC	82 ms 37,560 KB
testcase_09	AC	83 ms 38,084 KB
testcase_10	AC	79 ms 38,152 KB
testcase_11	AC	87 ms 38,036 KB
testcase_12	AC	636 ms 70,436 KB
testcase_13	AC	539 ms 73,200 KB
testcase_14	AC	634 ms 71,996 KB
testcase_15	AC	553 ms 67,284 KB
testcase_16	AC	480 ms 65,016 KB
testcase_17	AC	587 ms 70,652 KB
testcase_18	AC	595 ms 70,396 KB
testcase_19	AC	257 ms 45,416 KB
testcase_20	AC	631 ms 71,024 KB
testcase_21	AC	408 ms 55,896 KB
testcase_22	AC	628 ms 72,284 KB
testcase_23	AC	677 ms 73,876 KB
testcase_24	AC	172 ms 42,444 KB
testcase_25	AC	579 ms 64,732 KB
testcase_26	AC	598 ms 65,968 KB
testcase_27	AC	410 ms 55,464 KB
testcase_28	AC	144 ms 41,968 KB
testcase_29	AC	456 ms 52,988 KB
testcase_30	AC	666 ms 71,700 KB
testcase_31	AC	610 ms 70,292 KB
testcase_32	AC	822 ms 75,304 KB
testcase_33	AC	696 ms 79,676 KB
testcase_34	AC	663 ms 79,348 KB
testcase_35	AC	766 ms 79,432 KB
testcase_36	AC	639 ms 74,740 KB
testcase_37	AC	700 ms 74,684 KB
testcase_38	AC	749 ms 74,392 KB
testcase_39	AC	565 ms 73,656 KB
testcase_40	AC	589 ms 75,420 KB
testcase_41	AC	256 ms 72,432 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

package no2xxx;

import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Queue;
import java.util.function.IntUnaryOperator;
import java.util.function.LongPredicate;
import java.util.function.LongUnaryOperator;

public class No2617 {
	InputStream is;
	FastWriter out;

	String INPUT = "";

	public void solve()
	{
		// 3
		// 2+1
		// 2
		// 1+1+1
		// 1+1
		// 1

		// 3の個数n3を決める
		// 残りのナップザックはK-n3個
		// 2の個数n2を決める
		// 1の個数は3(K-n3)-2n2個になる

		int n = ni(), K = ni();
		long seed = ni();
		long a = nl(), b = nl();
		int m = ni();
		long[] f = new long[2*n];
		f[0] = seed;
		for(int i = 1;i < 2*n;i++){
			f[i] = (f[i-1] * a + b) % m;
		}
		int[] ws = new int[n];
		long[] vs = new long[n];
		for(int i = 0;i < n;i++){
			ws[i] = (int)(f[i]%3 + 1);
			vs[i] = (f[i+n] * ws[i]);
		}
		long[][] g = packD(4, ws, vs);
		for(long[] e : g){
			Arrays.sort(e);
			rev_(e);
		}
//		tr(g);

		cs = new long[4][];
		for(int i = 0;i < 4;i++)cs[i] = buildcum(g[i]);

		long ans = 0;
		for(int n3 = 0;n3 <= K && n3 <= g[3].length;n3++){
			int r = K-n3;
			long hh = maxlow(0, K - n3 + 1, h -> get(g[2], (int) h - 1) >= get(g[1], (int) (3 * r - 2 * h - 1)) + get(g[1], (int) (3 * r - 2 * h - 2)));
			{
				long val = get1(cs[2], (int)hh) + get1(cs[1], (int) (3 * r - 2 * hh)) + cs[3][n3];
				ans = Math.max(ans, val);
			}
			if(hh+1 <= K-n3){
				hh++;
				long val = get1(cs[2], (int)hh) + get1(cs[1], (int) (3 * r - 2 * hh)) + cs[3][n3];
				ans = Math.max(ans, val);
			}
//			bsdebug(0, K-n3+1, h -> get(g[2], (int)h-1) >= get(g[1], (int)(3*r-2*h-1)) + get(g[1], (int)(3*r-2*h-2)));
//			for(int n2 = 0;n2 <= r;n2++){
//				long val = get(cs[2], (int) n2) + get(cs[1], (int) (3 * r - 2 * n2)) + cs[3][n3];
//				if(val > ans){
//					tr(n2, n3);
//				}
//				ans = Math.max(ans, val);
//			}
			//			tr(n3, hh, val, get(cs[2], (int)hh), get(cs[1], (int)(3*r-2*hh)), cs[3][n3]);
		}
		out.println(ans);
	}

	public static long[] rev_(long[] a){for(int i = 0, j = a.length-1;i < j;i++,j--){long c = a[i]; a[i] = a[j]; a[j] = c;}return a;}

	public static long get1(long[] a, int ind)
	{
		return a[Math.max(0, Math.min(a.length-1, ind))];
	}

	public static long get(long[] a, int ind)
	{
		if(a.length == 0)return 0;
		if(ind >= a.length)return 0;
		return a[Math.max(0, Math.min(a.length-1, ind))];
	}

	static long[][] cs;

	public static void trx(Object... o) { System.out.println(Arrays.deepToString(o)); }

	public static long maxlow(long low, long high, LongPredicate sameaslow)
	{
		while(high-low > 1){
			long h = high+low>>>1;
			if(sameaslow.test(h)){
				low = h;
			}else{
				high = h;
			}
		}
		return low;
	}

	public static void bsdebug(long low, long high, LongPredicate sameaslow)
	{
		boolean ye = true;
		long invalid = -1;
		for(long x = low;x < high;x++){
			boolean v = sameaslow.test(x);
			if(!ye && v && invalid == -1){
				invalid = x;
			}
			ye = v;
			trx(x, sameaslow.test(x));
		}
		if(invalid != -1){
			throw new RuntimeException("invalid: " + invalid);
		}
	}


	public static long[] buildcum(long[] a) {
		long[] b = new long[a.length+1];
		for(int i = 0;i < a.length;i++)b[i+1] = b[i] + a[i];
		return b;
	}


	public static long[][] packD(int n, int[] from, long[] to) {
		return packD(n, from, to, from.length);
	}

	public static long[][] packD(int n, int[] from, long[] to, int sup) {
		long[][] g = new long[n][];
		int[] p = new int[n];
		for (int i = 0; i < sup; i++) p[from[i]]++;
		for (int i = 0; i < n; i++) g[i] = new long[p[i]];
		for (int i = 0; i < sup; i++) {
			g[from[i]][--p[from[i]]] = to[i];
		}
		return g;
	}


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

	public void run()
	{
		long S = System.currentTimeMillis();
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new FastWriter(System.out);

		solve();
		out.flush();
		long G = System.currentTimeMillis();
		tr(G-S+"ms");
		//		Thread t = new Thread(null, null, "~", Runtime.getRuntime().maxMemory()){
		//			@Override
		//			public void run() {
		//				long s = System.currentTimeMillis();
		//				solve();
		//				out.flush();
		//				if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
		//			}
		//		};
		//		t.start();
		//		t.join();
	}

	private 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 final byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private 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 boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	//	private boolean isSpaceChar(int c) { return !(c >= 32 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private 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 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 int[][] nmi(int n, int m)
	{
		int[][] map = new int[n][];
		for(int i = 0;i < n;i++)map[i] = na(m);
		return map;
	}

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

	private long[] nal(int n)
	{
		long[] a = new long[n];
		for(int i = 0;i < n;i++)a[i] = nl();
		return a;
	}

	private 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 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();
		}
	}

	public static class FastWriter
	{
		private static final int BUF_SIZE = 1<<13;
		private final byte[] buf = new byte[BUF_SIZE];
		private final OutputStream out;
		private int ptr = 0;

		private FastWriter(){out = null;}

		public FastWriter(OutputStream os)
		{
			this.out = os;
		}

		public FastWriter(String path)
		{
			try {
				this.out = new FileOutputStream(path);
			} catch (FileNotFoundException e) {
				throw new RuntimeException("FastWriter");
			}
		}

		public FastWriter write(byte b)
		{
			buf[ptr++] = b;
			if(ptr == BUF_SIZE)innerflush();
			return this;
		}

		public FastWriter write(char c)
		{
			return write((byte)c);
		}

		public FastWriter write(char[] s)
		{
			for(char c : s){
				buf[ptr++] = (byte)c;
				if(ptr == BUF_SIZE)innerflush();
			}
			return this;
		}

		public FastWriter write(String s)
		{
			s.chars().forEach(c -> {
				buf[ptr++] = (byte)c;
				if(ptr == BUF_SIZE)innerflush();
			});
			return this;
		}

		private static int countDigits(int l) {
			if (l >= 1000000000) return 10;
			if (l >= 100000000) return 9;
			if (l >= 10000000) return 8;
			if (l >= 1000000) return 7;
			if (l >= 100000) return 6;
			if (l >= 10000) return 5;
			if (l >= 1000) return 4;
			if (l >= 100) return 3;
			if (l >= 10) return 2;
			return 1;
		}

		public FastWriter write(int x)
		{
			if(x == Integer.MIN_VALUE){
				return write((long)x);
			}
			if(ptr + 12 >= BUF_SIZE)innerflush();
			if(x < 0){
				write((byte)'-');
				x = -x;
			}
			int d = countDigits(x);
			for(int i = ptr + d - 1;i >= ptr;i--){
				buf[i] = (byte)('0'+x%10);
				x /= 10;
			}
			ptr += d;
			return this;
		}

		private static int countDigits(long l) {
			if (l >= 1000000000000000000L) return 19;
			if (l >= 100000000000000000L) return 18;
			if (l >= 10000000000000000L) return 17;
			if (l >= 1000000000000000L) return 16;
			if (l >= 100000000000000L) return 15;
			if (l >= 10000000000000L) return 14;
			if (l >= 1000000000000L) return 13;
			if (l >= 100000000000L) return 12;
			if (l >= 10000000000L) return 11;
			if (l >= 1000000000L) return 10;
			if (l >= 100000000L) return 9;
			if (l >= 10000000L) return 8;
			if (l >= 1000000L) return 7;
			if (l >= 100000L) return 6;
			if (l >= 10000L) return 5;
			if (l >= 1000L) return 4;
			if (l >= 100L) return 3;
			if (l >= 10L) return 2;
			return 1;
		}

		public FastWriter write(long x)
		{
			if(x == Long.MIN_VALUE){
				return write("" + x);
			}
			if(ptr + 21 >= BUF_SIZE)innerflush();
			if(x < 0){
				write((byte)'-');
				x = -x;
			}
			int d = countDigits(x);
			for(int i = ptr + d - 1;i >= ptr;i--){
				buf[i] = (byte)('0'+x%10);
				x /= 10;
			}
			ptr += d;
			return this;
		}

		public FastWriter write(double x, int precision)
		{
			if(x < 0){
				write('-');
				x = -x;
			}
			x += Math.pow(10, -precision)/2;
			//		if(x < 0){ x = 0; }
			write((long)x).write(".");
			x -= (long)x;
			for(int i = 0;i < precision;i++){
				x *= 10;
				write((char)('0'+(int)x));
				x -= (int)x;
			}
			return this;
		}

		public FastWriter writeln(char c){ return write(c).writeln(); }
		public FastWriter writeln(int x){ return write(x).writeln(); }
		public FastWriter writeln(long x){ return write(x).writeln(); }
		public FastWriter writeln(double x, int precision){ return write(x, precision).writeln(); }

		public FastWriter write(int... xs)
		{
			boolean first = true;
			for(int x : xs) {
				if (!first) write(' ');
				first = false;
				write(x);
			}
			return this;
		}

		public FastWriter write(long... xs)
		{
			boolean first = true;
			for(long x : xs) {
				if (!first) write(' ');
				first = false;
				write(x);
			}
			return this;
		}

		public FastWriter write(IntUnaryOperator f, int... xs)
		{
			boolean first = true;
			for(int x : xs) {
				if (!first) write(' ');
				first = false;
				write(f.applyAsInt(x));
			}
			return this;
		}

		public FastWriter write(LongUnaryOperator f, long... xs)
		{
			boolean first = true;
			for(long x : xs) {
				if (!first) write(' ');
				first = false;
				write(f.applyAsLong(x));
			}
			return this;
		}

		public FastWriter writeln()
		{
			return write((byte)'\n');
		}

		public FastWriter writeln(int... xs) { return write(xs).writeln(); }
		public FastWriter writeln(long... xs) { return write(xs).writeln(); }
		public FastWriter writeln(IntUnaryOperator f, int... xs) { return write(f, xs).writeln(); }
		public FastWriter writeln(LongUnaryOperator f, long... xs) { return write(f, xs).writeln(); }
		public FastWriter writeln(char[] line) { return write(line).writeln(); }
		public FastWriter writeln(char[]... map) { for(char[] line : map)write(line).writeln();return this; }
		public FastWriter writeln(String s) { return write(s).writeln(); }

		private void innerflush()
		{
			try {
				out.write(buf, 0, ptr);
				ptr = 0;
			} catch (IOException e) {
				throw new RuntimeException("innerflush");
			}
		}

		public void flush()
		{
			innerflush();
			try {
				out.flush();
			} catch (IOException e) {
				throw new RuntimeException("flush");
			}
		}

		public FastWriter print(byte b) { return write(b); }
		public FastWriter print(char c) { return write(c); }
		public FastWriter print(char[] s) { return write(s); }
		public FastWriter print(String s) { return write(s); }
		public FastWriter print(int x) { return write(x); }
		public FastWriter print(long x) { return write(x); }
		public FastWriter print(double x, int precision) { return write(x, precision); }
		public FastWriter println(char c){ return writeln(c); }
		public FastWriter println(int x){ return writeln(x); }
		public FastWriter println(long x){ return writeln(x); }
		public FastWriter println(double x, int precision){ return writeln(x, precision); }
		public FastWriter print(int... xs) { return write(xs); }
		public FastWriter print(long... xs) { return write(xs); }
		public FastWriter print(IntUnaryOperator f, int... xs) { return write(f, xs); }
		public FastWriter print(LongUnaryOperator f, long... xs) { return write(f, xs); }
		public FastWriter println(int... xs) { return writeln(xs); }
		public FastWriter println(long... xs) { return writeln(xs); }
		public FastWriter println(IntUnaryOperator f, int... xs) { return writeln(f, xs); }
		public FastWriter println(LongUnaryOperator f, long... xs) { return writeln(f, xs); }
		public FastWriter println(char[] line) { return writeln(line); }
		public FastWriter println(char[]... map) { return writeln(map); }
		public FastWriter println(String s) { return writeln(s); }
		public FastWriter println() { return writeln(); }
	}

	public static void trnz(int... o)
	{
		for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
		System.out.println();
	}

	// print ids which are 1
	public static void trt(long... o)
	{
		Queue<Integer> stands = new ArrayDeque<>();
		for(int i = 0;i < o.length;i++){
			for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
		}
		System.out.println(stands);
	}

	public static void tf(boolean... r)
	{
		for(boolean x : r)System.out.print(x?'#':'.');
		System.out.println();
	}

	public static void tf(boolean[]... b)
	{
		for(boolean[] r : b) {
			for(boolean x : r)System.out.print(x?'#':'.');
			System.out.println();
		}
		System.out.println();
	}

	public void tf(long[]... b)
	{
		if(INPUT.length() != 0) {
			for (long[] r : b) {
				for (long x : r) {
					for (int i = 0; i < 64; i++) {
						System.out.print(x << ~i < 0 ? '#' : '.');
					}
				}
				System.out.println();
			}
			System.out.println();
		}
	}

	public void tf(long... b)
	{
		if(INPUT.length() != 0) {
			for (long x : b) {
				for (int i = 0; i < 64; i++) {
					System.out.print(x << ~i < 0 ? '#' : '.');
				}
			}
			System.out.println();
		}
	}

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

yukicoder

結果

テストケース

ソースコード