谷歌校园招聘在线笔试题题目一道

写一道吧，2013年第二轮第三题。

这一题在规定的时间内没有做出来，第二天看了一下题目，觉得可以做，谁知道这一做就是一天...

题意描述：

给定一个n*n的棋盘，如下图：

棋盘的上下两端是红色的，左右两端是蓝色的，四个角红色蓝色共享。红色蓝色轮流（先后随机）向棋盘中摆放一个棋子，率先联通两边者获胜（红色联通上下，蓝色联通左右）。求给定状态的棋盘是否合法（impossible,red wins,blue wins, nobody wins）。

这个题目瞬间想到了当时校赛的五子棋是否合法，但是惭愧的是至今没有做出那一个题...

解题思路：

个人觉得这一个题目主要是考验思维的缜密和短时间的代码能力，遗憾的是两者我都没有...

首先是，如何判断获胜？获胜的条件是，左右联通或者上下联通。这里把上下左右四条边，看作四个定点，那么只要存在一条路径将上下联通或者左右联通即是有人获胜。于是我想到了并查集合。将棋盘中每个点都看作一个点，与他相邻的六个点，如果颜色相同，那么即是存在一条边相连，即可把他们union。因此在整个地图输入之后，遍历一边图，即可得到获胜情况。注意的是，我们把四个边当作了四个定点，那么对每一个与边相邻的其他的定点都应当与该边进行一次判断，颜色相同就union。

接下来是如何判断非法情况？

这个问题，一开始觉得很简单，胡乱写了一个交了wa了多次，最后在纸上推敲了半天发现是没有覆盖完全。下面给出我的思路：

首先判断两个棋子差距的绝对值是不是大于。如果大于1，非法。

之后根据胜负情况进行讨论。首先两个都获胜，非法（今天看的时候感觉这种情况不会存在，欢迎大家讨论了）。

当其中有一方获胜的时候：如果红色胜但是蓝色棋子多，非法；蓝色胜红色棋子多同样非法。之外的只有一方胜利的情况下需要找到最后制胜的那枚棋子。找到这枚棋子的方法是，去掉获胜方的一枚棋子，然后判断胜负，如果不能获胜，则说明这是一个关键子，如果没有关键子的话，状态非法。

剩下的状态就是合法状态。

代码：

#include <iostream>
#include <cstring>

using namespace std;

const int MAXSIZE = 100+5;

char map[MAXSIZE][MAXSIZE];

int state[MAXSIZE*MAXSIZE+4];

const int nextX[] = {-1,-1,0,0,1,1};
const int nextY[] = {0,1,-1,1,-1,0};

int n,R,B;

int UP,LEFT,DOWN,RIGHT;

int F( int x ) {
    int t = x;
    while ( state[t] != t ) {
    t = state[t];
    }
    return t;
}

void U( int x,  int y ) {
    if ( x != y ) {
    int fx = F(x);
    int fy = F(y);
    if ( fx != fy ) {
    state[fy] = fx;
    }
    }
}

void input(){
    cin>>n;
    R = 0;
    B = 0;
    UP = n*n;
    LEFT = UP+1;
    DOWN = LEFT+1;
    RIGHT = DOWN+1;
    memset(map,0,sizeof(map));
    for ( int i = 0; i < n; i++ ) {
    for ( int j = 0; j < n; j++ ) {
        cin>>map[i][j];
        if ( map[i][j] == 'R' ) {
        R++;
        }
        else if ( map[i][j] == 'B' ) {
        B++;
        }
    }
    }

}

int inrange(int x, int y ) {
    return ( ( x >= 0 ) && ( x < n ) && ( y >= 0 ) && ( y < n )  );
}

void check(int x, int y, int nx, int ny){
    if ( ! ( inrange(x,y) && inrange(nx,ny) ) ){
    return;
    }
    if ( map[x][y] == map[nx][ny] ) {
    U(x*n+y,nx*n+ny);
    }
    return;
}

int flood(){
    memset(state,0,sizeof(state));
    for ( int i = 0; i < MAXSIZE*MAXSIZE+4; i++ ) {
    state[i] = i;
    }
    for ( int i = 0; i < n; i++ ){
    if ( map[0][i] == 'R' ) {
        U(UP,i);
    }
    if ( map[n-1][i] == 'R' ) {
        U(DOWN,n*(n-1)+i);
    }
    if ( map[i][0] == 'B' ) {
        U(LEFT,i*n);
    }
    if ( map[i][n-1] == 'B' ) {
        U(RIGHT,i*n+n-1);
    }
    }
    
    for ( int i = 0; i < n; i++ ) {
    for ( int j = 0; j < n; j++ ) {
        if ( map[i][j] != '.' ) {
        for ( int k = 0; k < 6; k++ ) {
            int nx = i+nextX[k];
            int ny = j+nextY[k];
            check(i,j,nx,ny);
        }
        }
        // for ( int k = 0; k < n*n; k++ ){
        //if ( k % n == 0 ) cout<<endl;
        //    cout<<state[k]<<" ";
        //}
        //cout<<"~~~~~
";
    }
    }
}

int Bwin(){
    return F(LEFT) == F(RIGHT);
}

int Rwin(){
    return F(UP) == F(DOWN);
}

int possible(){
    int t = R-B;
    int rw = Rwin();
    int bw = Bwin();
    t = t > 0? t:-t;
    // cout<<state[UP]<<" "<<state[LEFT]<<" "<<state[DOWN]<<" "<<state[RIGHT]<<endl;
    //cout<<rw<<" "<<bw<<" "<<t<<endl;
    if ( t > 1 ) {
    return 0;
    }
    if ( rw && bw ){
    return 0;
    }
            
    if ( rw && ( B > R ) ) {
    return 0;
    }
    
    if ( bw && ( R > B ) ) {
    return 0;
    }

    if ( rw || bw ){
    int mark = 0;
    for ( int i = 0; i < n; i++ ) {
        for ( int j = 0; j < n; j++ ){
        if ( rw && ( map[i][j] == 'R' ) ){
            map[i][j] = '.';
            flood();
            if ( !Rwin() ){
            mark ++;
            }
            map[i][j] = 'R';
        }
        if ( bw && ( map[i][j] == 'B' ) ) {
            map[i][j] = '.';
            flood();
            if ( !Bwin() ){
            mark ++;
            }
            map[i][j] = 'B';
        }
        if ( mark != 0 ) return 1;
        }
    }
    if ( mark == 0 ) return 0;
    }

    return 1;
}    

void solve(int x) {
    input();
    flood();
    int rw = Rwin();
    int bw = Bwin();
    cout<<"Case #"<<x<<": ";
    if ( !possible() ) {
    cout<<"Impossible
";
    return;
    }
    if ( bw ) {
    cout<<"Blue wins
";
    return;
    }
    if ( rw ) {
    cout<<"Red wins
";
    return;
    }
    cout<<"Nobody wins
";
    return;
}

int main(){
    int t;
    cin>>t;
    for ( int i = 1; i <= t; i++ ) {
    solve(i);
    }
    return 0;
}

    

 

最后在编码的时候犯了很多很多的错误，很多很多的小细节，最后研究了将近一天，才弄明白怎么回事儿，最后还是那句话，等完全想明白了，再动手。