El diseño del programa pensamiento Week4-CSP juego de simulación
cuco A- aventura oriental
Descripción
Un puntero en un anillo, el primer punto de la letra a. Este cuco cada uno puede rotar en sentido horario o antihorario un espacio. Por ejemplo, una rotación en sentido horario a través de z, la rotación en sentido antihorario a b. Este cuco manos de una cadena, pero es tonto, así que vino a pedir su ayuda, pregunte cuántas veces requiere un mínimo de turno.
número de línea de entrada String, al menos para convertir la salida.
Muestra
input:
zeus
output:
18
Idea
En primer lugar calcular la longitud de la cadena que es el número de revoluciones, desde un principio, para cada letra, hay dos opciones, hacia la derecha o hacia la izquierda del carácter inicial de carácter giratorias, y seleccionar el camino más corto para llegar a la forma de la letra, y la próxima rotación de la letra inicial actualiza en consecuencia. Por último, el número acumulado de las células para obtener un mínimo de turno.
Resumen
Esta pregunta es relativamente sencilla, sobre todo para medir el número de células para ser girada hacia la derecha y hacia la izquierda, y luego cada vez que se quiere recordar a actualizar la letra inicial
códigos
#include <iostream>
#include <string>
#include <cmath>
#include<cstdlib>
#include<cstdio>
using namespace std;
int main()
{
cin.sync_with_stdio(false);
string str;
cin >> str;
int size = str.length();
int sum = 0;
char now = 'a';
for (int i = 0; i < size; i++) {
int left = abs(str[i] - now);
int right = 26-left;
sum += left < right ? left : right;
now = str[i];
}
printf("%d\n", sum);
}
B- cuco Oriente quiere comer
Descripción
Este cuco ia necesidad de comprar un diario frito. Pero las tiendas frito con el fin de estimular el consumo, sólo hay dos formas de comprar: ① de una sola vez compra dos frito un día. ② comprar un frito hoy, pero para mañana a comprar un frito, la tienda le dará un boleto, al día siguiente para ir y entradas de cobro revertido. No el resto de la compra, la compra de estas dos formas se puede utilizar muchas veces, pero el cuco Este es un niño ahorrativos, abandonó final de la formación, las manos de un billete no se permite al final del entrenamiento. Este cuco muy rica, no es necesario preocuparse por el dinero del este de cuco, el cuco Oriente, pero estúpido, que sólo quería preguntarle si podía comprar un frito de ia semana de exámenes días.
día de entrada Test semana n (1 <= n <= 100.000), y el número n días diario fritos compran el AI (0 <= EA <= 10000).
Muestra
input:
4
1 2 1 2
output:
YES
input:
3
1 0 1
output:
NO
Idea
Debido a que todos los días si se selecciona la segunda opción día siguiente debe acumular entradas se agotan, por lo que las entradas antes de que el billete con un récord de un día acumula, cuando el número del día anterior para comprar boletos de un día el número de anuncio acumulada vino de la compra fallida, de lo contrario las deducciones después de entradas del día anterior segunda opción hasta que sólo necesitan comprar un frito o frito no necesita comprar una. Después del ciclo para determinar si el billete se borra al final del último día.
Resumen
Esta pregunta es, de hecho, no es difícil, hay unos pocos a la nota:
① 1 <= n - <= 100000, lea cuidadosamente el título, prestar atención a la gama variable.
② el principio, me cayó en un callejón sin salida recursividad, que la primera solución y la segunda solución se puede adoptar cero o más veces, lo que resulta en muchos casos. De hecho, a lo sumo, una segunda opción, independientemente de la situación varias veces al día usando la segunda opción, se puede utilizar como alternativa a la primera opción, por lo que una gran cantidad de simple, valor del boleto de sólo 0 o 1.
códigos
#include <iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;
int a[100000];
int n;
bool flag = true;
int main()
{
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int ticket = 0;
for (int i = 0; i < n; i++)
{
if (a[i] - ticket < 0) { flag = false; break; }
ticket = (a[i] - ticket) % 2;
}
if (ticket != 0)flag = false;
if (flag)cout << "YES";
else cout << "NO";
}
los rayos cósmicos terribles C-
Descripción
rayos de propagación cósmico (figura puede verse como una rejilla bidimensional) en un plano bidimensional infinita, la dirección hacia arriba inicial predeterminada. Los rayos cósmicos se emiten después de una división distancia en esta dirección
de aproximadamente 45 ° para dividir las dos direcciones de los rayos cósmicos, mientras que la potencia de la misma! Los rayos cósmicos se dividirán n veces, cada vez longitudes de unidad de división ai hará avanzar en la dirección de la división.
Calcular el número total de posiciones será "abajo sabiduría contra la"
entrada de número de rayos cósmicos separatista n (n <= 30), y la i-ésima división de los rayos cósmicos continuará para ir en su longitud en la dirección original de AI (EA <= 5).
Muestra
input:
4
4 2 2 3
output:
39
Idea
Esta es una variación del laberinto, se puede usar DFS o BFS resueltos. Existen rayos en la enésima división de múltiples localizaciones pueden superponerse, por lo que es necesario calcular el número total de ubicación central eléctrica se ha reducido frente a Chile, donde utilizamos las estructuras de datos de conjunto para asegurar que cada lugar aparece sólo una vez en la colección. rayos de división de la dirección del movimiento hay ocho tipos de situaciones que pueden ir de lado todos modos, la situación con el movimiento matriz de almacenamiento.
Se utilizó el recursiva DFS buscar hacia adelante a la última división se separó de la última ruta, para cada división, la división se determina de acuerdo a la dirección de parámetro dir-eje, cuando dir igual a 0 o 4 en nombre de dos rayos escindidos simétrica sobre el eje y cuando dir igual a 1 o 5, en nombre de y = x línea recta de simetría, cuando dir igual a 2 o 6 simétrica Representante alrededor del eje x, cuando dir igual a 3 o 7 en nombre de la recta y = simetría -x, en el que una primera simetría Añadir punto de la trayectoria, el eje de simetría y en el que unos rayos simétricos conocidos conjunto, se puede deducir otro punto de simetría de la naturaleza de los rayos se añade conjunto entre mediatrices, ha sido empujado hacia adelante para que todas las posiciones disponibles alcanzaron, el conjunto final tamaño es el número de posiciones que se reduzca el combate intelectual.
Resumen
Esta es una modificación de un laberinto típica, la clave es memoria de trayectorias de división de la posición de deduplicación es decir, antes de que laberinto canal excepto en que la dirección del movimiento incluyendo 8, generalmente difícil.
Al principio traté de usar BFS resolución de problemas, pero después de un par de veces hacia fuera o poda:
int bfs() {
Q.push(point(0,0,0));
while (!Q.empty()) {
point now = Q.front();
Q.pop();
point temp;
for (int i = 1; i <= a[index]; i++)
{
//cout << now.x + dx[now.dir] * i << " " << now.y + dy[now.dir] * i << endl;
P.push_back(point2(now.x + dx[now.dir] * i, now.y + dy[now.dir] * i));
}
temp.x = now.x + dx[now.dir] * a[index];
temp.y = now.y + dy[now.dir] * a[index];
temp.dir = now.dir;
sort(P.begin(), P.end(), cmp);
int u = 0, v = 1;
while (v < P.size()) {
if (P[u] == P[v]) { P.erase(P.begin() + v); }
else { u = v; v = u + 1; }
}
if (index == 0)index++;
else {
k++;
if (pow(2, index+1) == k)index++;
}
if (index == n)return P.size();
int d1 = temp.dir+1;
int d2 = temp.dir - 1;
if (d1 == 8)d1 = 0;
if (d2 == -1)d2 = 7;
Q.push(point(temp.x, temp.y, d1));
Q.push(point(temp.x, temp.y, d2));
}
}
Luego uso DFS de la memoria, que puede ser pensado como el último punto en una división dividido, y un eje de simetría conocido de la escisión de radiación puede ser propiedades simétricas de mediatrices derivan otro haz dividido, y luego hacia adelante pulsador de arranque de una copia simétrica, hasta que toda la figura copia.
códigos
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
using namespace std;
struct point {
int x, y;
bool operator <(const point & p) const {
if (x != p.x)return x < p.x;
else return y < p.y;
}
};
set<point> P;
int n;
int a[31];
int dx[] = { 0,1,1,1,0,-1,-1,-1 };
int dy[] = { 1,1,0,-1,-1,-1,0,1 };
void dfs(int x, int y, int index,int dir) {
if (index > n) return;
dfs(x + dx[dir] * a[index], y + dy[dir] * a[index], index + 1 ,(dir + 1) % 8);
//对称复制
set<point> temp;
for (auto &Q : P) {
if (dir % 4 == 0) {
temp.insert({ 2 * x - Q.x,Q.y });
}
else if (dir % 4 == 1) {
temp.insert({ x + Q.y - y,y + Q.x - x });
}
else if (dir % 4 == 2) {
temp.insert({Q.x,2 * y -Q.y });
}
else if (dir % 4 == 3) {
temp.insert({ x + y - Q.y,y - Q.x + x });
}
}
P.insert(temp.begin(), temp.end());
for (int i = 0; i < a[index]; i++) {
x = x + dx[dir];
y = y + dy[dir];
P.insert({ x,y });
}
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dfs(0, 0, 0, 0);
cout << P.size() << endl;
return 0;
}
