皇后控制问题算法

‘壹’ n皇后问题 c++

回溯法程序：
#include<iostream.h>
#include<string.h>
#include<time.h>
#define size 100
int board[size];
int ver[size];
int ru[size*2];//右上
int rd[size*2];//右下
int n,find; int rec[size];
//回溯搜索
void dfs(int t)
{
int i;
if(find) return;
if(t==n)
{
find=1;
for(i=0;i<n;i++)
{
rec[i]=board[i];
}
return;
}
for(i=0;i<n;i++)
{
if(ver[i]==1) continue;
if(ru[i-t+n]==1) continue;
if(rd[i+t]==1) continue;
ver[i]=1;
ru[i-t+n]=1;
rd[i+t]=1;
board[t]=i;
dfs(t+1);
rd[i+t]=0;
ru[i-t+n]=0;
ver[i]=0;
}
return;
}
int main()
{
int i,j,t1,t2;
cout<<"输入棋盘大小：";
cin>>n;
t1=clock();
find=0; memset(ver,0,sizeof(ver));
memset(ru,0,sizeof(ru)); memset(rd,0,sizeof(rd));
dfs(0);
t2=clock();
if(find)
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(rec[i]==j) cout<<'X';
else cout<<'+';
}
cout<<endl;
}
else
cout<<"Can't find!n";
cout<<"耗费时间："<<t2-t1<<"msn";
return 0;
}

既然是回溯法，楼主可以看看回溯法
---------2 回溯法：如果在第i行无论如何放置皇后，都和前面i-1行的皇后互相攻击的话，说明i-1行的皇后位置不合理，于是就回退一行，重新计算。这类似于走迷宫，如果在某个路口实在不下去了，只好退后一步重新选择。在退后一步重新选择的时候，显然可以排除已经尝过的路线。

下面重点分析回溯法解决N皇后问题。

很容易想到，在同一行上只能放置一个皇后，因此nxn的棋盘上放n个皇后的方案必然是每一行上放一个皇后。这样的话，我们可以使用一个一维数组q[n]来保存最后的方案，其中q[i]的含义是第i行上皇后的位置。比如q[3]=5，则表示第三行上的皇后在第5格。

上面无论哪种方法，都要解决一个问题：如何量化的判断两个皇后是否相互攻击？有了数组q的定义，我们很容易发现如下的规律：

对于两个皇后q[i]和q[j]，互相不攻击的条件是：
1 i != j，即不在同一行。
2 q[i] != q[j]，即不再同一列。
3 |q[i] - q[j]| != |i - j|，即不在一个对角线上。

根据前面的分析，我们假设前面的i-1行的皇后已经布好，即互不攻击，则在第i行上的皇后位置为q[i]，那么我们可以把q[i]依次和前面的i-1行比较，如果q[i]和前面的i-1行互不攻击的话，则说明第i行的皇后q[i]就是一个合理的位置，则继续寻找i+1行的皇后合理位置。如果第i行的皇后和前面的i-1行的某个皇后有攻击，则第i行的皇后需要右移一格，重新和前面的i-1行进行比较。

在进行具体处理时，要注意边界条件，即回退到棋盘第一行以及皇后已经右移到棋盘的最后一行的最后一格的情况，都意味着当前皇后位置使得N皇后问题无解。

下面是算法：

PROCEDURE QUEEN(n)
FOR i = 1 TO n DO q[i] = 1
i = 1
loop:
IF(q[i] <= n) THEN
{
k = 1
WHILE((k < i) and ((q[k] - q[i])) * (|q[k] - q[i]| - |k - i| ) != 0)
DO k = k + 1

IF(k < i) THEN q[i] = q[i] + 1
ELSE
{
i = i + 1
IF(i > n) THEN
{
OUTPUT q[i] (i = 1,2,...,n)
q[n] = q[n] + 1
i = n
}
}
}
ELSE
{
q[i] = 1
i = i - 1
IF(i < 1) THEN RETURN
q[i] = q[i] + 1
}

TOGO loop
RETURN

‘贰’ 数据结构课程设计：八皇后问题求出在一个n×n的棋盘上，放置n个不能互相捕捉的国际象棋“皇后”的所有布局

