1077:N皇后

1077: N皇后

---

Description

检查一个如下的6 x 6的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列只有一个，每条对角线(包括两条主对角线的所有平行线)上至多有一个棋子。

列号
      1　 2　 3　 4　 5　 6

　　-------------------------

1 |　 | O |　 |　 |　 |　 |

　　-------------------------

2 |　 |　 |　 | O |　 |　 |

　　-------------------------

3 |　 |　 |　 |　 |　 | O |

　　-------------------------

4 | O |　 |　 |　 |　 |　 |

　　-------------------------

5 |　 |　 | O |　 |　 |　 |

　　-------------------------

6 |　 |　 |　 |　 | O |　 |

　　-------------------------

上面的布局可以用序列2 4 6 1 3 5来描述，第i个数字表示在第i行的相应位置有一个棋子，如下：
行号 1 2 3 4 5 6
列号 2 4 6 1 3 5
这只是跳棋放置的一个解。请编一个程序找出所有跳棋放置的解。并把它们以上面的序列方法输出。解按字典顺序排列。请输出前3个解。最后一行是解的总个数。

Input

输入包含多组测试数据，每组数据包含一个数字N (6 <= N <= 13) 表示棋盘是N x N大小的。

Output

对于每组测试数据，输出四行。

前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。

Sample Input

6

Sample Output

2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4

 

 

根据 八皇后问题 的思路，编写程序如下：

#include <iostream>
#define MAXN 15
using namespace std;
int cur,tot,n,count=0;
bool ok=0;
int C[MAXN];
void print(int k);
void search(int cur)
{   int i,j;
    if (cur == n)  /**递归边界，只要走到了这里，所有的皇后必然不冲突*/
    {
        if (count++ < 3) print(n); /**n为输入组数的规模*/
        tot++;
    }
    else
    for (i=0 ;i<n; i++)
    {
        int ok=1;
        C[cur]=i;              /**试把第cur行的皇后放在第i列*/
        for (j=0; j<cur ;j++ ) /**检查是否和前面的皇后有冲突*/
            if (C[cur]==C[j] || cur-C[cur]==j-C[j] || cur+C[cur]==j+C[j])
            { ok=0 ; break;}
            if (ok) search(cur+1);
    }
    return ;
}
void print(int k)
{
    for (int n=0;n<k;n++)
        if (n!=k-1) cout<<C[n]+1<<" ";
        else cout<<C[n]+1<<endl;
}
int main()
{
    while(cin>>n)
    {   tot=0;
        count=0;
        search(0);
        cout<<tot<<endl;
    }
    return 0;
}

 

其中print()函数用来输出题目要求的前三个解。
提交结果如下：

RunID	User	Problem	Result	Memory	Time	Language	Code Length	Submit Time
12502	20130030219	1077	Time Limit Exceed	1684	4000	C++/ Edit	1087 B	2014-04-21 11:48:31

 

这个算法是否还有优化的空间?经过思考，可以采用一个新的方法：利用二位数组vis[2][]直接判断当前尝试的皇后所在列和两个对角线是否已有其他皇后。注意到主对角线标识y-x可能为负，存取时要加上n。

 

void search(int cur)
{   int i;
    if (cur == n)  /**递归边界，只要走到了这里，所有的皇后必然不冲突*/
    {
        if (count++ < 3) print(n); /**n为输入组数的规模*/
        tot++;
    }
    else for (i=0 ;i<n; i++)
    {   if ( !vis[0][i] && !vis[1][cur+i] && !vis[2][cur-i+n])
        /**利用二维数组直接判断：当前尝试的皇后所在的列和两个对角线是否已有其他皇后*/
        {
            C[cur]=i;
            vis[0][i]=vis[1][cur+i]=vis[2][cur-i+n]=1; /**修改全局变量*/
            search(cur+1);
            vis[0][i]=vis[1][cur+i]=vis[2][cur-i+n]=0; /**切记！一定要改回来*/
        }
    }
}

 

上面的程序有个极其关键的地方：vis数组的使用。它表示已经放置的皇后占据了哪些列，主对角线和副对角线。将来放置的皇后不应该修改这些值。

 

最终通过程序如下：

#include <iostream>
#include <cstring>
#define MAXN 15
using namespace std;
int cur,tot,n,count=0;
bool ok=0;
int vis[4][90];
int C[MAXN];
void print(int k)
{
    for (int n=0;n<k;n++)
        if (n!=k-1) cout<<C[n]+1<<" ";
        else cout<<C[n]+1<<endl;
}
void search(int cur)
{   int i;
    if (cur == n)  /**递归边界，只要走到了这里，所有的皇后必然不冲突*/
    {
        if (count++ < 3) print(n); /**n为输入组数的规模*/
        tot++;
    }
    else for (i=0 ;i<n; i++)
    {
        if ( !vis[0][i] && !vis[1][cur+i] && !vis[2][cur-i+n])
        /**利用二维数组直接判断：当前尝试的皇后所在的列和两个对角线是否已有其他皇后*/
        {
            C[cur]=i;
            vis[0][i]=vis[1][cur+i]=vis[2][cur-i+n]= 1 ; /**修改全局变量*/
            search(cur+1);
            vis[0][i]=vis[1][cur+i]=vis[2][cur-i+n]= 0 ; /**切记！一定要改回来*/
        }
    }
}
int main()
{
    while(cin>>n)
    {   tot=0;
        count=0;
        search(0);
        cout<<tot<<endl;
    }
    return 0;
}