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

AtCoder ABC 026 A&B&C AtCoder - 026

--ABC027 J'étais vraiment inquiet, mais le niveau de difficulté est très différent.

Un problème

-Essayez toutes les combinaisons de $ (x, y) $

	private void solveA() {
		final int a = nextInt();
		int res = IntStream.range(1, a).reduce(0, (sum, i) -> Integer.max(i * (a - i), sum));

		out.println(res);
	}

Problème B

-Peindre de l'extérieur du rouge au blanc --Enfin, j'ai entré manuellement 3.1415 sans utiliser Math.PI et c'était NG.

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

		long res = 0;
		boolean isRed = true;
		for (int i = 0; i < wk.length; i++) {
			res += Math.pow(wk[numN - 1 - i], 2) * (isRed ? 1 : -1);
			isRed = !isRed;
		}
		double mul = res * Math.PI;
		out.println(mul);
	}

Problème C: utilisation des classes

--Le boss reçoit le tableau d'entrée ―― D'après la description qu'il n'y a qu'un seul patron avec un petit numéro d'employé, pouvez-vous trouver la dernière personne en regardant par derrière? '' ――Si vous regardez de face, vous trouverez votre subordonné, mais si vous regardez de dos, vous trouverez votre patron. «Le salaire de votre patron est déterminé par vos subordonnés, il semble donc préférable de regarder par derrière.

――C'est redondant, mais j'ai créé une classe pour exprimer mon salaire ―― Qu'est-ce que «BOSS» même si vous exprimez votre salaire? .. .. --Calculez votre propre salaire et calculez le salaire BOSS en fonction du résultat du calcul

	private void solveC() {
		int numN = nextInt();
		/*
		 * Index=0 -> B2
		 * Index=-1 -> B1
		 */
		int[] wk = IntStream.range(0, numN - 1).map(i -> nextInt()).toArray();

		/*
		 *Liste subordonnée
		 */
		Boss[] wkList = new Boss[numN - 1];
		/*
		 *Pour Takahashi uniquement
		 */
		Boss takahashi = new Boss();
		/*
		 *Si vous l'exécutez depuis la fin, vous aurez toujours un boss. droite?
		 * (Takahashi exclut son patron)
		 */
		for (int i = wk.length - 1; i >= 0; i--) {
			/*
			 *Obtenez votre propre salaire
			 */
			int salary = getSelfSalary(wkList, i);

			/*
			 *Faire correspondre le numéro et l'index du boss
			 *Si Takahashi est un patron-Devenir 1
			 */
			int bossNum = wk[i] - 2;
			/*
			 *Obtenez une liste des subordonnés du boss
			 *Enregistrez votre salaire dans la liste de votre patron (total?)
			 */
			if (bossNum == -1) {
				/*
				 *BOSS est Takahashi, donc salaire+
				 *Même à Takahashi, max et min+Parce que la contrainte de 1 est appliquée
				 */
				takahashi.setMax(salary);
				takahashi.setMin(salary);
				takahashi.addMembers(1);
			} else {
				Boss boss = wkList[bossNum];
				if (boss == null) {
					/*
					 *Enregistré en tant que patron sans subordonnés jusqu'à présent
					 */
					boss = new Boss();
					wkList[bossNum] = boss;
				}
				boss.setMax(salary);
				boss.setMin(salary);
				boss.addMembers(1);
			}

		}

		out.println(takahashi.getMax() + takahashi.getMin() + 1);
	}

	/**
	 *Obtenez votre liste de subordonnés,
	 *Ma paie
	 * @param wkList
	 * @param i
	 * @return
	 */
	private int getSelfSalary(Boss[] wkList, int i) {
		int salary;

		Boss self = wkList[i];
		if (self != null) {
			int min = self.getMin();
			int max = self.getMax();
			salary = max + min + 1;
		} else {
			salary = 1;
		}
		return salary;
	}

	/**
	 *Avec le nombre de mes subordonnés
	 *Gardez le maximum et le minimum de votre salaire
	 * @author works
	 *
	 */
	private static class Boss {
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		int members;

		public int getMembers() {
			return members;
		}

		public void addMembers(int member) {
			this.members += member;
		}

		public int getMin() {
			return min;
		}

		public int getMax() {
			return max;
		}

		public void setMin(int min) {
			this.min = Integer.min(this.min, min);
		}

		public void setMax(int max) {
			this.max = Integer.max(this.max, max);
		}
	}

Problème C: Liste

J'ai calculé en utilisant la classe, mais vous pouvez aussi le faire avec cette liste, non? ?? ?? J'ai pensé, j'ai essayé de l'exprimer dans List.

C'était beaucoup plus rapide que la classe

	private void solveC2() {
		int numN = nextInt();
		/*
		 * Index=0 -> B2
		 * Index=-1 -> B1
		 */
		int[] wk = new int[numN + 1];
		List<List<Integer>> mems = new ArrayList<List<Integer>>();
		wk[0] = 0;
		wk[1] = 0;
		mems.add(new ArrayList<Integer>());
		mems.add(new ArrayList<Integer>());
		for (int i = 0; i < numN - 1; i++) {
			wk[i + 2] = nextInt();
			mems.add(new ArrayList<Integer>());
		}

		for (int i = wk.length - 1; i >= 0; i--) {
			List<Integer> tmp = mems.get(i);
			int salary = 0;
			if (tmp.size() != 0) {
				int min = Integer.MAX_VALUE;
				int max = Integer.MIN_VALUE;
				for (int j = 0; j < tmp.size(); j++) {
					min = Integer.min(min, tmp.get(j));
					max = Integer.max(max, tmp.get(j));
				}
				salary = min + max + 1;
			} else {
				salary = 1;
			}
			tmp = mems.get(wk[i]);
			tmp.add(salary);
		}
		long salary = 0;
		{
			List<Integer> tmp = mems.get(1);
			int min = Integer.MAX_VALUE;
			int max = Integer.MIN_VALUE;
			for (int j = 0; j < tmp.size(); j++) {
				min = Integer.min(min, tmp.get(j));
				max = Integer.max(max, tmp.get(j));
			}
			salary = min + max + 1;
		}
		out.println(salary);
	}