#include <iostream>
using namespace std;
#define MAX 8 //数组维数
static int total=0; //算法总数
int array[MAX][MAX]; //定义数组
void SetArray() //数组置零
{
int i,j;
for(i=0;i<MAX;i++)
for(j=0;j<MAX;j++)
array[i][j]=0;
}
bool IsTrue(int a,int b) //合法性判断
{
int i,j,len;
for (i=0;i<MAX;i++)
if(array[a][i]==1||array[i][b]==1)
return false;
len=(a<b?a:b);
for(i=a-len,j=b-len;i<MAX&&j<MAX;i++,j++)
if(array[i][j]==1)
return false;
for(i=a,j=b;i<MAX&&j>=0;i++,j--)
if(array[i][j]==1)
return false;
for(i=a,j=b;i>=0&&j<MAX;i--,j++)
if(array[i][j]==1)
return false;
return true;
}
void show() //显示结果
{
int i,j;
cout<<"第"<<++total<<"种结果为："<<endl;
for (i=0;i<MAX;i++)
{
for(j=0;j<MAX;j++)
cout<<array[i][j]<<" ";
cout<<endl;
}

}
bool Queen(int i) //皇后算法
{
int j;
for(j=0;j<MAX;j++)
{
if(IsTrue(i,j))
{
array[i][j]=1;
if(i==MAX-1)
{
show();
array[i][j]=0;
continue;
}
else if(!Queen(i+1))
{
array[i][j]=0;
continue;
}
}
}
return false;
}
void main()
{
int i;
for(i=0;i<MAX;i++)
{
SetArray();
array[0][i]=1;
Queen(1);
}
}
程序给你了，按你的思路写的，比较简单，刚运行了一下，八皇后问题有92种算法，跟上面说的一样。具体是什么样的，自己去运行，说明，这是用c++写的，有问题可以去www.pptkj.net 上面留言。。或者追问。

‘叁’ C语言五皇后控制棋盘问题

#include <iostream>
#include <cstdlib>
using namespace std ;
int iCount = 0 ;
void pintf(int qp[8][8] )
{
for ( int i = 0 ; i < 8 ; i ++)
{
for ( int j = 0 ; j < 8 ; j++)
{ if ( qp[i][j] > 6 )
cout<< " 皇 " ;
else
cout<< " ＊ " ;
// cout<< " " << qp[i][j] ;
}
cout << endl ;
}
cout << endl ;
cout << endl ;
}
void fz( int qp[8][8] , int wz[5][2] , int iIndex , int ii , int jj)
{
if ( iIndex == 5 )
{ for ( int i = 0 ; i < 8 ; i ++)
{
for ( int j = 0 ; j < 8 ; j++)
{
if ( qp[i][j] == 0 )
return ;
}
} iCount ++ ;
cout<< "方式 " << iCount << endl ;
pintf(qp); return ;
} for ( int i = ii ; i < 8 ; i++)
{
for ( int j = jj ; j < 8 ; j++)
{
if ( qp[i][j] == 0 )
{
for ( int m = 0 ; m < 8 ; m++) //设置
{
for ( int n = 0 ; n < 8 ; n++)
{
if ( m == i || n == j ) //同行或同列
qp[m][n] += 1 ;
else if ( m-n == i-j || n+m == i+j ) //对角线
{
qp[m][n] += 1 ;
}
}
} qp[i][j] += 6 ;
wz[iIndex ][ 0 ] = i;
wz[iIndex ][ 1 ] = j;
//cout<< i << " " << j << " " << iIndex << endl ;
fz( qp , wz, iIndex+1 , i , 0 ) ;
//还原
qp[i][j] -= 6 ;
for ( int m = 0 ; m < 8 ; m++) //设置
{
for ( int n = 0 ; n < 8 ; n++)
{
if ( m == i || n == j ) //同行或同列
{
qp[m][n] -= 1 ;
}
else if ( m-n == i-j || n+m == i+j ) //对角线
{
qp[m][n] -= 1 ;
}
}
}
}
}
}
}main()
{
int qp[8][8] , wz[5][2] ;
//init
for ( int i = 0 ; i < 8 ; i++)
{
for ( int j = 0 ; j < 8 ; j++)
{
qp[i][j] = 0 ;
}
}
iCount = 0 ;
fz( qp , wz , 0 , 0 , 0 ) ;
cout<< "共计方式 " << iCount << endl ;}

‘肆’ 八皇后究竟有多少种解法怎么解

