[JAVA] ABC - 133 - A & B & C & D.

AtCoder ABC 133 A&B&C&D AtCoder - 133

A - T or T

	private void solveA() {
		int n = nextInt();
		int a = nextInt();
		int b = nextInt();

		out.println(n * a > b ? b : n * a);
	}

B - Good Distance

• Vergessen Sie nicht die Bedingung von $ (i <j) $

	private void solveB() {
		int n = nextInt();
		int d = nextInt();
		int[][] wk = Stream.generate(() -> IntStream.range(0, d).map(i -> nextInt()).toArray()).limit(n)
				.toArray(int[][]::new);

		int res = 0;
		for (int i = 0; i < n; i++) {
			//i <Anmerkung j
			for (int j = i + 1; j < n; j++) {
				long tmp = 0;
				for (int k = 0; k < d; k++) {
					tmp += Math.pow(wk[i][k] - wk[j][k], 2);
				}
				long tmpRes = (long) Math.sqrt(tmp);
				if (Math.pow(tmpRes, 2) == tmp) {
					res++;
				}
			}
		}

		out.println(res);
	}

C - Remainder Minimization 2019

――Was können Sie tun, wenn Sie das Maximum (r) reduzieren?

• Da es Mod 2019 ist, wiederholt sich die Nummer 0 - 2018
• Wiederholen Sie 0-2018 ab l
• Anstatt alles von $ l bis r $ auszuprobieren, versuchen Sie es mit dem kleineren von $ l bis min (l + (2019 * 2), r) $.
• $ 0,1,2 ・ ・ ,0 2018,0,1,2, ・ ・ ・ Wenn Sie bis zu $ 2018 versuchen, können Sie die Kombination von 0,0 auswählen, die der Mindestwert ist.
• Das ideale Minimum von zwei Zahlen ist eine Kombination von 0,0
• Wenn r-l größer als 2019 ist * 2
• Dies ist nicht der Fall, wenn r-l kleiner als 2019 * 2 ist.

	private void solveC() {
		final int CONST_MOD = 2019;
		int l = nextInt();
		int r = nextInt();
		/*
		 *Nichts kann getan werden, ohne das Maximum vorerst zu reduzieren.
		 * l+Nehmen Sie den kleineren Wert von 2019 oder r als Maximalwert an (da es sich um einen MOD handelt).
		 * l+Ein Zyklus im Jahr 2019. Damit kommt der Mindestwert jedoch nur einmal heraus.
		 * +(2019*2)Wenn Sie zwei Runden fahren, erscheint 1 zweimal.
		 *
		 */
		int wkR = Math.min(l + (CONST_MOD * 2), r);
		int res = 2020;
		for (int i = l; i <= wkR; i++) {
			for (int j = i + 1; j <= wkR; j++) {
				res = Math.min(((i % CONST_MOD) * (j % CONST_MOD)) % CONST_MOD, res);
			}
		}

		out.println(res);
	}

D - Rain Flows into Dams

• Gleichzeitige Gleichungen wurden aufgestellt und gelöst
• Berechnen Sie die Versandkosten des Damms und fragen Sie nach dem Regen eines Berges ――Wenn Sie sich für einen Berg entscheiden, können Sie sich für den anderen entscheiden
• Da die Anzahl der Berge ungerade ist, steigt sie mit 1-> 3-> 5-> 7-> 9 ...
• Da es immer zwei Peaks gibt, wiederholt sich die Formel +-wie folgt:
• Berg A = Damm 1 - Damm 2 + Damm 3 - Damm 4 + Damm 5 - + - + - + ・ ・ ・

Beispiel: 2

	 
Damm 1=Berg A./2 +Berg B./2  ->Damm 1*2 =Berg A. +Berg B.  -> Berg B. =Damm 1*2 -Berg A.
Damm 2=Berg B./2 +Berg C./2  ->Damm 2*2 =Berg B. +Berg C.  -> Berg C. =Damm 2*2 -Berg B.
Damm 3=Berg C./2 +Berg D./2  ->Damm 3*2 =Berg C. +Berg D.  -> Berg D. =Damm 3*2 -Berg C.
Damm 4=Berg D./2 +Berg E./2  ->Damm 4*2 =Berg D. +Berg E.  -> Berg E. =Damm 4*2 -Berg D.
Damm 5=Berg E./2 +Berg A./2  ->Damm 5*2 =Berg E. +Berg A.  -> Berg A. =Damm 5*2 -Berg E.

Finden Sie zuerst Berg A, indem Sie die obige Gleichung transformieren
Berg A.=Damm 1-Damm 2+Damm 3-Damm 4+Damm 5
	 
Wenn Berg A entschieden wird, wird es nach Berg B entschieden
Berg B.=Damm 1*2 -Berg A.
Berg C.=Damm 2*2 -Berg B.
Berg D.=Damm 3*2 -Berg C.
Berg E.=Damm 4*2 -Berg D.

	private void solveD() {
		int n = nextInt();
		int[] wk = IntStream.range(0, n).map(i -> nextInt()).toArray();

		long a = 0;

                //Der gerade nummerierte Damm+Die ungerade Anzahl von Dämmen-
		for (int i = 0; i < wk.length; i++) {
			if (i % 2 == 0) {
				a += wk[i];
			} else {
				a -= wk[i];
			}
		}
		long[] mountain = new long[n];
		mountain[0] = a;
		//Der letzte Berg ist Berg A, daher ist er ausgeschlossen
		for (int i = 0; i < mountain.length - 1; i++) {
			mountain[i + 1] = wk[i] * 2 - mountain[i];
		}
		StringBuilder builder = new StringBuilder();
		for (long l : mountain) {
			builder.append(l + " ");
		}
		out.println(builder.toString().trim());
	}