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

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

E und F werden in Kürze aktualisiert

A - Rounding

	private void solveA() {
		int x = nextInt();
		int a = nextInt();

		out.println(x < a ? 0 : 10);
	}

B - Bounding

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

		int d = 0;
		//Achten Sie auf D1=Da es bei 0 springt, beginnt es bei 1
		int cnt = 1;

		for (int i = 0; i < wk.length; i++) {
			d = d + wk[i];
			if (d <= x) {
				cnt++;
			}
		}

		out.println(cnt);
	}

C - Rectangle Cutting

• Ich habe es falsch verstanden
• Über "Teilen eines Rechtecks in zwei Teile mit einer geraden Linie durch" (x, y) "
• Die gerade Linie durch "(x, y) schneidet den Außenumfang des Rechtecks im rechten Winkel". (Das Thema ist nicht immer richtig)
• Wenn es den Außenumfang nicht rechtwinklig schneidet, ist es möglich, das Rechteck in zwei gleiche Teile zu teilen, indem eine gerade Linie durch den Schwerpunkt des Rechtecks gezogen wird (weil es ein Rechteck ist).
• Daher beträgt der maximal geteilte Wert die Hälfte der Fläche des ursprünglichen Rechtecks. --Wenn "(x, y) der Schwerpunkt ist, können Sie mehrere gerade Linien zum Teilen zeichnen"
• Wenn (x, y) nicht der Schwerpunkt ist, kann nur eine gerade Linie gezeichnet werden.

	private void solveC() {
		double w = nextInt();
		double h = nextInt();
		double x = nextInt();
		double y = nextInt();

		double res = (w * h) / 2;
		String ref = String.format("%.10f", res);
		int bF = 0;
		if (w == 2 * x && h == 2 * y) {
			bF = 1;
		}
		out.println(ref + " " + bF);
	}

D - Enough Array

• Es wird einfacher, wenn Sie das Problem lesen können ―― Anstatt nach "Kombinationen, die K überschreiten" zu suchen, "subtrahieren Sie Kombinationen, die K nicht überschreiten, von der Gesamtzahl der Kombinationen". ――Bei diesem Vorgang können Sie nach der Skalierungsmethode zählen. ――Ich denke, es gibt eine Möglichkeit, "Kombinationen zu zählen, die K überschreiten", aber ich konnte mir das nicht vorstellen.

	private void solveD() {
		int n = nextInt();
		long k = nextLong();
		//		int[] wk = IntStream.range(0, n).map(i -> nextInt()).toArray();
		long[] wk = new long[n];
		for (int i = 0; i < n; i++) {
			wk[i] = nextLong();
		}

		long res = 0;
		long total = 0;
		int right = 0;
		/*
		 *Es scheint schwierig zu sein, "Kombinationen zu zählen, die K überschreiten"
		 *Mit der Politik "Kombinationen, die K nicht überschreiten, von der Gesamtzahl der Kombinationen zu subtrahieren"
		 */
		for (int left = 0; left < n; left++) {
			//wk bis total[right]Wenn Sie richtig hinzufügen können++
			while (right < n && total + wk[right] < k) {
				total += wk[right];
				right++;
			}
			//rechts ist das Maximum, das die Bedingung erfüllt
			res += (right - left);

			if (right == left) {
				right++;
			} else {
				total -= wk[left];
			}

		}

		/*
		 *Gesamtzahl der Kombinationen, die k ignorieren
		 *Weil es eine Unterspalte ist, n* (n+1)
		 *Wenn Sie vergessen, zu lange zu wirken, wird es zu int und WA
		 */
		long totalCnt = (long) n * ((long) n + 1L) / 2L;
		out.println(totalCnt - res);
	}