【ACWing】 1116. Dia de caminhada a cavalo

Endereço do assunto:

https://www.acwing.com/problem/content/1118/

Os cavalos se movem no xadrez chinês em um padrão japonês. Escreva um programa, dado $n\ast$tabuleiro de xadrez de tamanho$m$ , e a posição inicial do cavalo$(x,y)$ , é necessário que o mesmo ponto no tabuleiro de xadrez não possa ser repetido e de quantas maneiras o cavalo pode atravessar todos os pontos do tabuleiro.

Formato de entrada: a
primeira linha é um TT inteiro$T$ representa o número de grupos de dados de teste. Cada conjunto de dados de teste contém uma linha, quatro inteiros, que são do tamanho do tabuleiro de xadrez e as coordenadas da posição inicial$n,m,x,e$。

Formato de saída:
cada conjunto de dados de teste contém uma linha, que é um número inteiro, que representa o número total de maneiras pelas quais o cavalo pode atravessar o tabuleiro. Se ele não puder atravessar todos os pontos no tabuleiro, a saída será $0$。

Faixa de dados:
$1\le T\le 9$
$1\le m,n\le 9$
$0\le x\le n-1$
$0\le Y\le m-1$

Partindo de um determinado estado, cada etapa irá para uma bifurcação na árvore de pesquisa. Como o caminho não está apenas relacionado a quais grades são passadas, mas também como ir (ou seja, para qual direção cada etapa deve seguir), então pesquisa Os nós na árvore não são sobrepostos e só podem ser pesquisados ​​usando a força bruta DFS. O estado legal é que o número de grades passadas é exatamente $nm$ tempo. Você não pode sair dos limites a cada passo, e você não pode ir para a grade que você andou antes. código mostrado abaixo:

#include <iostream>
#include <cstring>
using namespace std;

const int N = 10;
int dx[] = {
    
    -1, -2, -2, -1, 1, 2, 2, 1};
int dy[] = {
    
    -2, -1, 1, 2, 2, 1, -1, -2};
int m, n;
// 记录哪些格子被走过
bool st[N][N];
// 用个全局变量记录走过的格子数量
int res;

// cnt记录走过了多少个格子
void dfs(int x, int y, int cnt) {
    
    
    st[x][y] = true;
    cnt++;

    if (cnt == n * m) res++;
    else 
        for (int i = 0; i < 8; i++) {
    
    
            int nx = x + dx[i], ny = y + dy[i];
            if (0 <= nx && nx < n && 0 <= ny && ny < m && !st[nx][ny])
                dfs(nx, ny, cnt);
        }

    st[x][y] = false;
}

int main() {
    
    
    int T;
    cin >> T;
    while (T--) {
    
    
        int x, y;
        cin >> n >> m >> x >> y;
        memset(st, false, sizeof st);

        res = 0;
        dfs(x, y, 0);

        cout << res << endl;
    }

    return 0;
}

A complexidade do tempo é exponencial, espaço $O\left(nm\right)$。