这样算是最佳解 class Queen8{ static final int QueenMax = 8; static int oktimes = 0; static int chess[] = new int[QueenMax]; public static void main(String args[]){ for (int i=0;i<QueenMax;i++)chess[i]=-1; placequeen(0); System.out.println("\n\n\n八皇后共有"+oktimes+"个解法 made by yifi 2003"); } public static void placequeen(int num) { int i=0; boolean qsave[] = new boolean[QueenMax]; for(;i<QueenMax;i++) qsave[i]=true; i=0; while (i<num){ qsave[chess[i]]=false; int k=num-i; if ( (chess[i]+k >= 0) && (chess[i]+k < QueenMax) ) qsave[chess[i]+k]=false; if ( (chess[i]-k >= 0) && (chess[i]-k < QueenMax) ) qsave[chess[i]-k]=false; i++; } for(i=0;i<QueenMax;i++){ if (qsave[i]==false)continue; if (num<QueenMax-1){ chess[num]=i; placequeen(num+1); } else{ //num is last one chess[num]=i; oktimes++; System.out.println("这是第"+oktimes+"个解法 如下:"); System.out.println("第n行: 1 2 3 4 5 6 7 8"); for (i=0;i<QueenMax;i++){ String row="第"+(i+1)+"行: "; if (chess[i]==0); else for(int j=0;j<chess[i];j++) row+="--"; row+="++"; int j = chess[i]; while(j<QueenMax-1){row+="--";j++;} System.out.println(row); } } } } } 多少种解法就不好说了..

‘伍’ 皇后冲突问题

#include <stdio.h>
#include<string.h>
const int MAX=10;
char s[MAX][MAX];
bool r[MAX],c[MAX],left[MAX*2],right[MAX*2];
int main()
{
int n=8,m=8,i,j;
while(scanf("%s",s[0])!=EOF)
{
for(i=1;i<n;i++)
{
scanf("%s",s[i]);
}
memset(r,false,sizeof(r));
memset(c,false,sizeof(c));
memset(left,false,sizeof(left));
memset(right,false,sizeof(right));
bool flag=true;
for(i=0;i<n&&flag;i++)
{
for(j=0;j<n&&flag;j++)
{
if(s[i][j]=='Q')
{
if(r[i])flag=false;
if(c[j])flag=false;
if(left[i+j])flag=false;
if(right[i-j+MAX])flag=false;
r[i]=true;
c[j]=true;
left[i+j]=true;
right[i-j+MAX]=true;
}
}
}
if(flag)puts("NO");
else puts("YES");
}
return 0;
}

/*
Q**Q**** *Q****** ****Q*** **Q***** Q******* ******** ******** ********
*/

‘陆’ 国际象棋5皇后问题

如图所示：

所以最后应该是有两种.有问题请指教

‘柒’ 谁有八皇后问题的编程过程

这就是着名的八皇后问题。八个皇后在排列时不能同在一行、一列或一条斜
线上。在8!=40320种排列中共有92种解决方案。

“八皇后”动态图形的实现

八皇后问题是一个古老而着名的问题，是回溯算法的典型例题。该问题是十九世纪着名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。
对于八皇后问题的实现，如果结合动态的图形演示，则可以使算法的描述更形象、更生动，使教学能产生良好的效果。下面是笔者用Turbo C实现的八皇后问题的图形程序，能够演示全部的92组解。八皇后问题动态图形的实现，主要应解决以下两个问题。

1．回溯算法的实现
（1）为解决这个问题，我们把棋盘的横坐标定为i，纵坐标定为j,i和j的取值范围是从1到8。当某个皇后占了位置(i,j)时，在这个位置的垂直方向、水平方向和斜线方向都不能再放其它皇后了。用语句实现，可定义如下三个整型数组：a[8],b[15],c[24]。其中：

a[j-1]=1 第j列上无皇后
a[j-1]=0 第j列上有皇后
b[i+j-2]=1 (i,j)的对角线（左上至右下）无皇后
b[i+j-2]=0 (i,j)的对角线（左上至右下）有皇后
c[i-j+7]=1 (i,j)的对角线（右上至左下）无皇后
c[i-j+7]=0 (i,j)的对角线（右上至左下）有皇后

（2）为第i个皇后选择位置的算法如下：

for(j=1;j<=8;j++) /*第i个皇后在第j行*/
if ((i,j)位置为空)） /*即相应的三个数组的对应元素值为1*/
{占用位置（i,j） /*置相应的三个数组对应的元素值为0*/
if i<8
为i+1个皇后选择合适的位置；
else 输出一个解
}

2．图形存取
在Turbo C语言中，图形的存取可用如下标准函数实现：

size=imagesize(x1,y1,x2,y2) ;返回存储区域所需字节数。
arrow=malloc(size);建立指定大小的动态区域位图，并设定一指针arrow。
getimage(x1,y1,x2,y2,arrow);将指定区域位图存于一缓冲区。
putimage(x,y,arrow,)将位图置于屏幕上以（x，y）左上角的区域。

3． 程序清单如下

＃i nclude <graphics.h>
＃i nclude <stdlib.h>
＃i nclude <stdio.h>
＃i nclude <dos.h>
char n[3]={0,0};/*用于记录第几组解*/
int a[8],b[15],c[24],i;
int h[8]={127,177,227,277,327,377,427,477};/*每个皇后的行坐标*/
int l[8]={252,217,182,147,112,77,42,7};/*每个皇后的列坐标*/
void *arrow;
void try(int i)
{int j;
for (j=1;j<=8;j++)
if (a[j-1]+b[i+j-2]+c[i-j+7]==3) /*如果第i列第j行为空*/
{a[j-1]=0;b[i+j-2]=0;c[i-j+7]=0;/*占用第i列第j行*/
putimage(h[i-1],l[j-1],arrow,COPY_PUT);/*显示皇后图形*/
delay(500);/*延时*/
if(i<8) try(i+1);
else /*输出一组解*/
{n[1]++;if (n[1]>9) {n[0]++;n[1]=0;}
bar(260,300,390,340);/*显示第n组解*/
outtextxy(275,300,n);
delay(3000);
}
a[j-1]=1;b[i+j-2]=1;c[i-j+7]=1;
putimage(h[i-1],l[j-1],arrow,XOR_PUT);/*消去皇后，继续寻找下一组解*/
delay(500);
}
}
int main(void)
{int gdrive=DETECT,gmode,errorcode;
unsigned int size;
initgraph(&gdrive,&gmode,"");
errorcode=graphresult();
if (errorcode!=grOk)
{printf("Graphics error\n");exit(1);}
rectangle(50,5,100,40);
rectangle(60,25,90,33);
/*画皇冠*/
line(60,28,90,28);line(60,25,55,15);
line(55,15,68,25);line(68,25,68,10);
line(68,10,75,25);line(75,25,82,10);
line(82,10,82,25);line(82,25,95,15);
line(95,15,90,25);
size=imagesize(52,7,98,38); arrow=malloc(size);
getimage(52,7,98,38,arrow);/*把皇冠保存到缓冲区*/
clearviewport();
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 4);
setusercharsize(3, 1, 1, 1);
setfillstyle(1,4);
for (i=0;i<=7;i++) a[i]=1;
for (i=0;i<=14;i++) b[i]=1;
for (i=0;i<=23;i++) c[i]=1;
for (i=0;i<=8;i++) line(125,i*35+5,525,i*35+5);/*画棋盘*/
for (i=0;i<=8;i++) line(125+i*50,5,125+i*50,285);
try(1);/*调用递归函数*/
delay(3000);
closegraph();
free(arrow);
}

八皇后问题的串行算法

1 八皇后问题

所谓八皇后问题,是在8*8格的棋盘上,放置8个皇后。要求每行每列放一个皇后,而且每一条对角线和每一条反对角线上不能有多于1个皇后,也即对同时放置在棋盘的两个皇后(row1,column1)和(row2,column2),不允许(column1-column2)=(row1-row2)或者(column1+row1)=(column2+row2)的情况出现。

2 八皇后问题的串行递归算法

八皇后问题最简单的串行解法为如下的递归算法:

(2.1)深度递归函数:

go(int step,int column)

{int i,j,place;

row[step]=column;

if (step==8)

outputresult( ); /*结束递归打印结果*/

else /*继续递归*/

{for(place=1;place<=8;place++)

{for(j=1;j<=step;j++)

if(collision(j ,row[j],step+1,place))

/*判断是否有列冲突、对角线或反对角线*/

goto skip_this_place;

go(step+1,place);

skip_this_place:;

}

}

}/* go */

(2.2)主函数:

void main( )

{int place,j;

for(place=1;place<=8;place++)

go(1,place);

}/* main */

八皇后问题的并行算法

该算法是将八皇后所有可能的解放在相应的棋盘上,主进程负责生成初始化的棋盘，并将该棋盘发送到某个空闲的子进程,由该子进程求出该棋盘上满足初始化条件的所有的解。这里，我们假定主进程只初始化棋盘的前两列，即在棋盘的前两列分别放上2个皇后,这样就可以产生8*8=64个棋盘。

1 主进程算法

主进程等待所有的子进程,每当一个子进程空闲的时侯，就向主进程发送一个Ready(就绪)信号。主进程收到子进程的Ready信号后,就向该子进程发送一个棋盘。当主进程生成了所有的棋盘后,等待所有的子进程完成它们的工作。然后向每个子进程发送一个Finished信号,打印出各个子进程找到的解的总和，并退出。子进程接收到Finished信号也退出。

2 子进程算法

每个子进程在收到主进程发送过来的棋盘后,对该棋盘进行检查。若不合法,则放弃该棋盘。子进程回到空闲状态,然后向主进程发送Ready信号,申请新的棋盘;若合法,则调用move_to_right(board,rowi,colj)寻找在该棋盘上剩下的6个皇后可以摆放的所有位置,move_to_right(board,rowi,colj)是个递归过程, 验证是否能在colj列rowi行以后的位置是否能放一个皇后。

1)首先将more_queen设置成FALSE；

以LEAF,TRUE和FLASE区分以下三种情况:

A)LEAF:成功放置但是已到边缘,colj现在已经比列的最大值大1,回退两列,检查是否能将待检查皇后放在哪一行:如果能,把more_queen设成TRUE;

B)TRUE:成功放置皇后,检查这一列是否能有放置皇后的其他方式,如有,把more_queen设成TRUE;

