AtCoder ABC 126 A&B&C&D AtCoder - 126
A - Changing a Character
«J'avais l'habitude de l'écrire comme ça, mais est-ce que c'est difficile à lire si je le relis? ?? ??
private void solveA() {
int n = nextInt();
int k = nextInt() - 1;
StringBuilder builder = new StringBuilder(next());
out.println(builder.replace(k, k + 1, builder.substring(k, k + 1).toLowerCase()).toString());
}
――Hmm. Pas assez bon. .. ..
private void solveA() {
int n = nextInt();
int k = nextInt();
String[] wk = next().split("");
wk[k - 1] = wk[k - 1].toLowerCase();
String res = Arrays.stream(wk).collect(Collectors.joining(""));
out.println(res);
}
B - YYMM or MMYY
private void solveB() {
int wk = nextInt();
int front = wk / 100;
int back = wk % 100;
if ((0 < front && front <= 12) && (back <= 0 || back > 12)) {
out.println("MMYY");
} else if ((0 < back && back <= 12) && (front <= 0 || front > 12)) {
out.println("YYMM");
} else if ((0 < front && front <= 12) && (0 < back && back <= 12)) {
out.println("AMBIGUOUS");
} else {
out.println("NA");
}
}
C - Dice and Coin
--Big Decimal est utilisé car il est difficile de traiter les fractions
Exemple 1: Parce que je lance un dé à trois faces
Si 1 est lancé, la pièce doit être affichée 4 fois de suite Si 1 apparaît: 1 $ x 2 x 2 x 2 x 2 = 16 $ Probabilité: $ \ frac {1} {3} × (\ frac {1} {2}) ^ 4 $
Si 2 est lancé, la pièce doit être affichée 3 fois de suite Si 2 apparaît: 2 $ x 2 x 2 x 2 = 16 $ Probabilité: $ \ frac {1} {3} × (\ frac {1} {2}) ^ 3 $
Si 3 est obtenu, la pièce doit être affichée deux fois de suite Si 3 apparaît: 3 $ x 2 x 2 = 12 $ Probabilité: $ \ frac {1} {3} × (\ frac {1} {2}) ^ 2 $
Le total (quand 1 sort, quand +2 sort, quand +3 sort) est comme suit $ \frac{1}{3} × (\frac{1}{2})^4 + \frac{1}{3} × (\frac{1}{2})^3 +\frac{1}{3} × (\frac{1}{2})^2 = \frac{7}{48} $
Simplifiez la formule en l'enveloppant ** (Comme il est difficile de penser au traitement des fractions au moment de la mise en œuvre, j'apporterai la division à la fin) ** $ ((\frac{1}{2})^4 + (\frac{1}{2})^3 + (\frac{1}{2})^2) × \frac{1}{3} = \frac{7}{48} $
private void solveC() {
int n = nextInt();
int k = nextInt();
BigDecimal res = new BigDecimal("0");
for (int i = 1; i <= n; i++) {
int pow = recursiveC(i, k);
/*
*Le recto et le verso de la pièce sont 1/2 donc 0.5 à la nième puissance
*0 lorsque la surface de la matrice est i.5^pow
*/
BigDecimal powB = new BigDecimal("0.5").pow(pow);
//Ajouter
res = res.add(powB);
}
//Enfin, divisez par le côté de la matrice à la fois
out.println(res.divide(new BigDecimal(n), 11, RoundingMode.HALF_UP));
}
/**
*Renvoie combien de fois x 2 doit dépasser n
* @param i
* @param n
* @return
*/
private int recursiveC(int i, int n) {
if (i >= n) {
return 0;
}
return recursiveC(i * 2, n) + 1;
}
AtCoder ABC 126 D --Even Relation (400 points)
――Le site de référence ci-dessus de M. Kenchon a une méthode de solution dans DFS. J'en ai parlé. ――Je l'ai résolu moi-même avec DFS, mais je ne le posterai pas car le site de Kenchon est plus facile à comprendre. ――Ce n'est pas un round-robin, mais une racine est décidée et peinte en fonction de la régularité de la distance à partir de là (je ne savais pas sans voir l'explication) ――Peut-être pouvez-vous utiliser Dyxtra? ?? ?? Essayons-le la prochaine fois.
private void solveD() {
int n = nextInt();
int[] u = new int[n - 1];
int[] v = new int[n - 1];
int[] w = new int[n - 1];
/*
*Créer une carte d'arêtes
*/
Map<Integer, List<Edge>> wk = new TreeMap<Integer, List<Edge>>();
for (int i = 0; i < n - 1; i++) {
Edge e = null;
List<Edge> tmp = null;
u[i] = nextInt() - 1;
v[i] = nextInt() - 1;
w[i] = nextInt();
/*
*Le coût est inutile sauf pour les paires et les impairs, donc je l'ai modifié, mais je n'ai pas eu à le faire séparément. .. ..
*/
int cost = w[i] % 2;
e = new Edge();
e.from = u[i];
e.to = v[i];
e.cost = cost;
tmp = wk.getOrDefault(e.from, new ArrayList<Edge>());
tmp.add(e);
wk.put(e.from, tmp);
e = new Edge();
e.from = v[i];
e.to = u[i];
e.cost = cost;
tmp = wk.getOrDefault(e.from, new ArrayList<Edge>());
tmp.add(e);
wk.put(e.from, tmp);
}
/*
*File d'attente pour BFS
*/
Deque<Edge> ek = new ArrayDeque<Edge>();
/*
*sélection de la première que pour explorer l'arbre
*Tout ne va pas bien, l'enfant en choisit un
*N sommets et N côtés-Puisqu'il n'y en a qu'un, il y en a toujours un qui remplit cette condition.
* while()Seule la première file d'attente de la liste ne voit pas toutes mes destinations.
*Eh bien, pendant que()Je pense que je devrais simplement mettre tous les bords à la position 0 dans la file d'attente avant d'entrer.
*/
for (List<Edge> edges : wk.values()) {
if (edges.size() == 1) {
ek.addLast(edges.get(0));
break;
}
}
// ek.addLast(wk.get(0).get(0));
int[] res = new int[n];
//Pour stocker les couleurs
res[0] = 0;
while (!ek.isEmpty()) {
Edge e = ek.removeLast();
/*
*Décidez de la couleur à peindre en fonction de l'étrangeté du coût
*/
if (e.cost % 2 == 0) {
//Si c'est pair, à la fois de et d'avoir la même couleur
res[e.to] = res[e.from];
} else {
//Si c'est étrange, vous devez peindre dans une couleur différente de
res[e.to] = 1 - res[e.from];
}
//Recherche d'enfants en
List<Edge> edges = wk.get(e.to);
for (Edge edge : edges) {
/*
*Pour empêcher les parents et les enfants de circuler
*/
if (e.from == edge.to) {
continue;
}
/*
*Ajouter à la file d'attente car il s'agit d'une cible de recherche
*/
ek.addLast(edge);
}
}
for (int resN : res) {
out.println(resN);
}
}
/**
*Classe interne pour représenter les arêtes
*/
private static class Edge {
private int from;
private int to;
private int cost;
}
Recommended Posts