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

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

E et F seront bientôt mis à jour

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;
		//Assurez-vous de D1=Puisqu'il rebondit à 0, il part de 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

• Je l'ai mal lu
• A propos de diviser un rectangle en deux parties avec une ligne droite passant par (x, y)--La ligne droite passant par(x, y) coupe la circonférence extérieure du rectangle à angle droit. (Le sujet n'est pas toujours juste) --S'il ne coupe pas la circonférence extérieure à angle droit, il est possible de faire le `` rectangulaire en deux parties égales '' en traçant une ligne droite passant par le centre de gravité du rectangle (car il s'agit d'un rectangle)
• Par conséquent, la valeur divisée maximale correspond à la moitié de la surface du rectangle d'origine. --Lorsque (x, y) est le centre de gravité, vous pouvez dessiner plusieurs lignes droites à diviser
• Au contraire, si (x, y) n'est pas le centre de gravité, une seule ligne droite peut être dessinée.

	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

• Ce sera plus facile si vous pouvez lire le problème ―― Plutôt que de rechercher des «combinaisons qui dépassent K», «soustrayez les combinaisons qui ne dépassent pas K du nombre total de combinaisons» ―― En faisant cela, vous pourrez compter par la méthode de l'échelle. «Je pense qu'il existe un moyen de compter les« combinaisons qui dépassent K », mais je ne pouvais pas y penser.

	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;
		/*
		 *Il semble difficile de compter les "combinaisons qui dépassent K", donc
		 *Avec la politique de "soustraire les combinaisons qui ne dépassent pas K du nombre total de combinaisons"
		 */
		for (int left = 0; left < n; left++) {
			//sem au total[right]Bien si vous pouvez ajouter++
			while (right < n && total + wk[right] < k) {
				total += wk[right];
				right++;
			}
			//right est le maximum qui satisfait la condition
			res += (right - left);

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

		}

		/*
		 *Nombre total de combinaisons ignorant k
		 *Parce que c'est une sous-colonne, n* (n+1)
		 *Si vous oubliez de lancer trop longtemps, il devient int et WA
		 */
		long totalCnt = (long) n * ((long) n + 1L) / 2L;
		out.println(totalCnt - res);
	}