Copa Blue Bridge 2020 Primera Ronda Grupo Provincial B
Prefacio
No. 4 competencia provincial, todavía no hay solución hasta el día de hoy. Simplemente escribe una por ti mismo. Por supuesto que no es una respuesta estándar. Es puramente un entendimiento personal. Puede haber errores. Por favor, corrígeme. Personalmente pienso que la calidad de las preguntas en este concurso provincial es buena, todas son preguntas redactables y el gradiente de dificultad también es bueno, la última pregunta puede ser simple.
La respuesta para completar el espacio en blanco no se guarda, así que simplemente escriba la solución de la idea.
Las preguntas de programación se llenarán con código más adelante.
Un entrenamiento de carrera
Hay muchos problemas similares, como los caracoles trepando árboles, trepando pozos, etc. Puede calcularse directamente o programarse para simular. Cabe señalar que la fuerza física restante en el último minuto de carrera es 400 en lugar de 100.
B aniversario
No hay nada que decir, solo haz los cálculos. Escuché que hay una función en Excel para obtener la cantidad de días directamente.
Detección de fusión C
Suponiendo que el total es 1, la prueba combinada necesita consumir kits de reactivos 1 / K. Entre ellos, 0,01 personas infectadas necesitan gastar kits de reactivos 0,01 * K adicionales, es decir, se requiere un total de kits de reactivos 1 / K + K / 100. K se obtiene de acuerdo con la desigualdad básica Toma 10.
Programa D REPEAT
Puede escribir un programa de traducción o puede utilizar trucos para convertir el texto de reemplazo en código y luego ejecutarlo directamente.
Si escribe un programa de traducción, puede escribir un dfs. Cada vez que encuentra una repetición, se realiza una nueva llamada. Utilizo la sangría para los parámetros pasados para obtener la prioridad. La sangría más larga debe calcularse primero para obtener el resultado. Puede volver al nivel superior cuando la sangría de esta línea es menor que el parámetro.
Dar un programa de traducción que escribí, basado en el procesamiento de dfs REPEAT anidado
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn = 1000010;
string s[1005];
int i = 0;
int getp(string s)
{
int p = 0;
while(s[p] == ' ')p++;
return p;
}
int x = 0;
int dfs(int y)
{
int p = 0,v = 0;
while(x<i){
x++;
cout << s[x] << endl << x << ' ' << y << ' ' << v << endl;
p = getp(s[x]);
if(p<y){
x--;
return v;
}
if(s[x][p] == 'R')
{
v+=(s[x][p+7]-'0')*dfs(p+4);
}
else if(s[x][p] == 'A'){
v+=s[x][p+8]-'0';
}
}
return v;
}
int main()
{
freopen("prog.txt","r",stdin);
long long ans = 0;
//getline(cin,s[0]);
while(!cin.eof()){
getline(cin,s[i]);
i++;
}
ans = dfs(0);
cout << ans;
return 0;
}
Matriz E
Después de la observación, se puede encontrar que la parte superior izquierda e inferior derecha solo pueden tomar 1, 2020; y las dos cuadrículas adyacentes a 1, es decir, una fila, dos columnas y dos filas y una columna, solo pueden tomar 2, 3; mover una columna hacia atrás, es decir, una fila, tres columnas y Dos filas y dos columnas, solo se pueden tomar 4 y 5; infiriendo que hay un total de 1009 grupos, entonces la respuesta es 2 ^ 1009mod2020.
F secuencia divisible
Como sugiere el título, simplemente ejecute la división de bucle por 2 directamente en la entrada.
Decodificación G
Puede emitirse en modo de lectura previa, es decir, leer dos caracteres a la vez y ver si el segundo dígito es un número. Si no lo es, emitir el carácter actual, si lo es, generar el carácter actual del número especificado y la posición +1; también se puede secuenciar directamente Salida, compensa el dígito anterior cada vez que se lee un número.
H ir cuadrado
Dp simple es suficiente, dp [i] [j] = dp [i-1] [j] + dp [i] [j-1].
También se puede resolver mediante dfs, pero puede que se agote el tiempo de espera cuando el valor se acerque a 30. Hice un gráfico.
Yo empalmo enteros
El número de empalme puede considerarse compuesto de dos partes, la primera parte es a * 10 ^ b, la segunda parte es c, por lo que podemos preprocesar la primera parte y luego consultar cuántos números como la primera parte son para cada c Para satisfacer la suma de las dos partes modK = 0, simplemente agregue ans.
El método específico es crear un mod de matriz bidimensional, unidimensional representa la potencia de 10 y bidimensional representa el resto de modK. Calcule el resto del producto modK de cada número y 10, 100, 1000 ... 10 ^ 9, y luego +1 la unidad de la matriz bidimensional correspondiente. Después del procesamiento, mod [a] [b] significa que un número va seguido de un 0, y el resto de modK es b, que es el número de dichos números (la primera parte mencionada anteriormente). Luego procese cada número, asumiendo que este número es la segunda parte del número de empalme mencionado anteriormente, luego la primera parte que cumple con las condiciones modK se agrega a este número modK, y el resultado del módulo K debe ser 0.
Para facilitar el procesamiento, escribí dos funciones, una getl, que devuelve el número de dígitos del valor pasado; una getll, que devuelve la potencia de 10. De esta forma, al procesar cada número a, podemos acceder directamente a la matriz mod obtenida por preprocesamiento. Una dimensión es getl (a), que significa cuántos ceros deben seguirse en la primera parte, y la segunda parte es (Ka modK) modK, lo que significa que la suma de las dos partes modK es 0. El resultado obtenido es el número de a * 10 ^ b que cumple la condición.
A lo que debe prestar atención es a la coincidencia entre usted y usted mismo, es decir, la a en la primera parte y la c en la segunda parte son el mismo número. Podemos comprobar si el número actual a se multiplica por getll (a) a módulo K durante el procesamiento, y si es el mismo que el resto (Ka modK) modK que necesitamos. Si es el mismo, significa que el número del resto incluye el número que se está procesando actualmente, y ans debe ser -1.
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn = 100010;
int mod[10][maxn];
long long a[maxn];
int getl(long long a)
{
int r = 0;
while(a>0)
{
r++;
a/=10;
}
return r;
}
long long getll(int a)
{
long long r = 1;
while(a--)r*=10;
return r;
}
int main()
{
int n,k;
long long ans = 0;
cin >> n >> k;
for(int i = 0;i < n;i++)
{
cin >> a[i];
long long p = 0,q = 1;
while(p<10)
{
long long t = (a[i]*q)%k;
mod[p][t]++;
p++;
q*=10;
}
}
//cout << mod[1][0] << ' ' << mod[1][1];
for(int i = 0;i < n;i++)
{
//cout << getl(a[i]) << ' ' << (k-a[i]%k)%k << endl;
ans+=mod[getl(a[i])][(k-a[i]%k)%k];
//cout << a[i]*getll(getl(a[i]))%k;
if((a[i]*getll(getl(a[i])) + a[i])%k == 0)ans--;
}
cout << ans;
return 0;
}
Análisis de red J
Resolver a través del conjunto de búsqueda de unión solo necesita encontrar el peso de cada punto al final, por lo que el conjunto de búsqueda de unión solo necesita actualizar cada valor raíz.
El método específico es configurar una matriz de incremento para guardar el valor de incremento de los puntos en cada colección de unión. Cada vez que se fusiona la colección, el valor de incremento de la raíz del conjunto combinado menos el valor de incremento de la raíz del conjunto combinado De esta manera, al calcular el peso del punto al final, solo necesitamos encontrar la raíz de abajo hacia arriba y sumar el valor de incremento cada vez para obtener el peso final del punto. Cuando se fusiona la colección, solo se actualiza el nodo principal del nodo raíz, los nodos principales de otros nodos siguen siendo el nodo raíz y el valor de incremento solo se actualiza en el nodo raíz. Puede ser analógico para generar un árbol, y el peso del nodo hoja es Proceso de búsqueda de raíces.
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn = 10010;
int ans[maxn];
int add[maxn];
int fa[maxn];
int v[maxn];
int f(int i)
{
if(fa[i]!=i)return f(fa[i]);
}
void uni(int a,int b)
{
if(f(a) == f(b)) return;
else
{
a = f(a),b = f(b);
if(v[a]>=v[b])
{
add[b]-=add[a];
fa[b] = a;
v[a]+=v[b];
}
else
{
add[a]-=add[b];
fa[a] = b;
v[b]+=v[a];
}
}
}
int main()
{
int n,m;
int c = n;
cin >> n >> m;
for(int i = 1;i <= n;i++){
fa[i] = i;v[i] = 1;
}
for(int i = 0;i < m;i++)
{
int a,b,c;
cin >> a >> b >> c;
if(a == 1)
{
uni(b,c);
}
else
{
add[f(b)]+=c;
}
}
for(int i = 1;i <= n;i++)
{
int t = i;
ans[i]+=add[i];
while(fa[t]!=t)
{
ans[i]+=add[fa[t]];
t=fa[t];
}
}
for(int i = 1;i <= n;i++)
cout << ans[i] << endl;
return 0;
}
Enlace de título: https://pan.baidu.com/s/1xcNT6pqKltR_WLhlep64OA
Código de extracción: 5789
Tengo un mensaje privado y lo recibiré.