描述：

城堡是一个4×4的方格，为了保卫城堡，现需要在某些格子里修建一些堡垒。城堡中的某些格子是墙，其余格子都是空格，堡垒只能建在空格里，每个堡垒都可以向上下左右四个方向射击，如果两个堡垒在同一行或同一列，且中间没有墙相隔，则两个堡垒都会把对方打掉。问对于给定的一种状态，最多能够修建几个堡垒。

输入：
每个测例以一个整数n（1<=n<=4）开始，表示城堡的大小。接下来是n行字符每行n个，‘X’表示该位置是墙，‘.’表示该位置是空格。n等于0标志输入结束。

输出：
每个测例在单独的一行输出一个整数：最多修建堡垒的个数。

输入样例：
4
.X..
….
XX..
….
2
XX
.X
3
.X.
X.X
.X.
3
…
.XX
.XX
4
….
….
….
….
0
输出样例：
5
1
5
2
4

代码如下：

#include <iostream>
using namespace std;
int curNum = 0;
int MAX = 0;
char A[10000][10000] = { 0 };


void search(int i, int n);
bool isCanPut(int x, int y, int n);

int main() {
    int test[100];
    int j = 0;
    int n = -1;
    while (1) {
    cin >> n;
    if (n != 0) {
    for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
    cin >> A[i][j];
    }
    }
    search(0, n);

    test[j++] = MAX;

    MAX = 0;
    curNum = 0;
    }
    else {
    break;
    }
    }

    for (int i = 0; i < j; i++) {
    cout << test[i] << endl;
    }


}

/* 回溯法查找 */
void search(int i, int n) {
    int x = i / n;
    int y = i % n;

    if (i == n*n) {
        if (MAX < curNum) {
            MAX = curNum;
        }
    }
    else {
        if (isCanPut(x, y, n)) {
            //检查左支
            A[x][y] = 'T';
            curNum++;
            search(i + 1, n);
            //恢复
            curNum--;
            A[x][y] = '.';          
        }
        search(i + 1, n);

    }

}


/* 剪枝条件 */

bool isCanPut(int x, int y, int n) {
    //如果两个堡垒在同一行或同一列，且中间没有墙相隔，则两个堡垒都会把对方打掉
    // 1.该点是空格 2.在同行没有墙的情况下同行没有多余堡垒 3. 在有墙的情况下可以相隔有堡垒

    int r = x;
    int c = y;
    if (A[x][y] != '.') { //墙或者是堡垒
        return false;
    }

    while (y >= 0 && A[r][y] == '.') {
        y--;
    }
    if (y < 0 || (y >= 0 && A[r][y] == 'X')) { //满足行的条件
        while (x >= 0 && A[x][c] == '.') {
            x--;
        }
        if (x < 0 || (x >= 0 && A[x][c] == 'X')) {
            return true;
        }
    }

    return false;
}


/* 4 .X.. .... XX.. .... 2 XX .X 3 .X. X.X .X. 3 ... .XX .XX 4 .... .... .... .... 0 */