关于java连连看游戏的算法

Question

我写过一个，用递归找出路径。

Answer 1

是不是广度遍历，能不能详细的讲一下呢。

Answer 2

我写过一个连连看外挂。就是用广度优先搜索的。
#include <iostream>
#define COL 19
#define ROW 11
using namespace std;
int map[ROW][COL];
int mturn[ROW][COL];
struct point {
    int x;
    int y;
    int pret;
    int turn;
};
point ans,start;
point queue[ROW*COL*2];
int dx[4] = {-1,0,1,0}; //上，右，下，左  0 1 2 3
int dy[4] = {0,1,0,-1};
int deal(int pret,int turn) {
    if (pret == -1) {
        return 0;
    } else {
        if ( pret == 0 || pret == 2) {
            if (turn == 1 || turn == 3) {
                return 1;
            } else {
                return 0;
            }
        } else {
            if ( turn == 0 || turn == 2) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}
bool check(int x,int y,int turn) {
    if ( x >= 0 && x < ROW && y >= 0 && y < COL && turn <= 2 && turn < mturn[x][y]) {
        return true;
    } else {
        return false;
    }
}
bool bfs(int x,int y) {
   // cout << " x " << x << " y " << y << endl; //
   // char cc; //
   // cin >> cc; //
    int top = 0, end = 0, i;
    point r,c;
    start.x = x;
    start.y = y;
    start.pret = -1;
    start.turn = 0;
    queue[top] = start;
    mturn[x][y] = 0;
    while (top <= end) {
        c = queue[top];        for (i = 0; i < 4; i++) {
            r.x = c.x + dx[i];
            r.y = c.y + dy[i];
            r.pret = i;
            r.turn =c.turn + deal(c.pret,i);
            /*
            cout <<"r.x "<<r.x << endl;
            cout <<"r.y "<<r.y << endl;
            cout <<"r.pret " <<r.pret << endl;
            cout <<"r.turn " <<r.turn << endl;
            */
            if ( check(r.x,r.y,r.turn) ) {
                if ( map[start.x][start.y] == map[r.x][r.y] ) {
                    ans.x = r.x;
                    ans.y = r.y;
                    return true;
                } else if ( map[r.x][r.y] == 0) {
                    mturn[r.x][r.y] = r.turn;
                    queue[++end] = r;
                    //cout << r.x <<" " << r.y << endl;//
                }
            }        }
        top++;
    }
    return false;
}
void init() {
    int i,j;
    for (i = 0; i < ROW; i++) {
        for ( j = 0; j < COL; j++) {
            mturn[i][j] = 10;
        }
    }
}
void move() {
    int i,j;
    int count = 0;
    for (i = 0; i < ROW;i++) {
        for ( j = 0; j < COL; j++) {
            if ( map[i][j] != 0) {
                count++;
            }
        }
    }
    while (count != 0) {
        for (i = 0; i < ROW; i++) {
            for (j = 0; j < COL; j++) {
                if ( map[i][j] != 0) {
                    init();
                    if ( bfs(i,j) ) {
                        count -= 2;
                        map[start.x][start.y] = 0;
                        map[ans.x][ans.y] = 0;
                        //click();
                        cout <<"start.x:"<<start.x<<"  "<<"start.y:"<<start.y << endl;
                        cout <<"ans.x:"<<ans.x <<"  "<<"ans.y:"<<ans.y << endl;                    }
                }
            }
        }
    }
}
int main()
{
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < COL; j++) {
            cin >> map[i][j];
        }
    }
    /*
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < COL; j++) {
            cout << map[i][j] <<" ";
        }
        cout << endl;
    }
    */
    move();
    return 0;
}
用c++写的。你不一定能看懂。不过，这算是一个比较简单的搜索问题。而且，这个问题。用广搜更经济一些。

Answer 3

外挂是实现，解连连看。也就是一步一步找点。而你要是做连连看的话，那问题应该是不一样的。你的问题应该是判断两个点，是否符合规则（能否消去）。更简单了，加限制条件的广搜就OK。挺简单的。