[JAVA] ABC --017 --A & B & C

AtCoder ABC 017 A&B&C AtCoder - 017

A --Procon

	private void solveA() {
		int res = 0;
		for (int i = 0; i < 3; i++) {
			int point = nextInt();
			int ratio = nextInt();
			res += point * ratio / 10;
		}

		out.println(res);
	}

B --choku

--Si'ch''o''k''u'est inclus, ce ne sera pas un mot choku --Si vous remplacez all'ch''o''k''u 'par des caractères vides, la longueur de la valeur d'entrée sera 0. ―― Je pense qu'il est normal de vérifier un par un au lieu de remplacer, mais java est plus facile à remplacer.

	private void solveB() {
		String res = next().replaceAll("ch", "").replaceAll("o", "").replaceAll("k", "").replaceAll("u", "");

		out.println(res.length() == 0 ? "YES" : "NO");
	}

C - Score élevé

Boucle (point partiel 30 + 70 / TLE)

• Du problème -Ne prenez pas toutes sortes de bijoux ――Quel des types de bijoux 1-n est le plus gratifiant à ne pas prendre? Peut être lu comme ―― Quelles ruines explorez-vous? Quel bijou ne doit pas être pris, non? Pensez avec ――Lorsque vous prenez un certain type de bijou, il vaut mieux prendre tous le même genre de bijoux dans d'autres ruines

• Si vous lisez la question, ce sera "trouver le score maximum quand vous ne prenez pas un certain bijou".

• $ Si vous ne prenez pas Jewel 1, si vous ne prenez pas Jewel 2, si vous ne prenez pas Jewel 3 ... Si vous ne prenez pas Jewel N $ ――Si vous tournez simplement la boucle, elle ne sera jamais dans le temps, alors essayez-la comme une somme cumulative

• Exemple d'entrée 1:

4 6 1 3 30 2 3 40 3 6 25 6 6 10

――Par exemple, si vous décidez de ne pas prendre 1 bijou, ce sera comme suit

• Vous ne pouvez pas aller aux Ruines 1
• Les ruines 2 et 3 sont accessibles
• Ruines 4 ne peut pas aller
• Si vous ne prenez pas 1-3, vous n'obtiendrez pas ce score, mais si vous décidez de ne pas prendre 4-6, vous obtiendrez ce score.

――Si tel est le cas, le dernier ne sera pas inclus «Cependant, j'ai senti que la partie de la somme cumulative pouvait être implémentée par la méthode« Imos », j'ai donc essayé une autre solution.

	private void solveC2() {
		int n = nextInt();
		int m = nextInt();

		int[] l = new int[n];
		int[] r = new int[n];
		int[] s = new int[n];
		int[][] res = new int[m + 1][1];
		for (int i = 0; i < n; i++) {
			l[i] = nextInt();
			r[i] = nextInt();
			s[i] = nextInt();
			for (int j = 1; j <= m; j++) {
				if (j < l[i] || r[i] < j) {
					res[j][0] += s[i];
				}
			}
		}

		Arrays.sort(res, (x, y) -> -Integer.compare(x[0], y[0]));
		out.println(res[0][0]);
	}

Méthode IMOS (méthode de solution en 101 points)

--Site de référence (méthode Imos et somme cumulée)

• Imosho
• Résumé de la méthode imos et du problème des sommes cumulées dans la programmation compétitive
• Etre capable d'écrire la somme cumulée sans réfléchir!
  • ABC - 035- A&B&C

Correction de la partie suivante de la solution ci-dessus

			for (int j = 1; j <= m; j++) {
				if (j < l[i] || r[i] < j) {
					res[j][0] += s[i];
				}
			}

	private void solveC() {
		int n = nextInt();
		int m = nextInt();

		int[] l = new int[n];
		int[] r = new int[n];
		int[] s = new int[n];
		int[] res = new int[m];
		for (int i = 0; i < n; i++) {
			l[i] = nextInt() - 1;
			r[i] = nextInt() - 1;
			s[i] = nextInt();
			res[0] += s[i];
			res[l[i]] -= s[i];
			if (r[i] < m - 1) {
				res[r[i] + 1] += s[i];
			}
		}

		for (int i = 1; i < res.length; i++) {
			res[i] = res[i] + res[i - 1];
		}
		Arrays.sort(res);
		out.println(res[m - 1]);
	}