Código Educativo Fuerzas Ronda 85 (Clasificado para Div. 2) 【ABCDE】 （题 解）

Puntos de conocimiento cubiertos: pensamiento, avaricia, matemáticas.

Enlace al juego: Portal

A - Estadísticas de nivel

Tema: Indique el número de juegos y el número de despacho de aduanas en orden cronológico para determinar si es razonable.
Solución: asegúrese de que el número de veces en el intervalo adyacente y el intervalo total sea mayor o igual que el número de despachos de aduana y no disminuya.
Aceptar código:

#include <bits/stdc++.h>
using namespace std;

int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        int maxp=0,maxc=0;
        bool flag=true;
        while(n--){
            int p,c;
            cin>>p>>c;
            if(p<maxp||c<maxc||p<c||p-maxp<c-maxc){
                flag=false;
            }
            maxp=max(p,maxp),maxc=max(c,maxc);
        }
        puts(flag?"YES":"NO");
    }
    return 0;
}

B - Clase media

Tema: para estipular que una riqueza es mayor o igual que un determinado umbral es una persona rica, cada operación puede seleccionar un grupo de personas, de modo que cada una de sus riquezas se convierta en su promedio.
Solución del problema: codicioso después de ordenar de grande a pequeño.
Aceptar código:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        ll x;
        cin>>n>>x;
        for(int i=1;i<=n;i++)cin>>a[i];
        sort(a+1,a+n+1);
        reverse(a+1,a+1+n);
        int cnt=0;
        ll sum=0;
        for(int i=1;i<=n;i++){
            sum+=a[i];
            if(sum>=x*i)cnt++;
            else break;
        }
        cout<<cnt<<"\n";
    }
    return 0;
}

C - Círculo de monstruos

Tema: hay un círculo de monstruos, cada monstruo tiene \ (a_i \) salud, cada golpe de monstruo perderá 1 salud, y cuando el monstruo muera, causará \ (b_i \) daño al siguiente monstruo . Cuántos disparos se requieren para destruir a todos los monstruos.
Solución: Primero repara toda la cantidad de sangre al daño que causará la muerte del monstruo anterior, y luego elige el menor daño para matar al monstruo.
Aceptar código: aprendí el uso de rotar.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=3e6+10;
const ll inf=0x3f3f3f3f3f3f3f3f;
ll a[maxn],b[maxn];
int main(){
    int t;
    cin>>t;
    while(t--){
        ll n,ans=inf,cnt=0;
        scanf("%lld",&n);
        for(int i=0;i<n;i++)scanf("%lld%lld",&a[i],&b[i]);
        rotate(b,b+n-1,b+n);
        for(int i=0;i<n;i++){
            if(a[i]>b[i])cnt+=a[i]-b[i];
        }
        for(int i=0;i<n;i++){
            ll res=0;
            if(a[i]>b[i])res-=(a[i]-b[i]);
            res+=a[i];
            ans=min(ans,res);
        }
        cout<<cnt+ans<<"\n";
    }
    return 0;
}

D - Ciclo mínimo de Euler

Tema: Un gráfico totalmente dirigido con vértices \ (n \) dados . Se requiere encontrar un cierto intervalo del bucle de Euler con el orden lexicográfico más pequeño.
Solución: observando el ejemplo de \ (n = 3 \) dado en el título, puede ver que \ (\ left [1,2,1,3 \ right] \ left [2,3 \ right] \ left [1 \ right ] \)
significa que para \ (1 \ n sim \) para cada nodo, empezando cada vez que ir al siguiente nodo a su vez para volver desde el punto actual lexicográficamente más pequeña, el punto actual pero ir \ (n- \) cuando Si no puede regresar, debe ir directamente al siguiente nodo; de lo contrario, no tendrá forma de hacerlo. Finalmente, volvemos al nodo 1. La
observación muestra que para el nodo \ (1 \ sim n \) , hay \ (2 (ni) \) nodos en cada grupo , y el nodo impar está en sí mismo, y el nodo par está en el grupo actual. La posición se divide por \ (2 + i \) .
Aceptar código:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int main(){
    int t;
    cin>>t;
    while(t--){
        ll n, l, r;
        cin>>n>>l>>r;
        ll limit = 1ll * n * (n - 1) + 1;
        ll sum = 0, id = 1;
        for (ll i = l; i <= r && i < limit; i++){
            while (sum + (n - id) * 2 < i)
                sum += (n - id) * 2, id++;
            ll d = i - sum;
            printf("%lld ", (d & 1) ? id : d / 2 + id);
        }
        if (r == limit)
            cout<<"1 ";
        cout<<"\n";
    }
}

