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

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

Je serai de retour pour résoudre E & F dans un proche avenir.

A - Apple Pie

	private void solveA() {

		out.println((nextInt() * 3 + nextInt()) / 2);
	}

B - Guidebook

--Maintenez [] [] de la chaîne de caractères, triez dans l'ordre des caractères par [] [0], et si [] [0] sont identiques, convertissez [] [1] en valeur numérique et triez par ordre décroissant

	private void solveB() {
		int n = nextInt();
		String[][] s = new String[n][3];

		for (int i = 0; i < n; i++) {
			s[i][0] = next();
			s[i][1] = next();
			s[i][2] = Integer.toString(i + 1);
		}
		Arrays.sort(s,
				(x, y) -> {
					if (x[0].compareTo(y[0]) < 0) {
						return -1;
					} else if (x[0].compareTo(y[0]) > 0) {
						return 1;
					} else {
						return -Integer.compare(Integer.parseInt(x[1]), Integer.parseInt(y[1]));
					}
				});

		for (int i = 0; i < s.length; i++) {
			out.println(s[i][2]);
		}
	}

C - Switches

--Recherche complète en utilisant un bit devenu possible d'écrire progressivement

• Commutateurs 1-5, le nombre de commutateurs qui doivent être ON \ Numéro de commutateur

• L'ampoule numéro 1 peut être utilisée avec 1, 2, 5 interrupteurs, et même 1, 2, 5 (deux dans cet exemple) doit être allumée. ――Il est NG que tous les 1,2,5 soient ON, et ON / OFF de 3,4 n'est pas pertinent. ――Pour l'ampoule numéro 2, les interrupteurs qui peuvent être utilisés sont 2,3 et un nombre impair de 2,3 (un dans cet exemple) doit être allumé. ――Il est NG que 2 et 3 soient tous les deux sur ON, et ON / OFF de 1,4,5 n'est pas pertinent.

Il y a donc autant d'options que $ 2 ^ {nombre de commutateurs} $

Plus précisément, essayez le modèle suivant ($ 2 ^ {nombre de commutateurs} $) Prenant l'exemple de sortie 3 comme exemple

	private void solveC() {
		int n = nextInt();
		int m = nextInt();
		int[] k = new int[m];

		List<List<Integer>> s = new ArrayList<List<Integer>>();
		for (int i = 0; i < k.length; i++) {
			k[i] = nextInt();
			List<Integer> temp = new ArrayList<Integer>();
			for (int j = 0; j < k[i]; j++) {
				temp.add(nextInt());
			}
			s.add(temp);
		}
		int[] p = IntStream.range(0, m).map(i -> nextInt()).toArray();

		long res = 0;
		for (int i = 0; i < 1 << n; i++) {
			boolean isResult = true;
			for (int j = 0; j < m; j++) {
				//Obtenez la liste des boutons de l'ampoule j
				List<Integer> sList = s.get(j);
				//Est-il pair ou étrange que l'ampoule j soit allumée?
				int compareBase = p[j];
				//Combien de boutons nécessaires pour allumer l'ampoule j sont allumés
				int compare = 0;
				for (Integer buttonNum : sList) {
					/*
					 *Trouvez le bouton ON dans la liste des boutons de l'ampoule j
					 * buttonNum - 1　->Numéro de bouton(Selon l'arrangement-1)
					 * (i & (1 << (buttonNum - 1))　->Y a-t-il un drapeau à la position du numéro de bouton?
					 */
					if ((i & (1 << (buttonNum - 1))) >= 1) {
						compare++;
					}
				}
				//Juger le nombre de chances et de chances que le bouton soit allumé et juger si l'exigence de l'ampoule j est satisfaite
				if (compareBase != compare % 2) {
					isResult = false;
					break;
				}
			}
			if (isResult) {
				//Ce modèle a toutes les ampoules allumées
				res++;
			}

		}

		out.println(res);
	}

D - equeue

--Effectuez les 4 opérations suivantes ―― 1: prendre à gauche ―― 2: prendre de la droite ―― 3: Jetez votre main et placez-la à gauche ―― 4: Jetez votre main et placez-la à droite ―― 3 et 4 peuvent être effectués en même temps à la fin de l'opération (l'idée de jeter les choses inutiles à la fin), alors effectuez les opérations suivantes dans tous les modèles --De la gauche, prenez $ 0-max (n, K) $ fois --De la droite, prenez $ 0-min (n, (temps pris de k-l)) $ fois

• $ (temps pris de k-l) $ minutes, gauche ou droite de la main
• Puisqu'il s'agit d'une opération d'élimination, elle peut être à gauche ou à droite. Je ne le prendrai pas après l'avoir jeté -En outre, il vaut la peine de jeter les objets inférieurs à 0 (jeter augmentera la valeur de votre possession), mais si vous jetez 0 ou plus, la valeur de votre possession diminuera, vous n'avez donc pas besoin de jeter

	private void solveD() {
		int n = nextInt();
		int k = nextInt();
		long[] wk = new long[n];
		for (int i = 0; i < n; i++) {
			wk[i] = nextInt();
		}
		long res = 0;
		//Prenez autant que vous pouvez de la gauche
		for (int l = 0; l <= k; l++) {
			//Prenez autant que vous pouvez de la droite
			for (int r = 0; r <= k; r++) {
				//Pause si le nombre d'opérations dépasse k
				if (l + r > k) {
					break;
				}

				//Total disponible pour le moment
				long now = 0;
				List<Long> s = new ArrayList<Long>();
				int pickCount = 0;
				//Ajouter uniquement le montant obtenu du côté gauche
				for (int i = 0; i < Integer.min(l, n); i++) {
					long tmp = wk[i];
					now += tmp;
					s.add(tmp);
					pickCount++;
				}
				/*
				 *Ajouter uniquement le montant obtenu du côté droit
				 *Je joue avec max sur le côté droit
				 * 	-Parce que le nombre d'opérations (K) peut être supérieur à N
				 *  -Il y a deux boucles, l'une du côté gauche et l'autre du côté droit.
				 *Si K est supérieur à N, cela peut prendre la même chose
				 *Par conséquent, le nombre d'acquisition maximum d'origine de r et le nombre acquis par l sont comparés.
				 *  　e.g.K>=Si N, l Entier.min(l, n)Et n est retourné.
				 */
				for (int i = n - 1; i > Integer.max(n - 1 - r, Integer.min(l, n)); i--) {
					long tmp = wk[i];
					now += tmp;
					s.add(tmp);
					pickCount++;
				}
				//Disposez-les de manière à ne pas en avoir besoin pour jeter les extras
				Collections.sort(s);

				//Le nombre de fois où vous pouvez jeter l'acquisition supplémentaire
				int d = k - pickCount;
				//Tu ne peux pas jeter plus que ce nombre de fois
				for (int i = 0; i < Integer.min(d, s.size()); i++) {
					//
					//Si la valeur du bijou retiré n'est pas négative, il n'est pas nécessaire de le jeter
					if (s.get(i) > 0) {
						break;
					}

					//Jetez les bijoux à valeur négative
					now -= s.get(i);
				}
				res = Long.max(res, now);
			}
		}
		out.println(res);
	}