Niuke Programming Summit Nivel S2

Niuke Programming Summit Nivel S2

Niuke Programming Summit S2 Game Nivel 11

Pregunta A

Descripción del Título:

A Niuniu le gusta hacer preguntas. Pero no le gusta hacer problemas difíciles, le gusta hacer problemas con el agua.

Para una pregunta con la pregunta número i, la dificultad de la pregunta es la suma de todos los factores de i dividida por i. Niuniu piensa que todas las preguntas con dificultad menor a 2 son preguntas de agua.

P.ej:

La pregunta con el número 25 tiene una dificultad de (1 + 5 + 25) /25=1.24 <2, por lo que esta pregunta es una pregunta de agua.

La pregunta número 28 tiene una dificultad de (1 + 2 + 4 + 7 + 14 + 28) / 28 = 2, por lo que esta pregunta no es una cuestión de agua.

No. 30 del sujeto, que es difícil de (1 + 2 + 3 + 5 + 6 + 10 + 15 + 30) /30=2.4 > 2, por lo que esta cuestión es también no problema del agua.

Niuniu recibió una hoja de preguntas con n preguntas, con los números de pregunta 1, 2, 3, ..., n. Niuniu cepilló todas las preguntas sobre el agua anteriores. Cada vez que haces una pregunta sobre el agua con el número i, Niu Niu puede obtener el índice de felicidad de i.

Niuniu quiere saber cuánto índice de felicidad puede obtener en total.

Obviamente es un problema de agua y dos bucles. El primer bucle es atravesar de 1 an, y el segundo bucle está anidado para encontrar todos los factores, sumarlos y luego compararlos con 2 * n para calcular el índice de felicidad.

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

int main()
{
    int n;
    int ans = 0, sum = 0;
    cin>>n;
    for(int i = 1; i <= n; i++)
    {
        sum = 0;
        for(int j = 1; j <= i; j++)
        {
            if(i % j == 0) sum++;
        }
        if(sum < 2 * i) ans+=i;
    }
    cout<<ans;
}

Pregunta B riego

Descripción del Título:

Niuniu tiene ahora n árboles en el jardín, ordenados del primero al enésimo. Niuniu regará los árboles en una determinada sección de acuerdo con su estado de ánimo todos los días. Por ejemplo, si el intervalo de riego es [2,4] en un día determinado, Niuniu regará el segundo, tercer y cuarto árbol ese día. Los árboles crecerán después de ser regados Para simplificar el problema, asumimos que la altura de todos los árboles es 0 cm al principio. El árbol crecerá naturalmente 1 cm cada día, y cada vez que se riegue, crecerá 1 cm más en el día. Niuniu elige un intervalo [l, r] todos los días en m días para regar los árboles en este intervalo. Niuniu quiere saber cuántos árboles son impares en altura después de m días. ¿Puedes decirle a Niuniu?

El tiempo de esta pregunta es de tres segundos, que se pueden pasar violentamente, pero también hay un algoritmo llamado prefijo de diferencia y ...

Primero mire el método de violencia:

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

int main()
{
    int tr[10005];
    int n, m, a, b;
    int ans = 0;
    cin>>n>>m;
    for(int i = 0; i < m; i++)
    {
        cin>>a>>b;
        for(int j = a; j <= b; j++)
            tr[j]++;
    }
    for(int i = 1; i <= n; i++)
    {
        if((tr[i] + m) % 2 == 1)
            ans++;
    }
    cout<<ans;
}

Tomó 2007 milisegundos, y fue muy lento. Generalmente, el juego directamente TL

Echemos un vistazo al prefijo de diferencia y cómo implementarlo.

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回m天后高度为奇数的树的数量
     * @param n int整型 
     * @param m int整型 
     * @param l int整型vector 
     * @param r int整型vector 
     * @return int整型
     */
    int oddnumber(int n, int m, vector<int>& l, vector<int>& r) {
        // write code here
        int  sum[200020] = {0};
        int ans = 0;
        for(int i = 0; i < m; i++)
        {
            sum[l[i]]++;
            sum[r[i] + 1]--;
        }
        for(int i = 1; i <= n; i++)
        {
            sum[i] += sum[i - 1];
        }
        for(int i = 1; i <= n; i++)
        {
            if((sum[i] + m) % 2 == 1)
                ans++;
        }
        return ans;
    }
};

Verifique el prefijo y vea mi blog aquí para no obtener detalles

Pregunta C

Hay 5 platos en la cafetería, todos llenos de pan.

Hay panes ilimitados en el primer plato;

Solo hay 1 pan en el segundo plato;

Solo hay 4 panes en el tercer plato;

También hay panes ilimitados en el cuarto plato, pero deben tomarse de dos en dos;

También hay panes ilimitados en el quinto plato, pero debe tomar 5 de 5 panes;

Dado un número entero positivo n, encuentre el número de soluciones que producen exactamente n panes.

El plan ay el plan b son diferentes, si y solo si el plan a tiene una cantidad diferente de pan de un determinado plato y plan b.

