这些天逛论坛,忽然发现可以用QS2算法求解N-皇后问题,而且效果比较好。之前学《人工智能》曾经用爬山法解决过,但当N上千时,效果很差。论坛里介绍QS2算法效果很好。自己便按照楼主给的思路和伪代码写了一遍,果然很厉害啊。在此先赞一个。(以下蓝色部分来自论坛楼主帖子)
8皇后问题是一个广为人知的问题:将8个皇后放在8×8的棋盘上,皇后之间不能互相攻击,求各种放法。更一般的,把8换成n,其解法个数是随n成几何级增长的,因此程序运行时间也是几何级别的。现在我们关注这样一个问题,既然不能很快的把所有解都枚举出来,那么我们能不能很快的求出一个解来呢?这就是n皇后问题。
有人说,我就用纯搜索来搜第一个解,会不会快呢?你可以试一试,当n增大的时候会变的非常非常慢。除了搜索,还能有什么更好的办法呢?下面介绍一个QS2算法,可以在当n大到500000的时候仍能在几分钟之内得到解。描述算法前,先定义一些数据结构:
1. 状态表示。用queen[i] (1<=i<=n)存储1..n个一个排列,用它表示第i列的皇后所放的行数。这样表示的作用是,同一行同一列都不会有互相攻击的情况发生,发生攻击只可能是对角线。
2. 对角线标记。对于第i行第j列的元素,它有两个方向的对角线。假设以左下角为坐标(1,1)点,那么一条对角线是斜率为正的,另外一条是斜率为负的。对于斜率为正的对角线上的元素,i-j为定值,对斜率为负的对角线上的元素,i+j为定值,因此用i+j来标记该元素所处的负对角线,用i-j来标记其所处的正对角线。用数组dn[ ]来表示第i+j条负对角线上有多少个皇后,用dp[ ]来表示第i-j条正对角线上的皇后的个数。定义在某条对角线上,碰撞的个数为这条对角线上皇后的个数减1。
3. 被攻击的皇后。用一个数组attack[ ]来存储所有被攻击的皇后的行数。此数组用于加速程序的运行。 有了这些数据结构,就可以开始介绍QS2算法了。
算法如下:
1. repeat
2. 随机产生初始状态queen[i]
3. collisions = compute_collisions(queen, dn, dp) (计算每个对角线上皇后的个数,dp[]和dn[],并计算总的碰撞次数collisions)
4. 设limit = C1 * collisions (该变量用于界定程序中每种状态产生的碰撞次数,C1是一个参数,这里设为0.45)
5. number_of_attacks = compute_attacks(queen, dn, dp, attack) (计算被攻击的皇后的个数)
6. loopcount = 0
7. repeat
8. for k <- 1 to number_of_attacks do
9. i <- attack[k]
10. 随机选择一个1..n之间的数j
11. if 交换queen[i]和queen[j]可以减少总的碰撞次数collisions then
12. 进行这次交换,并重新计算dn[], dp[]和collisions
13. if collisions = 0 then 找到解,结束。
14. if collisions < limit then do
15. limit <- C1*collisions
16. 重新计算number_of_attacks = compute_attacks(queen, dn, dp, attack)
17. end do
18. end do
19. end do
20. loopcount <- loopcount + number_of_attacks
21. until loopcount > C2 * n (C2是一个常量,这里设为32)
22. until collisions = 0
通观这个算法,发现其实很简单,就是先随机产生了一种排列方案,然后找一个被攻击的皇后,随机选择另一个皇后,让她们交换位置,如果这个交换可以使总的碰撞次数减少,那么就进行交换。由于这个算法是随机的,不能保证从最开始随机产生的queen[i]状态一定可以得到一组解,因此,程序在运行一段时间之后,如果没有解产生,就重新产生一组初始值(这个过程是通过loopcount变量来控制的)。再看看这个算法的性能。由于程序里面充满了随机化,对这个程序的性能的分析也无法直接从代码中来分析其复杂度。它的性能是通过实验来分析的。下面这个表列出了一些统计数字:
皇后个数n 1000 10000 100000 500000
被测试的皇后数 14742 138762 1386974 6981193
进行交换的皇后对个数 436 4333 43256 216407
表中第2行被测试的皇后对个数,是指程序第11行对两个皇后交换后是否可以减少碰撞个数的测试。表中第3行进行交换的皇后对个数,是指程序第12行交换两个皇后的次数。
从表中我们不难发现,随着n增大,测试皇后对和交换皇后对这两个操作都是呈线性增加的。也就是说,对由一个初始状态出发到产生解,所用时间是线性的。但是,如果不能从某个随机的初始状态产生出解呢?虽说若不能出解,程序运行一段时间后会重新产生初始状态,但如果不能产生解的初始状态很多,那么程序的性能也会大大下降。事实上这个顾虑是多余的,实验验证,当n超过1000的时候,几乎总可以从第一个初始值出发找到解!
这个算法介绍完了,最后,我想说说我对这个算法的感觉。首先,这个算法是实验性的。其性能的评估没法用传统的复杂度分析方法来进行,必须通过实验来验证。当我看到了这个算法,如果不是亲自去写一遍,我根本无法相信它会这么快的出解,这也是它神奇的地方。其次,这个算法的思路跳出了解决n皇后问题一般所能想到的回溯搜索方法,取而代之的是一个随机化贪心算法。虽然说它是不确定的,可是它却快速的解决了问题。这为人们提供了一个思路,当遇到传统的搜索很难奏效的时候,随机化贪心也许会另辟捷径,收到意想不到的效果。
最后在贴上自己写的code
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
using namespace std;
const double C1 = 0.45;
const double C2 = 32;
void initQueen(int N , vector <int> &queen) // 初始化Queen
{
vector <int> array(N);
for(int i = 0; i < N ; i++)
array[i] = i;
queen.clear();
while(N)
{
double t = rand()%N;
queen.push_back(array[t]);
array[t] = array[--N];
}
}
__int64 compute_collisions(const vector<int> &queen,vector<int> &dn,vector<int> &dp)
{
for(int t =0 ; t < 2*queen.size() ; t++)
{
dn[t] = dp[t] = 0;
}
for(int i = 0 ; i < (int)queen.size() ; i++)
{
int j = queen.at(i);
dn[i+j]++;
dp[queen.size()-1+i-j]++;
}
__int64 collisions = 0;
for(int k =0 ; k < 2*queen.size()-1;k++)
{
collisions +=dn[k]*(dn[k]-1)/2;
collisions +=dp[k]*(dp[k]-1)/2;
}
return collisions;
}
int compute_attacks(const vector<int> &queen,vector<int> &dn,vector<int> &dp,vector<int>&attack)
{
attack.clear();
int attackedLines = 0;
for(int i =0 ; i<(int)queen.size();i++)
{
int j = queen.at(i);
if(dn.at(i+j) > 1 || dp.at(queen.size()-1+i-j) > 1)
{
attack.push_back(i);
attackedLines++;
}
}
return attackedLines;
}
int randInt(int k ,int size)
{
int val =rand()%size;
while(val == k)
val = rand()%size;
return val;
}
int cacl_collisions(const vector<int> &queen,vector<int> &dn,vector<int> &dp,int a,int b)
{
int i,j,counts = 0 ;
i = queen[a];
j = queen[b];
counts -= dn[a+i] - 1;
counts -= dn[b+j] - 1;
if(a+i == b+j) counts++;
counts -= dp[queen.size()-1+a-i] - 1;
counts -= dp[queen.size()-1+b-j] - 1;
if(a-i == b-j) counts++;
counts += dn[a+j] ;
counts += dn[b+i] ;
if(a+j == b+i) counts++;
counts += dp[queen.size()-1+a-j] ;
counts += dp[queen.size()-1+b-i] ;
if(a-j == b-i) counts++;
return counts;
}
void updateQueen(vector<int> &queen,vector<int> &dn,vector<int> &dp,int a,int b)
{
int i = queen.at(a);
int j = queen.at(b);
dn[a+i]--;
dn[b+j]--;
dp[queen.size()-1+a-i]--;
dp[queen.size()-1+b-j]--;
int t = queen[a];
queen[a] = queen[b];
queen[b] = t;
dn[a+j]++;
dn[b+i]++;
dp[queen.size()-1+a-j]++;
dp[queen.size()-1+b-i]++;
}
void printQueen(vector<int>&queen)
{
for(int i = 0 ; i < (int)queen.size(); i++)
{
for(int j = 0;j < (int)queen.size();j++)
{
if(j == queen.at(i))
cout<<"0";
else cout<<"*";
}
cout<<endl;
}
}
void pashan(int N)
{
__int64 collisions = N;
int num_of_attack;
int swapCount = 0;
vector<int> queen;
vector<int> attack;
vector<int> dn(2*N);
vector<int> dp(2*N);
if(N == 2||N == 3)
{
cout<<"无解"<<endl;
return ;
}
while(collisions)
{
initQueen(N,queen);
collisions = compute_collisions(queen, dn, dp);
num_of_attack = compute_attacks(queen, dn, dp, attack);
int limit = C1*collisions;
int loopSteps = 0;
while(loopSteps < C2*N)
{
for(int k = 0 ; k < num_of_attack ; k++)
{
int i = attack.at(k);
int j = randInt(i,N);
int c;
if(( c = cacl_collisions(queen,dn,dp,i,j)) < 0)
{
collisions += c;
updateQueen(queen,dn,dp,i,j);
swapCount++;
if(collisions == 0)break;
if(collisions < limit)
{
limit = C1*collisions;
// k = 0;
num_of_attack = compute_attacks(queen, dn, dp, attack);
}
}
}
if(collisions == 0)break;
loopSteps +=num_of_attack;
}
}
cout<<"交换次数: "<<swapCount<<endl;
// printQueen(queen);
}
int main()
{
int N=100000;
clock_t startTime,endTime;
cout<<"请输入皇后的个数:";
cin>>N;
srand((unsigned)time(NULL));
startTime = clock();
pashan(N);
endTime = clock();
double totalTime = 1.0*(endTime - startTime)/CLOCKS_PER_SEC;
cout<<"共耗时:"<<totalTime<<"s"<<endl;
return 0;
}