La description
Donnez un graphique de grille de $ n \ fois m $ avec la couleur et la direction à chaque emplacement. La couleur est noir / blanc et la direction indique dans quelle direction le robot à cette position se déplacera vers le haut, le bas, la gauche et la droite par une grille, et demandez combien de robots vous pouvez placer au maximum, afin que ces robots ne se rencontrent jamais en marchant. Sur la base de la maximisation du nombre, maximisez le nombre de robots à grille noire.
Solution
C'est vraiment métaphysique de continuer indéfiniment et de voir si cela peut être transformé.
En raison de la grille limitée, donc illimité $ = $ circulation .
Pour le dire autrement, nous pouvons d'abord mettre chaque position sur le robot, et continuer à marcher, la supprimer sera répétée.
De toute évidence, chaque robot passe d'abord par une course à pied, puis marche dans un anneau.
Par exemple, si nous avons maintenant deux robots, comment savoir s'ils vont se répéter?
Supposons d'abord que les deux robots ne se sont pas rencontrés lorsqu'ils ont couru, c'est-à-dire qu'ils ont atteint leur propre anneau cible, puis ils ne se rencontreraient jamais. C'est facile à comprendre. S'ils ne sont pas dans un ring, il est évidemment impossible de les rencontrer; s'ils sont dans un ring (bien sûr, s'ils ne sont pas en position), alors la distance entre eux ne changera jamais et ne se rencontrera jamais. .
Par conséquent, la condition nécessaire et suffisante pour que les deux robots se rencontrent est de se rencontrer sur la route, et après cela, celui qui s'est rencontré devrait avoir marché ensemble, et celui qui n'aurait pas dû se rencontrer ne sera jamais touché.
Par conséquent, la longueur de chaque route ne doit pas dépasser la taille totale de la carte (c'est-à-dire $ nm $), nous n'avons donc qu'à laisser le robot à chaque position faire le pas $ nm $, puis calculer la position.
En ce qui concerne les statistiques spécifiques, vous pouvez obtenir un $ have_ {0/1, \ text {pos}} $ pour indiquer le dernier $ \ text {pos} $ y a-t-il un robot noir / blanc à cet emplacement, puis laissez $ tot $ représenter le total, $ black $ représente le nombre total de robots noirs, alors c'est:
$$ \ begin {array} {l | l} 1 & \ textbf {for} i \ obtient 1 \ textbf {to} nm \ textbf {do} \\ 2 & \ qquad \ textbf {if} have_ {0, i } = \ text {true} \ textbf {then} tot \ gets tot + 1, black \ gets black + 1 \\ 3 & \ qquad \ textbf {else if} have_ {1, i} = \ text {true} \ textbf {then} tot \ obtient tot + 1 \\ 4 & \ qquad \ textbf {end if} \\ 5 & \ textbf {end for} \ end {array} $$
Le code est pour référence seulement.
#include <bits / stdc ++. h> en
utilisant l'espace de noms std;
const int NM = 1e6 + 5, LGSZ = 21;
int n, m, nxt [LGSZ] [NM];
char dir [NM], col [NM], buf [NM];
bool have [2] [NM];
int main ()
{
int t;
scanf ("% d", & t);
while (t--)
{
scanf ("% d% d", & n, & m);
pour (int i = 1; i <= n * m; i ++)
have [0] [i] = have [1] [i] = false;
pour (int i = 1; i <= n; i ++)
{
scanf ("% s", buf + 1);
pour (int j = 1; j <= m; j ++)
col [(i - 1) * m + j] = buf [j];
}
pour (int i = 1; i <= n; i ++)
{
scanf ("% s", buf + 1);
}
for (int i = 1; i <= n * m; i ++)
switch (dir [i])
{
case 'U': nxt [0] [i] = i - m; Pause;
cas 'D': nxt [0] [i] = i + m; Pause;
cas 'L': nxt [0] [i] = i - 1; Pause;
cas 'R': nxt [0] [i] = i + 1; Pause;
}
pour (int i = 1; i <LGSZ; i ++)
pour (int j = 1; j <= n * m; j ++)
nxt [i] [j] = nxt [i - 1] [nxt [i - 1 ] [j]];
pour (int i = 1; i <= n * m; i ++)
{
int pos = i;
pour (int j = LGSZ - 1; ~ j; j--)
if (n * m >> j & 1) pos = nxt [j] [pos];
avoir [col [i] ^ 48] [pos] = true;
}
int noir = 0, tot = 0;
for (int i = 1; i <= n * m; i ++)
{
if (have [0] [i]) tot ++, black ++;
else if (have [1] [i]) tot ++;
}
printf ("% d% d \ n", tot, noir);
}
return 0;
}