用DFS算法设计一个推箱子胜负判定，c语言

好的，推箱子游戏的胜负判定可以通过深度优先搜索（DFS）算法实现。以下是C语言实现的代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAXN 20

// 地图大小
int n, m;

// 地图
char map[MAXN][MAXN];

// 记录箱子和人的位置
int bx, by, px, py;

// 记录箱子是否到达终点
bool box_reached;

// 记录访问状态
bool visited[MAXN][MAXN][MAXN][MAXN];

// DFS搜索函数
bool dfs(int bx, int by, int px, int py) {
    // 如果箱子到达终点，返回true
    if (map[bx][by] == 'O') {
        box_reached = true;
        return true;
    }
    
    // 标记当前状态为已访问
    visited[bx][by][px][py] = true;

    // 从当前位置向四个方向移动
    int dx[4] = {0, 0, -1, 1};
    int dy[4] = {-1, 1, 0, 0};
    for (int i = 0; i < 4; i++) {
        int nx = bx + dx[i];
        int ny = by + dy[i];
        int tx = px + dx[i];
        int ty = py + dy[i];
        
        // 如果下一步位置越界或者是障碍物，跳过
        if (nx < 0 || nx >= n || ny < 0 || ny >= m || map[nx][ny] == '#') continue;
        
        // 如果下一步位置是箱子，尝试推动箱子
        if (nx == px && ny == py) {
            int tx2 = px + dx[i];
            int ty2 = py + dy[i];
            
            // 如果箱子下一步位置越界或者是障碍物，跳过
            if (tx2 < 0 || tx2 >= n || ty2 < 0 || ty2 >= m || map[tx2][ty2] == '#') continue;
            
            // 如果箱子下一步位置已经被访问过，跳过
            if (visited[nx][ny][tx2][ty2]) continue;
            
            // 记录箱子和人的新位置
            int bx2 = nx;
            int by2 = ny;
            int px2 = tx2;
            int py2 = ty2;
            
            // 递归搜索
            if (dfs(bx2, by2, px2, py2)) return true;
        } else {
            // 如果下一步位置已经被访问过，跳过
            if (visited[nx][ny][px][py]) continue;
            
            // 记录箱子和人的新位置
            int bx2 = bx;
            int by2 = by;
            int px2 = nx;
            int py2 = ny;
            
            // 递归搜索
            if (dfs(bx2, by2, px2, py2)) return true;
        }
    }
    
    // 标记当前状态为未访问
    visited[bx][by][px][py] = false;

    // 如果箱子已经到达终点，返回true
    if (box_reached) return true;
    
    // 否则返回false
    return false;
}

int main() {
    // 读入地图大小和地图
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%s", map[i]);
        for (int j = 0; j < m; j++) {
            if (map[i][j] == 'B') {
                bx = i;
                by = j;
            } else if (map[i][j] == 'S') {
                px = i;
                py = j;
            }
        }
    }
    
    // 初始化访问状态
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            for (int k = 0; k < n; k++) {
                for (int l = 0; l < m; l++) {
                    visited[i][j][k][l] = false;
                }
            }
        }
    }
    
    // 搜索
    if (dfs(bx, by, px, py)) {
        printf("YES\n");
    } else {
        printf("NO\n");
    }
    
    return 0;
}

在该算法中，我们使用visited数组记录访问状态，避免重复访问同一个状态。在搜索时，如果下一步位置已经被访问过，我们直接跳过。同时，我们记录箱子和人的位置，并根据下一步的情况分别处理。如果下一步是箱子，我们尝试推动箱子。如果下一步是空地，我们直接移动人的位置。如果箱子到达终点，我们返回true，否则返回false。最终根据搜索结果判断胜负。