E - Caminos divisores

Tema:
Dado un entero positivo \ (D \) , úselo para construir una imagen

1. Cada nodo es un factor de \ (D \)
2. \ (x, y (x> y) \) Hay bordes no dirigidos entre los nodos si \ (y \) es un factor de \ (x \) y \ (\ frac (x) (y) \) es un número primo
3. \ (X, y \) si el borde entre el lado derecho es \ (X \) factor no es \ (Y \) número de factores
   dados \ (Q \) petición de consulta de grupo \ (U , v \) El número de rutas más cortas

Solución: En primer lugar, puede pensar en el proceso de transferir un nodo \ (u \) a otro nodo \ (v \) arrojando algunos factores, donde \ (v | u \)
es uu a vv La ruta más corta es \ (d (u) -d (x_1) + d (x_1) -d (x-2) + \ ldots + d (x_y) -d (v) = d (u) -d (v) \ ) , Donde \ (d (x) \) es el número de factores de \ (x \) , por lo que cuando un nodo es divisible por un nodo, la ruta más corta entre los dos nodos es la diferencia entre el número de factores de los dos nodos. Teniendo en cuenta que la relación entre \ (u \) y \ (v \) no es un múltiplo, ya que la transferencia del nodo debe realizarse arrojando algunos factores, es necesario encontrar un nodo intermedio \ (x \) para que \ (u- > x \) y \ (v-> x \) , entonces obviamente \ (x \) debe ser el factor común de \ (u \) y \ (v \) , la ruta más corta es hacer \ (d (u ) -d (x) + d (v) -d (x) \) mínimo, entonces es hacer \ (d (x) \) máximo, entonces \ (x = mcd (u, v) \) , luego el final Rogar\ (g (u, gcd (u, v)) * g (v, gcd (u, v)) \) , donde \ (g (u, v) \) es \ (u \) y \ (v \ ) El número de caminos más cortos entre dos puntos
Debido a que un nodo \ (u \) a otro nodo \ (v \) siempre se realiza arrojando algunos factores, entonces el número de estos es el lanzamiento de estos factores intermedios Fuera de orden, luego para \ (g (u, v) \) , donde \ (v | u \) , deje \ (x = \ frac {u} {v} \) , luego \ (g (u, v) = \ frac {t!} {p_1! * p_2! ... p_n!} \) , donde \ (t \) es la suma de las potencias de los factores primos en \ (x \) , \ (p_i \) es \ El poder de un factor primo en (x \) es el código de aceptación factorial del problema de eliminación repetida en la permutación y combinación
:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
map<ll, ll> m;

ll calc(ll x){
    if (m[x])
        return m[x];
    ll res = 0, y = x;
    for (ll i = 2; i * i <= y; i++)
        if (y % i == 0){
            while (y % i == 0)
                y /= i;
            res = (res + calc(x / i)) % mod;
        }
    if (y > 1)
        res = (res + calc(x / y)) % mod;
    return m[x] = res;
}

int main(){
    ll d, q;
    cin>>d>>q;
    m[1] = 1;
    while (q--){
        ll u, v;
        cin>>u>>v;
        ll w = __gcd(u, v);
        printf("%lld\n", calc(u / w) * calc(v / w) % mod);
    }
    return 0;
}