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

AtCoder ABC 025 A&B&C AtCoder - 025

Un problème

• Étant donné que les chaînes de caractères d'entrée sont disposées dans l'ordre croissant, essayez d'assembler les caractères tels qu'ils sont -Si [a, b, c, d, e] est la valeur d'entrée
• [a, a] [a, b] [a, c] ・ ・ ・ [b, a] [b, b] [b, c] ・ ・ ・ [e, a] [e, b] ・ ・ ・ [e, e] ――En raison de l'ordre croissant, même si vous tournez la boucle telle quelle, elle sera dans l'ordre du dictionnaire

	private void solveA() {
		char[] wk = next().toCharArray();
		int n = nextInt();

		int cnt = 0;
		for (int i = 0; i < wk.length; i++) {
			for (int j = 0; j < wk.length; j++) {
				cnt++;
				if (n == cnt) {
					out.println((char) wk[i] + "" + (char) wk[j]);
					return;
				}
			}
		}

	}

Problème B

• Décision décisive comme suit --Lorsque vous êtes à l'est, + coordonnées --Quand dans l'ouest-Coordonnées --Dans un état fixe, entrez simplement $ \ pm $ pour voir si vous êtes à l'est ou à l'ouest à la fin.

Hmmm. Stream semble n'avoir aucun mérite même s'il est utilisé dans un tel endroit.

	private void solveB() {
		int n = nextInt();
		int a = nextInt();
		int b = nextInt();
		long res = 0;

		res = IntStream.range(0, n).reduce(0, (sum, i) -> {
			String direction = next();
			int meter = nextInt();
			long move = meter < a ? a : meter > b ? b : meter;
			switch (direction) {
			case "East":
				sum -= move;
				break;
			case "West":
				sum += move;
				break;
			default:
				throw new IllegalArgumentException();
			}
			return sum;
		});
		//--------------------------------------------------------
		//		String[] direction = new String[n];
		//		int[] meter = new int[n];
		//
		//		for (int i = 0; i < n; i++) {
		//			direction[i] = next();
		//			meter[i] = nextInt();
		//			long move = meter[i] < a ? a : meter[i] > b ? b : meter[i];
		//			switch (direction[i]) {
		//			case "East":
		//				res -= move;
		//				break;
		//			case "West":
		//				res += move;
		//				break;
		//			default:
		//				throw new IllegalArgumentException();
		//			}
		//		}
		//--------------------------------------------------------

		out.println(res == 0 ? 0 : res > 0 ? "West " + res : "East " + res * -1);
	}

Problème C

――Dans l'explication, ça a commencé à partir du virage = 9, mais il y avait une partie que je ne pouvais pas rattraper, alors j'ai décidé de comparer tous les points lorsque j'ai mis les pierres dans l'ordre du virage = 1 ( En conséquence, on l'appelle une fonction récursive 623530 fois) ――Je veux mettre les deux au meilleur endroit, donc j'adopterai le score maximum à ce tour

• Il semble que vous puissiez faire un mémo rapidement, mais je n'ai pas pu bien faire un mémo, alors j'essaierai de m'en occuper la prochaine fois

	private void solveC() {
		int[][] b = new int[2][3];
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 3; j++) {
				b[i][j] = nextInt();
			}
		}
		int[][] c = new int[3][2];
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 2; j++) {
				c[i][j] = nextInt();
			}
		}

		/*
		 *L'une ou l'autre pierre a déjà été placée, personne ne l'a encore placée
		 *Afin d'exprimer[][]utilisation
		 *Si c'est 0, personne n'est mis
		 * boolean[][]Mais vous pouvez, mais pour le débogage 1/-Je voulais voir 1
		 */
		int[] res = calcPointC(b, c, new int[3][3], 0, true);

		out.println(res[0]);
		out.println(res[1]);
	}

	//	int cnt = 1;

	/**
	 *Enquête récursive
	 * @param b
	 * @param c
	 * @param board
	 * @param turn
	 * @param who
	 * @return
	 */
	private int[] calcPointC(int[][] b, int[][] c, int[][] board, int turn, boolean who) {
		if (turn == 9) {
			int chokudai = 0;
			int chokuko = 0;
			/*
			 *J'ai fini de tout mettre, alors j'ai commencé à calculer
			 */
			for (int i = 0; i < 3; i++) {
				for (int j = 0; j < 3; j++) {
					if (i < 2) {
						if (board[i][j] == board[i + 1][j]) {
							chokudai += b[i][j];
						} else {
							chokuko += b[i][j];
						}
					}
					if (j < 2) {
						if (board[i][j] == board[i][j + 1]) {
							chokudai += c[i][j];
						} else {
							chokuko += c[i][j];
						}
					}
				}
			}
			return new int[] { chokudai, chokuko };

		}

		List<int[]> resList = new ArrayList<int[]>();
		/*
		 *Découvrez le score maximum au tour de qui
		 *Le score lorsque le score maximum de celui qui fait le mieux
		 */
		for (int i = 0; i < 3; ++i) {
			for (int j = 0; j < 3; ++j) {
				//				if (i == 0 && j == 0) {
				//					out.println(cnt++);
				//				}
				/*
				 *Déjà placé
				 */
				if (board[i][j] != 0) {
					continue;
				}

				if (who) {
					board[i][j] = 1;
				} else {
					board[i][j] = -1;
				}
				/*
				 *qui est au tour
				 *Pour le moment, enregistrez le nombre de points que vous obtiendrez si vous le mettez dans cette position
				 *En fin de compte, voici une pression pour connaître le score maximum au tour de qui
				 */
				resList.add(calcPointC(b, c, board, turn + 1, !who));
				/*
				 *Réinitialisez la pierre placée dans cette position pour changer la position
				 */
				board[i][j] = 0;
			}
		}
		/*
		 *La raison pour laquelle le maximum de points est retourné en alternance est que c'est une prémisse que chaque personne fera de son mieux.
		 *Le résultat du renvoi alterné du score maximum est résultat
		 */
		if (who) {
			//Puisque c'est au tour de chokudai, retournez le tableau contenant la valeur maximale de chokudai
			return resList.stream().max(Comparator.comparing(x -> x[0])).get();
		} else {
			//Puisque c'est au tour de chokuko, retournez le tableau contenant la valeur maximale de chokuko
			return resList.stream().max(Comparator.comparing(x -> x[1])).get();
		}

	}