DFS blanco y negro

En matemáticas, el teorema de los cuatro colores, o el teorema del mapa de cuatro colores, establece que, dada cualquier separación de un plano en regiones contiguas, produciendo una figura llamada mapa, no se requieren más de cuatro colores para colorear las regiones del mapa. que no hay dos regiones adyacentes que tengan el mismo color.
- Wikipedia, la enciclopedia libre

En este problema, debe resolver el problema de los 4 colores. Oye, solo estoy bromeando.

Se le pide que resuelva un problema similar:

coloree un tablero de ajedrez N × M con K colores numerados del 1 al K, de modo que no haya dos celdas adyacentes que tengan el mismo color (dos celdas son adyacentes si comparten un borde). El i-ésimo color debe usarse exactamente en las celdas c _i .

Matt espera que puedas decirle una posible coloración.

Entrada La primera línea contiene solo un número entero T (1 ≤ T ≤ 5000), que indica el número de casos de prueba.

Para cada caso de prueba, la primera línea contiene tres enteros: N, M, K (0 <N, M ≤ 5, 0 <K ≤ N × M).

La segunda línea contiene K enteros c _i (c _i > 0), que indica el número de celdas donde se debe usar el i-ésimo color.

Se garantiza que c ₁ + c ₂ + · · · + c _K = N × M.
Salida Para cada caso de prueba, la primera línea contiene "Caso #x:", donde x es el número de caso (a partir de 1).

En la segunda línea, escriba "NO" si no hay colores que satisfagan los requisitos. De lo contrario, envíe "SÍ" en una línea. Cada una de las siguientes N líneas contiene números M separados por espacios en blanco, que denotan el color de las celdas.

Si hay varias soluciones, envíe cualquiera de ellas.

Salida de muestra

Caso n. ° 1: 
NO 
Caso n. ° 2: 
SÍ 
4 3 4 
2 1 2 
4 3 4 
Caso n. ° 3: 
SÍ 
1 2 3 
2 3 1 
Caso n. ° 4: 
SÍ 
1 2 
2 3 
3 1 
Nada que decir, dfsdfsdfs

// #include <bits / stdc ++. h> 
#include <iostream> 
#include <cstdio> 
#include <cmath> 
#include <cstring> 
#include <algorithm> 
#include <queue>
 usando  namespace std; 
typedef largo  largo LL;
const LL INF = 1e13;
const  int mod = 1000000007 ;
const  int mx = 1e7; // verifica los límites, dummy 
typedef pair < int , int > pa;
//const doble PI = acos (-1);
// ll gcd (ll a, ll b) {return b? mcd (b, a% b): a; } 
#define swa (a, b) a ^ = b ^ = a ^ = b
 #define re (i, a, b) for (int i = (a), _ = (b); i <_; i ++)
 #define rb (i, a, b) para (int i = (b), _ = (a); i> = _; i--)
 #define clr (a) memset (a, 0, sizeof (a) )
 #define lowbit (x) ((x) & (x-1))
 // #define mkp make_pai 
void sc ( int & x) {scanf ( " % d " , & x); } void sc (int64_t & x) {scanf ( " % lld " , & x); } void sc ( doble & x) {scanf ( "" , & x);} void sc ( char & x) {scanf ( " % c " , & x);} void sc ( char * x) {scanf ( " % s " , x);}
 int n, m, k , ans;
 int a [mx], mp [ 55 ] [ 55 ];
 bool flag;
 bool dfs ( int x, int y, int r) {
     if (! r) { 
        flag = 1 ;
         return  1 ; 
    } 
    re (i ,1 , k + 1 ) if (a [i]> (r + 1 ) / 2 ) devuelve  0 ; 
    re (i, 1 , k + 1 ) {
         if (a [i]) {
             if (x && mp [x - 1 ] [y] == i) continuar ;
            if (y && mp [x] [y - 1 ] == i) continuar ; 
            a [i] - ; 
            pf [x] [y] = i;
            if (y <m - 1 ) dfs (x, y + 1 , r - 1);
            sino dfs (x + 1 , 0 , r - 1 );
            si (bandera) devuelve  1 ; 
            a [i] ++ ; 
        } 
    } 
    devuelve  0 ; 
} 
int main () 
{ 
    ios :: sync_with_stdio ( false ); cin.tie ( 0 ); cout.tie ( 0 );
    int T, cas = 1 ; 
    scanf ( " % d " , & T);
    mientras que (T-- )
    { 
        clr (mp); 
        bandera = 0 ; 
        sc (n), sc (m), sc (k); 
        re (i, 1 , k + 1 ) sc (a [i]); 

        printf ( " Caso #% d: \ n " , cas ++ );
        if (! dfs ( 0 , 0 , n * m)) { 
            pone ( " NO " );
            continuar ; 
        } 
        pone ( " SÍ " ); 
        re (i, 0 , n) re (j, 0 , m) printf (j == m -1 ? " % d \ n " : " % d " , mp [i] [j]); 
    } 
    devuelve  0 ; 
}

Supongo que te gusta