[JAVA] Article sur la participation au concours AtCoder

Participation au AtCoder Beginner Contest 182 avec environ 20 minutes de retard. Eh bien, je ne peux pas le terminer à temps, alors je ferai ce que je peux.

A - twiblr

Calculez simplement la limite supérieure du nombre d'adeptes selon les règles et soustrayez le nombre actuel d'adeptes.

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        try(Scanner s = new Scanner(System.in)){
        	System.out.println(s.nextInt() * 2 + 100 - s.nextInt());
        }
    }
}

B - Almost GCD Ne devrait-on pas trouver le nombre maximum de promesses en utilisant la méthode euclidienne de division mutuelle? J'ai pensé, mais j'ai été convaincu par l'exemple. Ce serait une mauvaise chose si la contribution maximale totale était de 1. Ensuite, j'ai remarqué quand j'ai pensé que je devais décomposer chaque nombre en facteurs premiers et sélectionner celui avec de nombreux facteurs premiers communs. Alors, n'est-ce pas très différent même si vous essayez de tout diviser depuis le début?

import java.util.*;

public class Main {
    public static void main(String[] args) {
        try (Scanner s = new Scanner(System.in)) {
            int n = s.nextInt();
            int[] a = new int[n];
            int max = 0;
            for (int i = 0; i < n; i++) {
                a[i] = s.nextInt();
                max = Math.max(max, a[i]);
            }
            int maxCount = 0;
            int tempK = 0;
            for (int k = 2; k <= max; k++) {
                int count = 0;
                for (int x : a) {
                    if (x % k == 0) {
                        count++;
                    }
                }
                if (count > maxCount) {
                    tempK = k;
                    maxCount = count;
                    if (maxCount == n) {
                        break;
                    }
                }
            }
            System.out.println(tempK);
        }
    }
}

C - To 3 Le reste de la division d'un nombre par 3 est égal au reste de la division de la somme des nombres à chaque endroit par 3. Comme le reste de l'histoire ne peut être discuté que par le reste, il est décomposé en chaque partie et converti en le reste divisé par 3. À partir de là, il est difficile de diviser les affaires. Quand je pense que le reste du total est divisé par 0, 1 et 2, je remarque qu'il y en a.

Si le reste total est de 1 et qu'il n'y a plus de 1 chiffre, alors seuls le reste 0 et le reste 2 constituent les chiffres. Si tous les chiffres sont le reste 0, le reste total sera 0, et s'il n'y a qu'un seul chiffre du reste 2, le reste total doit être 2. Il y aura au moins deux chiffres avec un reste de 2. Si vous vous débarrassez de ces deux, vous pouvez rendre le reste 0. Il en va de même lorsque le reste total est de 2, de sorte que le jugement peut être écrit en 5 lignes, à l'exclusion du processus de «recherche de colonne».

import java.util.*;

public class Main {
    public static void main(String[] args) {
        try (Scanner s = new Scanner(System.in)) {
            int[] x = s.next().chars().map(i -> (i - '0') % 3).toArray();
            int r = Arrays.stream(x).sum() % 3;
            System.out.println(remove(x, r));
        }
    }
    
    private static int remove(int[] x, int r) {
        if (r == 0) return 0;
        if (x.length == 1) return -1;
        if (find(x, r)) return 1;
        if (x.length == 2) return -1;
        return 2;
    }
    
    private static boolean find(int[] x, int target) {
        for (int a : x) {
            if (a == target){
                return true;
            }
        }
        return false;
    }
}

D - Wandering Au début, j'ai pensé que je le ferais honnêtement. Je l'ai écrit avec inquiétude sur l'heure d'exécution En écrivant, j'ai été inspiré d'utiliser l'idée de somme cumulative et de la réécrire. Puisqu'il devrait y avoir un montant maximum qui peut se déplacer dans le sens positif dans un groupe de $ A_1 $ ~ $ A_i , (i = 1,2, \ dots, N) $. Enregistrez et comparez la position lorsque la quantité maximale de mouvement est effectuée. ** Faites-le ici. ** Je savais que ça déborderait si je ne faisais pas longtemps de la plage de nombres Puisque le tableau int qui enregistre $ A_i $ a été réutilisé tel quel pour la somme cumulée, il est devenu WA une fois. Remake-le dans un long tableau et AC.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        try (Scanner s = new Scanner(System.in)) {
            s.nextLine();
            long[] a = Arrays.stream(s.nextLine().split(" "))
                                .mapToLong(Long::parseLong)
                                .toArray();
            long[] max = new long[a.length];
            max[0] = a[0];
            for (int i = 1; i < a.length; i++) {
                a[i] += a[i - 1];
                max[i] = Math.max(max[i - 1], a[i]);
            }
            
            
            long maxP = 0;
            long p = 0;
            for (int i = 0; i < a.length; i++) {
                maxP = Math.max(maxP, p + max[i]);
                p += a[i];
            }
            System.out.println(maxP);
        }
    }
}

À ce stade, il restait environ 6 minutes et E n'était pas du tout à l'heure.