Esta pregunta requiere cinco bucles for de un vistazo, ¡pero esto inevitablemente se agotará!

Luego, comencemos con el problema y conviértalo a un lenguaje matemático: x + y + z + 2 * a + 5 * b = n (y <= 1, z <= 4)

Usando la ley conmutativa de la adición y la ley de la asociatividad, x + (y + a * 2) + (z + b * 5) = n, en este caso, se puede considerar como la suma de tres enteros como n. Hay varios Método, esta es la degeneración del método de blanking cuando la matemática de segundo grado habla de permutación y combinación. Hay tres casos. El primero es que dos de los tres números son 0, es decir, cuando no existe, este es C (3,1 ) = 3; El segundo caso es que hay dos números para dividir este n, un número no existe, es decir, C (3,2) * (n-1), este n-1 es el deflector del método de blanking, el primero En los tres casos, los tres números se utilizan para formar la n, por lo que es el método de interpolación directa C (n-1,2). En los tres casos, quiero sumar y obtener la expresión final (n + 1) * (n +2 ) / 2.

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param n int整型 
     * @return long长整型
     */
    long long wwork(int n) {
        // write code here
        return 1ll * (n + 1) * (n + 2) / 2;
    }
};

No olvide multiplicar por 1ll, de lo contrario será wa.

Niuke Programming Summit S2 Juego 10

Un experimento matemático

Niuniu está haciendo experimentos matemáticos.

La maestra le dio a Niuniu un número n, Niuniu necesita multiplicar los valores de todos los dígitos hasta que el número final no cambie.

Por favor, ayude a Niuniu a calcular, ¿cuál es el número final generado?

Idea: cuando n es menor que 10, el número final no cambiará, por lo que n <10 es la condición para que el ciclo termine, y luego solo necesitamos anidar un ciclo dentro del ciclo para multiplicar el número de cada dígito lata

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param n long长整型 老师给牛牛的数字
     * @return int整型
     */
    int mathexp(long long n) {
        int ans;
        while(n >= 10)
        {
            ans = 1;
            while(n)
            {
                ans *= n % 10;
                n /= 10;
            }
            n = ans;;
        }
        return n;//一定要记得返回n不是返回ans，因为如果输入的是小于0的数，返回n才是对的
    }
};

Pregunta B extraño problema de clasificación

Hay n personas en una fila en el patio de recreo. Las alturas de estas n personas son diferentes entre sí, y su altura puede considerarse como una disposición de 1 an.

En este momento, debe cambiar el equipo en orden ascendente, es decir, ordenar de bajo a alto.

Puedes elegir una persona a la vez y dejar que esta persona sea más alta o más baja que la persona que está detrás de él. Si es más alta que el oponente, cambia de posición y continúa la siguiente comparación hasta que sea más baja que el oponente o ya esté al final del equipo.

Ahora dé el número ny una permutación de 1 an, encuentre el número mínimo de opciones, de modo que el equipo ascienda.

Esta es una pregunta de pensamiento, comenzando desde el final de la cola para juzgar hacia adelante, porque es para encontrar el número mínimo de veces para cambiar al orden ascendente, simplemente juzgue, tr [i] se compara con minx, minx es inicialmente el valor máximo (esta pregunta es n + 1), si Si el primero es mayor, asigne el valor del primero a minx, no cuente y continúe el ciclo, si el segundo es mayor, significa que tr [i] tiene que ser intercambiado, entonces agregue uno y minx permanece sin cambios.

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param n int整型 
     * @param a int整型vector 
     * @return int整型
     */
    int wwork(int n, vector<int>& a) {
        int ans = 0;
        int minx = n + 1;
        for(int i = n - 1; i >= 0; i--)
        {
            if(a[i] > minx) ans++;
            else minx = a[i];
        }
        return ans;
    }
};

C preguntas XOR y

Niuniu aprendió recientemente la operación XOR, por lo que descubrió una función f (x) = x⊕ (x − 1) f (x) = x \ oplus (x-1) f (x) = x⊕ (x − 1 ), ahora Niuniu le da un número n \ mathit nn, quiere saber el valor de ∑i = 1nf (i) \ sum_ {i = 1} ^ nf (i) ∑i = 1nf (i), por favor diga él.

Violencia directa

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param n int整型 
     * @return long长整型
     */
    long long Sum(int n) {
        long long sum = 0;
        for(int i = 1; i <= n; i++)
        {
            sum += i ^(i - 1);
        }
        return sum;
    }
};

Después de leer el código de otras personas, hay operaciones mágicas, pero no entiendo (cabeza de perro manual

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param n int整型 
     * @return long长整型
     */
    long long  dfs(long long t) {
	if(t==1) return 1;
	if(t==0) return 0;
	return 	t+2*dfs(t/2);
}
    long long Sum(int n) {
        // write code here
        long long ans = n;
        ans+=2*dfs(n/2);
        return ans;
    }
};