enlaces a los temas: https://codeforces.com/contest/1333
El segundo golpe más de 2000, muy cerca de un máximo histórico. Problema C jugar un poco, los demás parece ser una reproducción normal.
A - Poco Artem
Una estructura simple, no necesita para participar en un tablero de ajedrez demasiado problema, dirigir todo el teñido del mismo color y luego vuelva a colocar la primera rejilla, debido a la n y m son de menos de 2 por lo que esta construcción necesariamente correcto.
B - Clase Anton
Una simulación sencillo, basta con pensar en ello.
* C - Eugene y una matriz
2, también desgraciado, y por primera vez es un algoritmo de falso + límites de la matriz, y la segunda es falsa algoritmo.
Significado de las preguntas: a número de secuencia n. Definir un continuo "buena" cuando no contiene ninguna suma de subintervalos consecutivos 0. Esta secuencia de todos los subintervalos continua demanda lo que es "bueno".
Solución: Esta "suma cero" parece haber visto muchas veces, por supuesto, es un mapa <ll, int> para guardar la última suma por el valor de la clave de posición. Sin embargo, hay un poco de detalle, procesar los datos siguientes:
7
1 2 -3 4 1 2 3
4 Número 4, que pueden ser seleccionados son: [2, 3,4], [- 3,4], [4], lo que resulta en el paso anterior para saltar igual a 1 han sido omitidos. Puede ser muy fácil de encontrar y entonces, el número de omitidos detrás ya menos (porque esto no puede contener la suma de intervalo 0), es común para limitar la posición seleccionable y el número de omitidos en una misma posición de la suma .
map<ll, int> MAP;
int a[2000005];
void TestCase() {
MAP.clear();
MAP[0] = 0;
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
ll sum = 0, ans = 0;
int rightmost = 0;
for(int i = 1; i <= n; ++i) {
sum += a[i];
if(MAP.count(sum))
//printf("?\n");
rightmost = max(rightmost, MAP[sum] + 1);
ans += i - rightmost;
MAP[sum] = i;
//printf("i=%d ans=%lld\n", i, ans);
//printf(" rightmost=%d\n", rightmost);
}
printf("%lld\n", ans);
return;
}
* D - Retos en la escuela №41
El significado de problemas: hay una secuencia de n indicada por las flechas, sólo la flecha hacia la izquierda o flecha derecha, cada operación se puede seleccionar de un par de adyacente flecha opuesto en flecha opuesto. Operaciones por segundo de al menos 1, solicitud de k s pueden ser exactamente en la secuencia de la totalidad de flecha no hay flechas opuestas.
La figura siguiente:
1 segundo, seleccionar dos pares de flechas opuestas mientras que mover de un tirón:
2 segundos para seleccionar flechas solamente relativamente invertidas:
Solución del problema: n k gran pequeña, el primer pensamiento a ser algunas de las etapas del ciclo de agotamiento flecha, pero después de unos empuje descubren que cada flecha para voltear ¿Cuántas veces está bien definido. Puede entenderse como 0 flecha izquierda flecha de la derecha entenderse como 1, esto es una burbuja tipo, pero puede ser operado independientemente uno de otro, al mismo tiempo varios grupos de flechas por segundo. Hay algunas posiciones se pueden encontrar en cada estado es el intercambio de bits temporal, y estas posiciones se pueden cambiar independientemente el uno del otro en el mismo momento de. Si cada flip todo el estado en lo posible, tiene que ser con un mínimo de tiempo para completar la tarea. Obviamente, cada operación se puede dividir en dos secciones, que haría + 1 (demasiado violentos), es muy claro que hay un algoritmo voraz: cuando el número de operación restante es menor que el tiempo restante, tantas veces como sea posible cada lanzamiento hasta restante después de un cierto número de pasos igual al tiempo de funcionamiento restante.
Tenga en cuenta que el siguiente código al avanzar j, si j se trunca tmp, a continuación, a la posición a calcular de j. (Afortunadamente, los datos de entrada relativamente grande, y configurado para comprobar un número k).
char s[3005];
char t[3005];
vector<pair<int, int> > ans;
void TestCase() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
//puts(s + 1);
int suc = 0, Layer = 1;
while(1) {
//printf("Layer=%d\n", Layer);
suc = 1;
t[1] = s[1];
for(int i = 2; i <= n; ++i) {
if(s[i - 1] == 'R' && s[i] == 'L') {
t[i - 1] = 'L';
t[i] = 'R';
ans.push_back({Layer, i - 1});
suc = 0;
//printf("swap %d\n", i - 1);
} else
t[i] = s[i];
}
if(suc) {
--Layer;
break;
}
for(int i = 1; i <= n; ++i)
s[i] = t[i];
//puts(s + 1);
++Layer;
}
//printf("Layer=%d\n", Layer);
int m = ans.size();
//printf("sumans=%d\n", m);
if(m < k || k < Layer) {
puts("-1");
return;
}
int rest = m;
int j = 0;
while(rest > k) {
--k;
int cnt = 0;
int begin_j = j;
while(j < m && ans[j].first == ans[begin_j].first) {
++cnt;
++j;
}
int tmp = min(cnt, rest - k);
printf("%d", tmp);
j = begin_j;
for(int k = 0; k < tmp; ++k)
printf(" %d", ans[j++].second);
printf("\n");
//printf("rest k=%d\n", k);
//printf("rest ans=%d\n", m - j);
rest -= tmp;
}
assert(rest == k);
while(rest--) {
printf("1 %d", ans[j].second);
++j;
printf("\n");
}
return;
}
Comenzando no se sabe cuántas operaciones allí (e inteligente directamente para el vector), ahora entendemos debe no más ser que el orden de n ^ 2, ya que este es en realidad un ordenamiento de burbuja, el número de operaciones y el mismo número en el orden inverso.
Tenga en cuenta que cuando la copia invertida como una cadena o secuencia de t que el anterior (recuerda copia t [1]), o la operación ++ i una vez más después de la inversión.
* F - Kate y la imperfección
Significado de las preguntas: a [1, n] de número natural continua. Cada uno de k [2, n], tienen todos un tamaño de subconjunto acabamos de enumerar de k, a continuación, definir una función F, F es un conjunto de parámetros que a través de la colección de todas las tuplas DIAD obtenidos el gcd, a continuación, tomar el máximo de estos dentro gcd, el mínimo requerido para cada función F k.
Solución: la clasificación después de haberse retirado del número mínimo de factores primos. Esto es muy fácil de encontrar la estructura adecuada, a sólo 1 después del primer número primo dejando para deshacerse de sí mismo, la priorización de ellos. Inmediatamente después, una fila 4, porque nunca más tiene la opción mcd es 1, y añadió un 4 marcas gcd 2 es buena. En este momento no debe insertar 8, 8 porque se necesita insertar 4 eliminarse. Del mismo modo, si el inserto 10, la toma 5 de borrar. Para insertar este caso 6, porque gcd 2 se ha agotado, el próximo 9 debe insertarse en lugar de 8. Si se tratara de escribir algunos ejemplos pueden observar una ley que se trataba de un caso de una escritura 12:
1 2 3 5 7 11 4 6 9 8 10 12
De hecho, en ese momento se han encontrado, es poner todos los números primos, a continuación, poner sólo 2, a continuación, poner sólo el 2 y 3, pero esto no 8 observado que la ley, por lo que no siempre se tiene que inspirar a todos los poderes principales un número están dispuestos de, ni es teniendo en cuenta cada número no se utiliza otros factores primos, y, a veces puede ser considerada desde la perspectiva del factor primo más pequeño.
Cuando el juego también encontrar plantillas de Möbius pretratamiento inversión de falta \ (\ sum \ limits_ {i = 1} ^ n \ sum \ limits_ {j = 1} ^ n [mcd (i, j ) == k] \) valores, pero ignora el hecho de que el sujeto se va a seleccionar subconjunto y no ignorar selectivamente gcd entre algunos elementos.
De hecho, este proceso se construye a su vez gcd = 1, gcd = 2, gcd = 3, gcd = 4 del proceso, pero empujado al gcd = 4 cuando tuve dudas.
const int MAXN = 5e5;
int p[MAXN + 5], ptop;
int pm[MAXN + 5];
void sieve() {
int n = MAXN;
pm[1] = 1;
for(int i = 2; i <= n; ++i) {
if(!pm[i]) {
p[++ptop] = i;
pm[i] = i;
}
for(int j = 1; j <= ptop; ++j) {
int t = i * p[j];
if(t > n)
break;
pm[t] = p[j];
if(i % p[j])
;
else
break;
}
}
}
void TestCase() {
sieve();
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
pm[i] = i / pm[i];
sort(pm + 1, pm + 1 + n);
for(int i = 2; i <= n; ++i)
printf("%d%c", pm[i], " \n"[i == n]);
return;
}