Linux环境下连连看游戏代码,《连连看》算法C语言演示(自动连连看)

以下是一个简单的连连看游戏算法的C语言演示代码：

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

#define ROWS 10
#define COLS 10

int board[ROWS][COLS] = {0}; // 游戏棋盘
int visited[ROWS][COLS] = {0}; // 访问数组
int path[2][100] = {0}; // 记录路径

void print_board(int b[ROWS][COLS])
{
    int i, j;

    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
}

void init_board()
{
    int i, j;

    // 初始化随机数种子
    srand((unsigned)time(NULL));

    // 随机生成一些棋子
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            board[i][j] = rand() % 6 + 1;
        }
    }
}

int is_link(int x1, int y1, int x2, int y2)
{
    int i, j;

    // 横向连通
    if (x1 == x2) {
        if (y1 < y2) {
            for (j = y1 + 1; j < y2; j++) {
                if (board[x1][j] != 0) {
                    return 0;
                }
            }
        } else {
            for (j = y2 + 1; j < y1; j++) {
                if (board[x1][j] != 0) {
                    return 0;
                }
            }
        }
        return 1;
    }

    // 纵向连通
    if (y1 == y2) {
        if (x1 < x2) {
            for (i = x1 + 1; i < x2; i++) {
                if (board[i][y1] != 0) {
                    return 0;
                }
            }
        } else {
            for (i = x2 + 1; i < x1; i++) {
                if (board[i][y1] != 0) {
                    return 0;
                }
            }
        }
        return 1;
    }

    // 其他情况
    return 0;
}

int dfs(int x1, int y1, int x2, int y2, int step)
{
    int i, j;

    // 到达目标点
    if (x1 == x2 && y1 == y2) {
        return step;
    }

    // 从四个方向搜索
    for (i = -1; i <= 1; i++) {
        for (j = -1; j <= 1; j++) {
            // 排除斜方向和原点
            if (i * j != 0 || (i == 0 && j == 0)) {
                continue;
            }

            // 计算新的坐标
            int new_x = x1 + i;
            int new_y = y1 + j;

            // 判断新坐标是否越界或已访问
            if (new_x < 0 || new_x >= ROWS || new_y < 0 || new_y >= COLS || visited[new_x][new_y]) {
                continue;
            }

            // 判断两点是否连通
            if (is_link(x1, y1, new_x, new_y)) {
                visited[new_x][new_y] = 1; // 标记已访问
                path[0][step] = new_x; // 记录路径
                path[1][step] = new_y;
                int ret = dfs(new_x, new_y, x2, y2, step + 1);
                if (ret > 0) {
                    return ret;
                }
                visited[new_x][new_y] = 0; // 取消标记
            }
        }
    }

    return 0;
}

int find_path(int x1, int y1, int x2, int y2)
{
    int i, j;

    // 初始化访问数组和路径数组
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            visited[i][j] = 0;
        }
    }
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 100; j++) {
            path[i][j] = -1;
        }
    }

    visited[x1][y1] = 1; // 标记起点已访问
    path[0][0] = x1; // 记录路径
    path[1][0] = y1;

    int len = dfs(x1, y1, x2, y2, 1); // 搜索路径

    if (len > 0) {
        return len;
    } else {
        return -1;
    }
}

int main()
{
    int x1, y1, x2, y2;
    int len;

    init_board();
    print_board(board);

    while (1) {
        printf("请输入第一个点的坐标(x, y)：");
        scanf("%d%d", &x1, &y1);
        printf("请输入第二个点的坐标(x, y)：");
        scanf("%d%d", &x2, &y2);

        // 判断坐标是否合法
        if (x1 < 0 || x1 >= ROWS || y1 < 0 || y1 >= COLS || x2 < 0 || x2 >= ROWS || y2 < 0 || y2 >= COLS) {
            printf("坐标越界，请重新输入！\n");
            continue;
        }

        // 判断两点是否相同
        if (x1 == x2 && y1 == y2) {
            printf("两点重合，请重新输入！\n");
            continue;
        }

        // 判断两点是否可以连通
        if (board[x1][y1] != board[x2][y2] || find_path(x1, y1, x2, y2) == -1) {
            printf("两点不连通，请重新输入！\n");
            continue;
        }

        // 连通成功，消除两个棋子
        board[x1][y1] = board[x2][y2] = 0;
        print_board(board);
    }

    return 0;
}

这个算法使用深度优先搜索来寻找两个点之间的路径，判断两个点是否可以连通。在判断两个点是否连通时，先判断两个点是否在同一行或同一列，然后再判断中间是否有其他棋子阻挡。如果两个点连通，则将它们消除。