求公式的递归函数

printf("n");

//应该可以一个搞定

八皇后问题python 八皇后问题python回溯法八皇后问题python 八皇后问题python回溯法


八皇后问题python 八皇后问题python回溯法


(1,4) (2,7) (3,5) (4,2) (5,6) (6,1) (7,3) (8,8)

/

printf("请输入x，n的值n");

f(x,n)=x-x^2+x^3-x^4+···+(-1)^(n-1)x^n

f(x,n-1)=x-x^2+x^3-x^4+···+(-1)^(n-2)x^(n-1)

(-x)f(x,n-1)=-x^2+x^3-x^4+……(-1)^(n-1)x^n=f(x,n)-x

f(x,n)=x-xf(x,n-1)

f(x,1)=x

/

#include "stdafx.h"

#include

#include

#include

long int fun(int,int);

int main(int argc, char argv[])

{int a,b;

while(1)

{("cls");

scanf("%d %d",&a,&b);

if(a<=0||b<=0)

{exit(0);

}else

{printf("%dn",fun(a,b));

Sleep(1500);

}long int fun(int x,int n)

{static long int r=x;

if(n==1)

{r=x;

}else

{r=x-(xfun(x,n-1));

}return r;

f(x,n) {

if (n==-1) return 0;

else return (-1)^(n-1)x^n + f(x,n-1);

我想知道八皇后问题的空间和时间复杂度，以及计算过程，谢谢

cout<<"8皇后可能的结果:"<直接给你pascal的源程序。

program eightqueens;

x:array[1..8] of intgeer;

a,b,c:array[-7..16] of boolean;

i,count:integer;

q:boolean;

procedure print;

i:integer;

beg(1,6) (2,3) (3,1) (4,8) (5,4) (6,2) (7,7) (8,5)in

for i:=1 to 8 fo

write(x[i]:2);

ifor(j=0;j<8;j++)nc(coint);

wrin('count=',count);

end;

j:integer;

begin

for j:=1 to 8 do

begin

if a[j] and c[i-j] and b[i+j] then

begin

x[i]:=j;

a[j]:=false;

c[i-j]:=false;

b[i+j]:=false;

if i<8 then try (i+1)

else print;

a[j]:=true;

b[i+j]:=true;

end; end;end;

begin

for i:=1 to 8 do

a[i]:=true;

for i:=-7 to 7 do

c[i]:=true;

for i:=2 to 16 do

b[i]:=true;

count:=0;

try(1);

end.

时空复杂度没超过noip竞赛的要求。

求八皇后问题C++程序设计

for(k=0;k这样算是解

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=for (int j = 0; j < k; j ++)0;i

placequeen(0);

System.out.println("nnn八皇后共有"+oktimes+"个解法 made by yifi 2003");

}public static void placequeen(int num)

{int i=0;

boolean qse[] = new boolean[QueenMax];

for(;i

i=0;

while (i

qse[chess[i]]=false;

int k=num-i;

if ( (chess[i]+k >= 0) && (chess[i]+k < QueenMax) ) qse[chess[i]+k]=false;

if ( (chess[i]-k >= 0) && (chess[i]-k < QueenMax) ) qse[chess[i]-k]=false;

i++;

}for(i=0;i

if (qse[i]==false)continue;

if (num

// 0,0,0,0,0,0,0,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

String row="第"+(i+1)+"行: ";

if (chess[i]==0);

else

for(int j=0;j

row+="++";

int j = chess[i];

while(j

System.out.println(row);

没想法了

课本上应该有吧

找本C++的书看看行了

求~~~pascal八皇后 非递归详细算法和程序

if ..... then

Program queen;

(1,6) (2,1) (3,5) (4,2) (5,8) (6,3) (7,7) (8,4)

a,b,c,d,e,f,g,h:1..8;

// 0,0,0,0,0,0,0

begin

for a:= 1 to 8 do

for b := 1 to 8 do

if a<>b then

for c:= 1 to 8 do

if (a<>c) and (b<>c) then

for d:= 1 to 8 do

for ... := 1 to 8 do

if .... then

......

for h := 1 to 8 do

if (a<>h) and (b<>h)..... then

begin

write(...)

end;

条件懒得写了

1楼貌似递归....

建议：多用几个for吧

八皇后问题的数据结构课程设计

(1,6) (2,4) (3,7) (4,1) (5,8) (6,2) (7,5) (8,3)

int m=0,n; //m为摆法计数,n为皇后个数

int a;

int fit(int i, int j) //检查(i,j)上能否放棋子

{int j1=j,{for(k=0;k

while( (j1>1)&&ok1)

{j1--;

ok1=a[j1]!=i ;

}j1=j; i1=i; //检查对角线上能否放棋子

while( (j1>1)&&(i1>1)&&ok1)

{j1--;

i1--;

ok1=a[j1]!=i1 ;

}j1=j; i1=i; //检查另一对角线上能否放棋子

while( (j1>1)&&(i1

{j1--;

i1++;

ok1=a[j1]!=i1 ;

}return ok1;

}void queen(int j) //从第j列开始逐个试探

{if (j>n)

{m++;

printf("放法%d ",m);

for (int i=1;i<=n;i++)

printf(" (%d,%d)",a[i],i);

printf("n");

}else for( int i=1; i<=n;i++)

if(fit(i,j)) //检查(i,j)上能否放棋子

{a[j]=i; //在(1,5) (2,3) (3,1) (4,7) (5,2) (6,8) (7,6) (8,4)(i,j)上放一个棋子

{printf("请输入皇后棋子的个数n:n");

scanf("%d",&n); //n为皇后个数

a = new int[n];

queen(1);

八皇后问题c++代码，求详解

(1,7) (2,4) (3,2) (4,8) (5,6) (6,1) (7,3) (8,5)

#include

#include

#include

#include

using namespace std;

bool d[17]={0},b[9]={0},c[17]={0};//下标用到16，数组必须开到17才行

int sum=0,a[9];

int search(int);

int print();

int main()

{search(1); //放第1个皇后

}int search(int i)

{int j;for(j=1;j<=8;j++) //穷举每一行上的8个位置

{if((!b[j])&&(!c[i+j])&&(!d[i-j+7])) //若列上、左斜线、右斜线均不冲突

{a[i]=j; //第i行的皇后放在第j列上

b[j]=1; //封锁第j列

c[i+j]=1; //封锁左斜线

d[i-j+7]=1; //封锁右斜线

if(i==8) //若第8行已放好

{print(); //就打印

}else

{search(i+1); //否则入下一行

}b[j]=0; //本行皇后重放：连同本行，以下三行回溯，解除封锁

c[i+j]=0;

d[i-j+7]=0;

}int pr//!依次输出各个列上的皇后的位置，即所在的行数。int() //打印

sum++;

cout<<"sum="<

for(i=1;i<=8;i++) //输出每一行的皇后放在第几列

{cout<

(1,5) (2,8) (3,4) (4,1) (5,3) (6,6) (7,2) (8,7)}cout<

象棋皇后的走法

c[i-j]:=true'

象棋皇后的走法如下：

走法非常简单的棋，横竖斜都可以进行移动，受到的限制条件较小，因此移动的范围非常的广，除了不能越过其他的棋子，在棋盘上基本可以随便移动，灵活性成为了皇后这款棋子的优势。

皇后的吃子方式很简单，不像是士兵要直走斜吃，皇后可以行棋如吃子，没有的吃子方式，士兵是吃子方式独特，马是行棋方法独特，皇后都没有这些限制。除了越子这一项以外皇后吃子行棋几乎没有限制，而无法越子也并不是皇后的限制，“象”，“车”等等都不可以越子。

八皇后问题就是在棋面上摆放八颗皇后棋子，然后让它们的走法不要冲突，也就是每一颗棋子的走法路径都。那么，这个摆放棋子的问题就成了一个算法问题。八皇后问题，是一个古老而的问题，是回溯算法的典型案例。

该问题是西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认(1,5) (2,7) (3,2) (4,6) (5,3) (6,1) (7,8) (8,4)为有76种方案。1854年在柏林的象棋杂志{/ t == N 时，算法搜索至叶结点，得到一个新的N皇后互不攻击的放置方案 /上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

用C语言编写八皇后问题

inse a[i]++;/将a[i]的值取下一个值/ printed;

#include "stdio.h"

#include "windows.h"

#define N 8 / 定义棋盘大小 /

int place(int k); / 确定某一位置皇a[1]=1;/为数组的个元素赋初值/后放置与否，放置则返回1，反之返回0 /

void backtrack(int i);/ 主递归函数，搜索解空间中第i层子树 /

void chesoard(); / 每找到一个解,打印当前棋盘状态 /

static int sum, / 当前已找到解的个数 /

x[N]; / 记录皇后的位置,x[i]表示皇后i放在棋盘的第i行的第x[i]列 /

int main(void)

{backtrack(0);

("pause");

}int place(int k)

{/ 测试皇后k在第k行第x[k]列时是否与前面已放置好的皇后相攻击。 x[j] == /

/ x[k] 时，两皇后在同一列上；abs(k - j) == abs(x[j] - x[k]) 时，两皇 /

/ 后在同一斜线上。两种情况两皇后都可相互攻击，故返回0表示不符合条件。/

if (abs(k - j) == abs(x[j] - x[k]) || (x[j] == x[k])) return 0;

}void backtrack(int t)

if (t == N) chesoard();

else

for (int i = 0; i < N; i ++) {

x[t] = i;

if (place(t)) backtrack(t + 1);

void chesoard()

{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");

这个题目用递归的方法呢，想楼上的那样。

用C语言编写三个算法，BFS或DFS，爬山算法，遗传算法实现八皇后问题

return 0;

百度算法名，加上八皇后

{if(label[i][j]==0)

比}如

BFS 八皇后问题 C语言。

或者

遗传算法 八皇后问题 C语言

然后根据搜索结果 就可以得到算法和代码了。

八皇后c++源码讲解

// 0,0,0,0,

回溯法:八皇后问题，一个经典问题

在程序设计中还有一种方法叫做"回溯法".他不是按照某种公式或确定的法则,求问题的解,而是通过试探和纠正错误的策略,找到问题的街.这种方法一般是从一个原始状态出发,通过若干步试探,达到目标状态终止.

回溯法在理论上来说,就是在一棵搜索树中从根结点出发,找到一条达到满足某条件的子结点的路径.在搜索过程中,对于每一个中间结点,他的位置以及向下搜索过程是相似的,因此完全可以用递归来处理.典型的例子就是的"八皇后问题".

"八皇后问题"是在象棋棋盘上放置八个皇后,使她们不能相吃.象棋中的皇后可以吃掉与她处于同一行,同一列,同一对角线上的棋子.因此每一行只能摆放一个皇后.因共有八行,所以每行有且只有一个皇后.

在本例中皇后的位置有一个一维数组来存放A(I)=J表示第I行皇后放在第J列.下面主要来看看怎么样判断皇后是否安全的问题.(1)首先,用一维数组来表示,已经解决了不在同一行的问题.(2)对于列可以引进一个标志数组C[J],若J列上已放了皇后,则C[J]=FALSE.(3)对于左上右下的对角线I-J为一常量,位于[-7,+7]之间,再此引入标志数组L[-7..7];对于左下右上的对角线,类似的有I+J等于常量,用数组R[2..16]来表示.当在第I行,第J列上放置了皇后,则只需设置:C[J]:=FALSE; L[I-J]:=FLASE; R[I+J]:=FALSE就可以解决皇后的安全问题了.

问题描述：在标准象棋的棋盘上（88格）准备放置8只皇后，我们知道，象棋中皇后的威力是的，她既可以横走竖走，还可以斜着走，遇到挡在她前进路线上的敌人，她就可以吃掉对手。要求在棋盘上安放8只皇后，使她们彼此互相都不能吃到对方，求皇后的放法。

//

/ /

/ 问题：在8×8的象棋棋盘上放置8个皇后，要求任意两个皇后 /

/ 不能在同一行、同一列或同一条对角线上。 /

/ /

/ 本程序使用递归－回溯法求解8皇后问题。Visual C++ 6.0 调试通过。 /

/ 作者 晨星 2002年5月9日 /

/ /

//

#include

#include

#include

#define QUEENS 8

//!记录解的序号的全局变量。

int iCount = 0;

//!记录皇后在各列上的放置位置的全局数组。

int Site[QUEENS];

//!递归求解的函数。

void Queen(int n);

//!输出一个解。

void Output();

//!判断第n个皇后放上去之后，是否有冲突。

int IsValid(int n);

/----------------------------Main：主函数。 ----------------------------/

{//!从第0列开始递归试探。

Queen(0);

//!按任意键返回。

getch();

}/-----------------Queen：递归放置第n个皇后，程序的核心!----------------/

//!参数n从0开始，等于8时便试出了一个解，将它输出并回溯。

if(n == QUEENS)

{Output();

return;

}//!n还没到8，在第n列的各个行上依次试探。

for(i = 1 ; i <= QUEENS ; i++)

{//!在该列的第i行上放置皇后。

Site[n] = i;

//!如果放置没有冲突，就开始下一列的试探。

if(IsValid(n))

Queen(n + 1);

/------IsValid：判断第n个皇后放上去之后，是否合法，即是否无冲突。------/

int IsValid(int n)

//!将第n个皇后的位置依次于前面n－1个皇后的位置比较。

for(i = 0 ; i < n ; i++)

{//!两个皇后在同一行上，返回0。

if(Site[i] == Site[n])

//!两个皇后在同一对角线上，返回0。

if(abs(Site[i] - Site[n]) == (n - i))

}//!没有冲突，返回1。

}/------------Output：输出一个解，即一种没有冲突的放置方案。------------/

void Output()

//!输出序号。

printf("No.%-5d" , ++iCount);

for(i = 0 ; i < QUEENS ; i++)

printf("%d " , Site[i]);

}STL源代码

用了STL, 方法是一样的.

#include

#include

using namespace std;

void queen(const string t, const string s)

{if (s=="") cout<

else

for (int i=0; i

bool safe=true;

if (t.length()-j==abs(s[i]-t[j])) safe=false;

}if (safe) queen(t+s[i], s.substr(0,i)+s.substr(i+1));

int main()

{string s="01234567";

queen("",s);

("PAUSE");

exit(EXIT_SUCCESS);

}递归解八皇后问题

/递归法解八皇后问题/

/作者黄国瑜，《数据结构（C语言版）》清华大学出版社/

char Chesoard[8][8]; /声明8＊8的空白棋盘/

int N_Queens(int LocX, int LocY, int Queens) /递归/

{int i,j;

int Result=0;

if(Queens == 8)/递归结束条件/

else if(QueenPlace(LocX,LocY))/递归执行部分/

{Chesoard[LocX][LocY] = 'Q';

for(i=0;i<8;i++)

{Result += N_Queens(i,j,Queens+1);

if(Result>0)

break;

}if(Result>0)

else

{Chesoard[LocX][LocY] = 'X';

else

}int QueenPlace(int LocX,int LocY) /判断传入坐标本身及入八个方向上是否有皇后/

{int i,j;

if(Chesoard[LocX][LocY] != 'X')

for(j=LocY-1;j>=0;j--)

if(Chesoard[LocX][j] != 'X')

for(j=LocY+1;j<8;j++)

if(Chesoard[LocX][j] != 'X')

for(i=LocX-1;i>=0;i--)

if(Chesoard[i][LocY] != 'X')

for(i=LocX+1;i<8;i++)

if(Chesoard[i][LocY] != 'X')

i= LocX - 1;

j= LocY - 1;

while (i>=0&&j>=0)

if(Chesoard[i--][j--] != 'X')

i= LocX + 1;

j= LocY - 1;

while (i<8&&j>=0)

i= LocX - 1;

j= LocY + 1;

while (i>=0&&j<8)

if(Chesoard[i--][j++] != 'X')

i= LocX + 1;

j= LocY + 1;

while (i<8&&j<8)

}main() /主程序/

{int i,j;

for(i=0;i<8;i++)

Chesoard[i][j] = 'X';

N_Queens(0,0,0);

printf("the graph of 8 Queens on the Chesoard.is:n");

for(i=0;i<8;i++)

{if(Chesoard[i][j] == 'Q')

printf("(%d,%d)n",i,j);

}getch();

}/

八皇后问题

根据严书给的类c算法求得

/

#define N 8

int col=1,row=1,slash=1,bslash=1;

int a[N][N];

int p,q,k,l;

int num=0;

void trial(int i)

{int j; /注 意，这里的j 一定要设为内部变量/

if(i==N)

{num++;

{for(l=0;l

{if(a[k][l]==1)

printf("@");

e1.线形表的类型定义lse printf("");

}printf("n");

}printf("nn");

getchar();

}else

{for(j=0;j

{col=0;

break;

} /列/

p=i-1;

while((p>=0)&&(q

{if(a[p][q]==1)

{slash=0;

break;

}p--;

q++;

}p=i-1;

q=j-1; /对角/

while((p>=0)&&(q>=0))

{if(a[p][q]==1)

{bslash=0;

break;

}p--;

q--;

} /斜对角/

if((col==1)&&(slash==1)&&(bslash==1)) /条件判断/

{a[i][j]=1;

trial(i+1);

}col=1;slash=1;bslash=1;

a[i][j]=0;

}void main()

{trial(0);

printf("%d}}n",num);

getchar();