C)FALSE:不能放置,回退一列再试,如果能把more_queen设成TRUE ,如果皇后已在最后一行,必须再检查上一列。

2)如果more_queens=TRUE,仍需再次调用move_to_right(),为新棋盘分配空间,用xfer()将现有棋盘拷贝到nextboard，并进行下列情况的处理：

TRUE:得到一个皇后的位置,增大列数再试；

FALSE:失败,如果more_queen为真, 取回棋盘,保存上次调用的棋盘。将列数减小,取走皇后,增加行数,再调用move_to_right()；

LEAF:得到一种解法,solution增一,将解法写入log_file,由于已到边缘,列数回退1,检查是否放置一个皇后,如果能,新加一个皇后后,调用move_to_right；如果不能,检查more_queen如果more_queen为真,将棋盘恢复到上次调用时保存的棋盘,将待检查的皇后下移,调用move_to_right。

八皇后问题的高效解法-递归版

// Yifi 2003 have fun! : )

//8 Queen 递归算法
//如果有一个Q 为 chess[i]=j;
//则不安全的地方是 k行 j位置,j+k-i位置,j-k+i位置

class Queen8{

static final int QueenMax = 8;
static int oktimes = 0;
static int chess[] = new int[QueenMax];//每一个Queen的放置位置

public static void main(String args[]){
for (int i=0;i<QueenMax;i++)chess[i]=-1;
placequeen(0);
System.out.println("\n\n\n八皇后共有"+oktimes+"个解法 made by yifi 2003");
}

public static void placequeen(int num){ //num 为现在要放置的行数
int i=0;
boolean qsave[] = new boolean[QueenMax];
for(;i<QueenMax;i++) qsave[i]=true;

//下面先把安全位数组完成
i=0;//i 是现在要检查的数组值
while (i<num){
qsave[chess[i]]=false;
int k=num-i;
if ( (chess[i]+k >= 0) && (chess[i]+k < QueenMax) ) qsave[chess[i]+k]=false;
if ( (chess[i]-k >= 0) && (chess[i]-k < QueenMax) ) qsave[chess[i]-k]=false;
i++;
}
//下面历遍安全位
for(i=0;i<QueenMax;i++){
if (qsave[i]==false)continue;
if (num<QueenMax-1){
chess[num]=i;
placequeen(num+1);
}
else{ //num is last one
chess[num]=i;
oktimes++;
System.out.println("这是第"+oktimes+"个解法 如下:");
System.out.println("第n行: 1 2 3 4 5 6 7 8");

for (i=0;i<QueenMax;i++){
String row="第"+(i+1)+"行: ";
if (chess[i]==0);
else
for(int j=0;j<chess[i];j++) row+="--";
row+="++";
int j = chess[i];
while(j<QueenMax-1){row+="--";j++;}
System.out.println(row);
}
}
}
//历遍完成就停止

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
char n[3]={\'0\',\'0\'};/*用于记录第几组解*/
int a[8],b[15],c[24],i;
int h[8]={127,177,227,277,327,377,427,477};/*每个皇后的行坐标*/
int l[8]={252,217,182,147,112,77,42,7};/*每个皇后的列坐标*/
void *arrow;
void try(int i)
{int j;
for (j=1;j<=8;j++)
if (a[j-1]+b[i+j-2]+c[i-j+7]==3) /*如果第i列第j行为空*/
{a[j-1]=0;b[i+j-2]=0;c[i-j+7]=0;/*占用第i列第j行*/
putimage(h[i-1],l[j-1],arrow,COPY_PUT);/*显示皇后图形*/
delay(500);/*延时*/
if(i<8) try(i+1);
else /*输出一组解*/
{n[1]++;if (n[1]>\'9\') {n[0]++;n[1]=\'0\';}
bar(260,300,390,340);/*显示第n组解*/
outtextxy(275,300,n);
delay(3000);
getch();
}
a[j-1]=1;b[i+j-2]=1;c[i-j+7]=1;
putimage(h[i-1],l[j-1],arrow,XOR_PUT);/*消去皇后，继续寻找下一组解*/
delay(500);
}
}
int main(void)
{int gdrive=DETECT,gmode,errorcode;
unsigned int size;
initgraph(&gdrive,&gmode,"c:\\\\tc\\\\bgi");
errorcode=graphresult();
if (errorcode!=grOk)
{printf("Graphics error\\n");exit(1);}
rectangle(50,5,100,40);
rectangle(60,25,90,33);
/*画皇冠*/
line(60,28,90,28);line(60,25,55,15);
line(55,15,68,25);line(68,25,68,10);
line(68,10,75,25);line(75,25,82,10);
line(82,10,82,25);line(82,25,95,15);
line(95,15,90,25);
size=imagesize(52,7,98,38); arrow=malloc(size);
getimage(52,7,98,38,arrow);/*把皇冠保存到缓冲区*/
clearviewport();
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 4);
setusercharsize(3, 1, 1, 1);
setfillstyle(1,4);
for (i=0;i<=7;i++) a[i]=1;
for (i=0;i<=14;i++) b[i]=1;
for (i=0;i<=23;i++) c[i]=1;
for (i=0;i<=8;i++) line(125,i*35+5,525,i*35+5);/*画棋盘*/
for (i=0;i<=8;i++) line(125+i*50,5,125+i*50,285);
try(1);/*调用递归函数*/
delay(3000);

closegraph();
free(arrow);
}

‘捌’ 用递归函数设计八皇后问题的回溯算法C++代码

解析：递归实现n皇后问题。
算法分析：
数组a、b、c分别用来标记冲突，a数组代表列冲突，从a[0]~a[7]代表第0列到第7列。如果某列上已经有皇后，则为1，否则为0。
数组b代表主对角线冲突，为b[i-j+7]，即从b[0]~b[14]。如果某条主对角线上已经有皇后，则为1，否则为0。
数组c代表从对角线冲突，为c[i+j]，即从c[0]~c[14]。如果某条从对角线上已经有皇后，则为1，否则为0。
代码如下：
#include <stdio.h>
static char Queen[8][8];
static int a[8];
static int b[15];
static int c[15];
static int iQueenNum=0; //记录总的棋盘状态数
void qu(int i); //参数i代表行
int main()
{
int iLine,iColumn;
//棋盘初始化，空格为*，放置皇后的地方为@
for(iLine=0;iLine<8;iLine++)
{
a[iLine]=0; //列标记初始化，表示无列冲突
for(iColumn=0;iColumn<8;iColumn++)
Queen[iLine][iColumn]='*';
}
//主、从对角线标记初始化，表示没有冲突
for(iLine=0;iLine<15;iLine++)
b[iLine]=c[iLine]=0;
qu(0);
return 0;
}
void qu(int i)
{
int iColumn;
for(iColumn=0;iColumn<8;iColumn++)
{
if(a[iColumn]==0&&b[i-iColumn+7]==0&&c[i+iColumn]==0)
//如果无冲突
{
Queen[i][iColumn]='@'; //放皇后
a[iColumn]=1; //标记，下一次该列上不能放皇后
b[i-iColumn+7]=1; //标记，下一次该主对角线上不能放皇后
c[i+iColumn]=1; //标记，下一次该从对角线上不能放皇后
if(i<7) qu(i+1); //如果行还没有遍历完，进入下一行
else //否则输出
{
//输出棋盘状态
int iLine,iColumn;
printf("第%d种状态为：\n",++iQueenNum);
for(iLine=0;iLine<8;iLine++)
{
for(iColumn=0;iColumn<8;iColumn++)
printf("%c ",Queen[iLine][iColumn]);
printf("\n");
}
printf("\n\n");
}
//如果前次的皇后放置导致后面的放置无论如何都不能满足要求，则回溯，重置
Queen[i][iColumn]='*';
a[iColumn]=0;
b[i-iColumn+7]=0;
c[i+iColumn]=0;
}
}
}

‘玖’ 高分：网络流问题

一、引言

网络流算法是一种高效实用的算法，相对于其它图论算法来说，它的模型更加复杂，编程复杂度也更高。但是它综合了图论中的其它一些算法（如最短路径、宽度搜索算法），因而适用范围也更广，经常能够很好地解决一些搜索与动态规划无法解决的非np问题。
网络流在具体问题中的应用，最具挑战性的部分是模型的构造，它没用现成的模式可以套用，需要我们对各种网络流的性质了如指掌（比如点有容量、容量有上下限、多重边等等），根据具体的问题发挥我们的创造性。一道问题经常可以建立多种模型，不同的模型对问题的解决效率的影响也是不同的，本文通过实例探讨如何确定适当的模型，提高网络流算法的效率。

二、网络流算法时间效率

当我们确定问题可以使用最大流算法求解后，就根据常用的ford-fulkerson标号法求解；而最小（大）费用最大流问题也可用类似标号法的对偶算法解题。ford-fulkerson标号法的运行时间为o（ve2），对偶法求最小费用流的运行时间大约为o（v3e2）。

显然，影响网络流算法的时间效率的因素主要是网络中顶点的数目与边的数目。这二个因素之间不是相互独立的，而是相互联系，矛盾而统一的。在构造网络模型中，有时，实现了某个因素的优化，另外一个因素也随之得到了优化；有时，实现某个因素的优化却要以增大另一因素为代价。因此，我们在具体问题的解决中，要坚持"全局观"，实现二者的平衡。

三、模型的优化与选择

(一)减少模型的顶点数与边数，优化模型

如果能根据问题的一些特殊性质，减少网络模型中的顶点的数目和边的数目，则可以大大提高算法的效率。

例1：最少皇后控制

在国际象棋中，皇后能向八个方向攻击（如图1(a)所示，图中黑点格子为皇后的位置，标有k的格子为皇后可攻击到的格子）。现在给定一个m*n（n、m均不大于于50）的棋盘，棋盘上某些格子有障碍。每个皇后被放置在无障碍的格子中，它就控制了这个格子，除此，它可以从它能攻击到的最多8个格子中选一个格子来控制，如图1(b)所示，标号为1的格子被一个皇后所控制。

请你编一程序，计算出至少有多少个皇后才能完全控制整个棋盘。

图1(a) 图1(b)

输入格式：
输入文件的第一行有两个整数m和n，表示棋盘的行数与列数。接下来m行n列为一个字符矩阵，用''.''号表示空白的格子，''x''表示有障碍的格子。

输出格式：
输出文件的第一行仅有一个数s，表示需要皇后的数目。
sample input
3 4
x...
x.x.
.x..
sample ouput
5

问题分析]

如果本问题用简单的搜索来做，由于题目给的棋盘很大，搜索算法很难在短时间内出解。由于一个皇后在棋盘最多只能控制两个格子，因此最少需要的皇后数目的下界为[n*m/2]。要使得皇后数目最少，必定是尽量多的皇后控制两个格子。如果我们在每两个能相互攻击到的格子之间加上一条有向弧，则问题很类似于二分图的最大匹配问题。

[模型一]

1． 将每个非障碍的格子按行优先编号(0~m*n-1)。
2． 将上述的每个格子i折成两个格子i''和i''''，作为网络模型中的顶点。
3． 若格子i可以攻击到格子j且i<j，则在模型中顶点i''到j''''之间加上一条有向弧，容量为1。
4． 增加一个源点s，从s点向所有顶点i''添上一条弧；增加一个汇点t，从所有顶点j''''到t添上一条弧，容量均为1。

图1(b)所示的棋盘，对应的模型为：

图2

显然，任一解对应于以上模型的一个最大匹配。且最大匹配中，匹配数必定是偶数。因此至少需要的马匹数为m＊n－障碍数－最大匹配数/2。

[模型二]

如果我们将棋盘涂成黑白相间的格子，则某皇后控制的两个格子一定是一个是黑格，另一个是白格（如图3），不妨设这两个格子中皇后在白格子上。于是，我们将n*m个格子分成两部分白格与黑格。因此我们可以将模型一优化为：

图3

1．将棋盘中的所有格子分成两个部分，对所有的格子进行编号，每个白格与它能攻击到的黑格之间（障碍除外）添上一条从白格到黑格的弧，构成一个二分图。

2．增加一个源点s，从s点向所有非障碍的白格添上一条弧；增加一个汇点t，从所有非障碍的黑格到t添上一条弧。

3．设置所有的弧的流量为1。
图1(b)所示的棋盘，对应的模型为：

图4

[两种模型的比较]

显然，模型二的顶点数与边数大致是模型一的一半。下面是在bp环境下两种模型的时间效率比较(p166/32m)：

模型一 模型二

可扩展性 不易打印出一种解 容易打印出一种解

模型二正是根据问题的特殊性（即马的走法），将网格中的格点分成白与黑两类，且规定马只能从白格跳到黑格，从而避免将每个格点折分成两个点，减少模型的顶点数，同时也大大减少了边的数目。达到了很好的优化效果。

(二)综合各种模型的优点，智能选择模型

有时，同一问题的各种模型各有特色，各有利弊。这种情况下，我们就要综合考虑各种模型的优缺点，根据测试数据智能地选择问题的模型。

例2火星探测器（ioi97）

有一个登陆舱（pod），里边装有许多障碍物探测车（mev），将在火星表面着陆。着陆后，探测车离开登陆舱向相距不远的先期到达的传送器（transmitter）移动，mev一边移动，一边采集岩石（rock）标品，岩石由第一个访问到它的mev所采集，每块岩石只能被采集一次。但是这之后，其他mev可以从该处通过。探测车mev不能通过有障碍的地面。
本题限定探测车mev只能沿着格子向南或向东从登陆处向传送器transmitter移动，允许多个探测车mev在同一时间占据同一位置。

任务：计算出所有探测车的移动途径，使其送到传送器的岩石标本的数量最多，且使得所有的探测车都必须到达传送器。

输入：

火星表面上的登陆舱pod和传送器之间的位置用网络p和q表示，登陆舱pod的位置为（1，1）点，传送器的位置在（p，q）点。

火星上的不同表面用三种不同的数字符号来表示：

0代表平坦无障碍
1代表障碍
2代表石块。
输入文件的组成如下：
numberofvehicles
p
q
(x1y1)(x2y1)(x3,y1)…(xp-1y1)(xpy1)
(x1y2)(x2y2)(x3,y2)…(xp-1y1)(xpy2)
(x1y3)(x2y3)(x3,y3)…(xp-1y3)(xpy3)
…
(x1yq-1)(x2yq-1)(x3,yq-1)…(xp-1yq-1)(xpyq-1)
(x1yq)(x2yq)(x3,yq)…(xp-1yq)(xpyq)
p和q是网络的大小；numberofvehicles是小于1000的整数，表示由登陆舱pod所开出的探测车的个数。共有q行数据，每行表示火星表面的一组数据，p和q都不超过128。

[模型一]

很自然我们以登陆舱的位置为源点，传送器的位置为汇点。同时某块岩石由第一个访问到它的mev所采集，每块岩石只能被采集一次。但是这之后，其他mev可以从该处通过，且允许多个探测车mev在同一时间占据同一位置。因此我们将地图中的每个点分成两个点，即（x,y）à(x,y,0)和(x,y,1)。具体的描述一个火星地图的网络模型构造如下：

1． 将网格中的每个非障碍点分成(x,y)两个点(x,y,0)和(x,y,1)，其中源点s = v(1, 1, 0),汇点t = v(maxx, maxy, 1)。

2． 在以上顶点中添加以下三种类型的边e1,e2,e3，相应地容量和费用分别记为c1、c2、c3以及w1、w2、w3:

u e1 = v(x, y, 0) -> v(x, y, 1),c1 = maxint,w1 = 0。
u e2 = v(x, y, 0) -> v(x, y, 1)，c2 = 1，w2 = -1（这里要求(x, y)必须是矿石）
u e3 = v(x, y, 1) -> v(x'', y'', 0)，c3 = maxint,w3 = 0.

其中x''=x+1 y''=y 或x''=x y''=y+1,1 <= x'' <= maxx，1 <= y'' <= maxy，且(x'' y'')非障碍。

从以上模型中可以看出，在构造的过程中，将地图上的一个点"拆"成了网络的两个节点。添加e1型边使得每个点可以被多次访问，而添加e2型边使得某点上的矿石对于这个网络，从s到t的一条路径可以看作是一辆探测车的行动路线。路径费用就是探测车搜集到的矿石的数目。对于网络g求流量为numberofvehicles的固定最小费用流，可以得到问题的解。

[模型二]

事实上，如果我们只考虑这numberofvehicles辆车中每辆车分别依次装上哪些矿石。则每辆车经过的矿石就是一条流，因此我们以网格中的矿石为网络的顶点建立以下的网络流模型。

1. 将网格中的每个起点(网格左上角)能到达，且能从它能到达终点(右下角)的矿石 (x,y)点分成左点(x,y,0)和右点(x,y,1)两个点，并添加源点s和汇点t。
2. 在以上顶点中添加以下五种类型的边e1,e2,e3，相应地容量和费用分别记为c1、c2、c3以及w1、w2、w3:

u e1 = v(x, y, 0) -> v(x, y, 1),c1 = 1,w1 = -1。
u e2 = v(x, y, 1) -> v(x'', y'', 0)，c2 = 1，w2 = 0（矿石点(x, y)可到达矿石点(x'',y'')）。
u e3 = s -> v(x, y, 0)，c3 = 1,w3 = 0。
u e4 = v(x, y, 1)->t，c4 = 1,w4 = 0。
u e5=s->t,c5=maxint,w5=0。

由于每个石块被折成两个点，且容量为1，就保证了每个石块只被取走一次，同时取走一块石块就得到-1的费用。因此对以上模型，我们求流量为numberofvehicles的最小费用流，就可得到解。

[两种模型的比较]

1.模型一以网格为顶点，模型二以矿石为顶点，因此在顶点个数上模型二明显优于模型一，对于一些矿石比较稀疏，而网格又比较大的数据，模型二的效率要比模型一来得高。且只要矿石的个数不超过一定数目，模型二可以处理p，q很大的数据，而模型一却不行。

2．模型一中边的数目最多为3*p*q，而模型二中边的数目最坏情况下大约为p*q*(p+1)*(q+1)/4-p*q。因此在这个问题中，若对于一些矿石比较密集且网格又比较大的数据，模型二的边数将大大超过模型一，从而使得时间效率大大低于模型一。

下面是网格中都是矿石的情况比较（piii700/128m ，bp7.0保护模式）：
numberofvehicles＝10 模型一 模型二

通过以上数据，可知对于p，q不超过60的情况，模型一都能在10秒内出解。而模型二则对于p、q＝30的最坏情况下速度就很慢了，且p、q超过30后就出现内存溢出情况，而无法解决。

因此，对于本题，以上两种模型各有利弊，我们可根据测试数据中矿石稀疏程度来决定建立什么样的模型。若矿石比较稀疏，则可以考虑用建立如模型二的网络模型；若矿石比较密集则建立模型一所示网络模型。然后，再应用求最小费用最大流算法求解。对于p，q＞60，且矿石比较多情况下，两种模型的网络流算法都无法求解。在实际的应用中问题经常都只要求近似解，此时还可用综合一些其它算法来求解。

四、结束语

综上所述，网络流算法中模型的优化是网络流算法提高效率的根本。我们要根据实际问题，从减少顶点及边的角度综合考虑如何对模型进行优化，选择适当的模型，以提高算法的效率。对于有些题目，解题的各种模型各有优劣时，还可通过程序自动分析测试数据，以决定何种情况下采用何种模型，充分发挥各种模型的优点，以达到优化程序效率的目的。

‘拾’ C语言中8皇后问题--怎么解决上下两种方法是否重复

#include "stdio.h"
#include "windows.h"
#define N 8 /* 定义棋盘大小 */
int place(int k); /* 确定某一位置皇后放置与否，放置则返回1，反之返回0 */
void backtrack(int i);/* 主递归函数，搜索解空间中第i层子树 */
void chessboard(); /* 每找到一个解,打印当前棋盘状态 */
static int sum, /* 当前已找到解的个数 */
x[N]; /* 记录皇后的位置,x[i]表示皇后i放在棋盘的第i行的第x[i]列 */
int main(void)
{
backtrack(0);
system("pause");
return 0;
}
int place(int k)
{
/* 测试皇后k在第k行第x[k]列时是否与前面已放置好的皇后相攻击。 x[j] == */
/* x[k] 时，两皇后在同一列上；abs(k - j) == abs(x[j] - x[k]) 时，两皇 */
/* 后在同一斜线上。两种情况两皇后都可相互攻击，故返回0表示不符合条件。*/
for (int j = 0; j < k; j ++)
if (abs(k - j) == abs(x[j] - x[k]) || (x[j] == x[k])) return 0;
return 1;
}
void backtrack(int t)
{
/* t == N 时，算法搜索至叶结点，得到一个新的N皇后互不攻击的放置方案 */
if (t == N) chessboard();
else
for (int i = 0; i < N; i ++) {
x[t] = i;
if (place(t)) backtrack(t + 1);
}
}
void chessboard()
{
printf("第%d种解法:\n", ++ sum);
for (int i = 0; i < N; i ++) {
for (int j = 0; j < N; j ++)
if (j == x[i]) printf("@ ");
else printf("* ");
printf("\n");
}
printf("\n");
}