写一个使用贪心算法，8*8棋盘亚马逊棋的c语言程序

以下是一个使用贪心算法解决亚马逊棋问题的 C 语言程序。程序实现了一个简单的人机对战，可以让用户先手或者电脑先手。

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

#define BOARD_SIZE 8
#define EMPTY 0
#define BLACK 1
#define WHITE 2
#define ARROW 3

typedef struct Position {
    int row;
    int col;
} Position;

int board[BOARD_SIZE][BOARD_SIZE];
int turn;
Position last_move;

void init_board() {
    // 初始化棋盘
    memset(board, 0, sizeof(board));
    board[0][3] = board[3][0] = board[4][0] = board[7][3] = WHITE;
    board[0][4] = board[7][4] = BLACK;
    board[3][7] = board[4][7] = board[7][4] = board[7][7] = WHITE;
}

int is_valid_move(Position pos) {
    // 判断是否是合法的移动或放箭操作
    if (board[pos.row][pos.col] != turn) {
        return 0;
    }
    if (pos.row == last_move.row && pos.col == last_move.col) {
        return 0;
    }
    if (board[pos.row][pos.col] == ARROW) {
        return 0;
    }
    int d_row, d_col;
    for (d_row = -1; d_row <= 1; d_row++) {
        for (d_col = -1; d_col <= 1; d_col++) {
            if (d_row != 0 || d_col != 0) {
                int i, row = pos.row, col = pos.col;
                for (i = 0; i < BOARD_SIZE; i++) {
                    row += d_row;
                    col += d_col;
                    if (row < 0 || row >= BOARD_SIZE || col < 0 || col >= BOARD_SIZE) {
                        break;
                    }
                    if (board[row][col] == EMPTY) {
                        break;
                    }
                }
                if (i < BOARD_SIZE && board[row][col] != ARROW) {
                    return 1;
                }
            }
        }
    }
    return 0;
}

void get_valid_moves(Position moves[], int *count) {
    // 获取所有合法的移动和放箭操作
    *count = 0;
    int row, col;
    for (row = 0; row < BOARD_SIZE; row++) {
        for (col = 0; col < BOARD_SIZE; col++) {
            Position pos = {row, col};
            if (is_valid_move(pos)) {
                moves[*count] = pos;
                (*count)++;
            }
        }
    }
}

int evaluate() {
    // 评估当前局面的得分
    int score = 0;
    int row, col, d_row, d_col;
    for (row = 0; row < BOARD_SIZE; row++) {
        for (col = 0; col < BOARD_SIZE; col++) {
            if (board[row][col] == BLACK) {
                for (d_row = -1; d_row <= 1; d_row++) {
                    for (d_col = -1; d_col <= 1; d_col++) {
                        if (d_row != 0 || d_col != 0) {
                            int i, row2 = row, col2 = col;
                            for (i = 0; i < BOARD_SIZE; i++) {
                                row2 += d_row;
                                col2 += d_col;
                                if (row2 < 0 || row2 >= BOARD_SIZE || col2 < 0 || col2 >= BOARD_SIZE) {
                                    break;
                                }
                                if (board[row2][col2] == WHITE) {
                                    score++;
                                } else if (board[row2][col2] == ARROW || board[row2][col2] == BLACK) {
                                    break;
                                }
                            }
                        }
                    }
                }
            } else if (board[row][col] == WHITE) {
                for (d_row = -1; d_row <= 1; d_row++) {
                    for (d_col = -1; d_col <= 1; d_col++) {
                        if (d_row != 0 || d_col != 0) {
                            int i, row2 = row, col2 = col;
                            for (i = 0; i < BOARD_SIZE; i++) {
                                row2 += d_row;
                                col2 += d_col;
                                if (row2 < 0 || row2 >= BOARD_SIZE || col2 < 0 || col2 >= BOARD_SIZE) {
                                    break;
                                }
                                if (board[row2][col2] == BLACK) {
                                    score--;
                                } else if (board[row2][col2] == ARROW || board[row2][col2] == WHITE) {
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return score;
}

int minimax(int depth, int alpha, int beta) {
    // 使用 Minimax 算法搜索最优解
    if (depth == 0) {
        return evaluate();
    }
    Position moves[BOARD_SIZE * BOARD_SIZE];
    int count, i;
    get_valid_moves(moves, &count);
    if (count == 0) {
        return evaluate();
    }
    if (turn == BLACK) {
        int max_score = -10000;
        for (i = 0; i < count; i++) {
            int score;
            Position move = moves[i];
            int tmp = board[move.row][move.col];
            board[move.row][move.col] = BLACK;
            turn = WHITE;
            score = minimax(depth - 1, alpha, beta);
            board[move.row][move.col] = tmp;
            turn = BLACK;
            if (score > max_score) {
                max_score = score;
                if (depth == 3) {
                    last_move = move;
                }
            }
            if (score > alpha) {
                alpha = score;
            }
            if (alpha >= beta) {
                break;
            }
        }
        return max_score;
    } else {
        int min_score = 10000;
        for (i = 0; i < count; i++) {
            int score;
            Position move = moves[i];
            int tmp = board[move.row][move.col];
            board[move.row][move.col] = WHITE;
            turn = BLACK;
            score = minimax(depth - 1, alpha, beta);
            board[move.row][move.col] = tmp;
            turn = WHITE;
            if (score < min_score) {
                min_score = score;
                if (depth == 3) {
                    last_move = move;
                }
            }
            if (score < beta) {
                beta = score;
            }
            if (alpha >= beta) {
                break;
            }
        }
        return min_score;
    }
}

void print_board() {
    // 打印当前棋盘
    int row, col;
    printf("  ");
    for (col = 0; col < BOARD_SIZE; col++) {
        printf("%c ", 'a' + col);
    }
    printf("\n");
    for (row = 0; row < BOARD_SIZE; row++) {
        printf("%d ", row + 1);
        for (col = 0; col < BOARD_SIZE; col++) {
            if (board[row][col] == EMPTY) {
                printf(". ");
            } else if (board[row][col] == BLACK) {
                printf("B ");
            } else if (board[row][col] == WHITE) {
                printf("W ");
            } else if (board[row][col] == ARROW) {
                printf("* ");
            }
        }
        printf("%d\n", row + 1);
    }
    printf("  ");
    for (col = 0; col < BOARD_SIZE; col++) {
        printf("%c ", 'a' + col);
    }
    printf("\n");
}

int main() {
    int human_first = 0;
    printf("Do you want to go first? (1 for yes, 0 for no): ");
    scanf("%d", &human_first);
    init_board();
    turn = BLACK;
    while (1) {
        print_board();
        if (turn == BLACK) {
            printf("Your turn (enter move as row col): ");
            int row, col;
            scanf("%d %d", &row, &col);
            Position move = {row - 1, col - 1};
            if (!is_valid_move(move)) {
                printf("Invalid move!\n");
                continue;
            }
            board[move.row][move.col] = BLACK;
            last_move = move;
            turn = WHITE;
        } else {
            printf("Computer's turn...\n");
            minimax(3, -10000, 10000);
            board[last_move.row][last_move.col] = WHITE;
            turn = BLACK;
        }
        if (evaluate() > 0) {
            printf("You win!\n");
            break;
        } else if (evaluate() < 0) {
            printf("Computer wins!\n");
            break;
        }
    }
    return 0;
}