搜索与回溯算法

【例1】素数环:从1到20这20个数摆成一个环，要求相邻的两个数的和是一个素数。

【算法分析】

解空间：从1开始，每个空位有20种可能，只要填进去的数合法：与前面的数不相同；

约束条件：与左边相邻的数的和是一个素数，且没有被用过。

边界条件：第20个数还要判断和第1个数的和是否素数，是就输出，不是就回溯

【算法流程】

1、数据初始化；  

2、递归填数：判断第i个数填入是否合法；

A、如果合法：填数；

     判断是否到达目标（20个已填完）：是，打印结果；

     不是，递归填下一个；

B、如果不合法：选择下一种可能；

代码：

#include<iostream>
#include<cstdio>
#include<cmath> 
using namespace std;

int a[10],tot=0;
bool b[10];

bool su(int x,int y){
    if(x==1) return 1;
    int k=2;int i=x+y;
    while(k<=sqrt(i)&&i%k!=0)k++;
    if(k>sqrt(i)) return 1;
    else return 0;
}

int print(){
    tot++;
    for(int i=1;i<=6;i++){
        cout<<a[i]<<" ";
    }cout<<endl;
}

int Search(int k){
    for(int i=1;i<=6;i++){
        if(su(a[k-1],i)&&!b[i]){
            a[k]=i;
            b[i]=true;
            if(k==6){
                if(su(a[6],a[1]))
                print();
            }
            else Search(k+1);
            b[i]=false;
        }
    }
}

int main(){
    Search(1);
    cout<<tot<<endl;
    return 0;
}

【例2】设有n个整数的集合｛1,2,…,n｝，从中取出任意r个数进行排列（r<n），试列出所有的排列。

 【算法分析】

解空间：从第1个位置开始，每个空位有n种选择

约束条件：只要没有被用过就可

边界条件：够了r 个数就可以输出

代码：

#include<iostream>
#include<cstdio>
using namespace std;

int a[10],n,r,tot;
int b[10];

int print(){
    tot++;
    for(int i=1;i<=r;i++)
      cout<<a[i]<<" ";
    cout<<endl;
}

int Search(int k){
    for(int i=1;i<=n;i++){
        if(!b[i]){
            a[k]=i;
            b[i]=true;
            if(k==r) print();
            else Search(k+1); 
            b[i]=false;
        }
    }
}

int main()
{
    cin>>n>>r;
    Search(1);
    cout<<tot<<endl;
    return 0;
}

【例2扩展】设有n个整数的集合｛1,2,…,n｝，从中取出任意r个数进行组合（r<n），试列出所有的组合。

代码：

#include<iostream>
#include<cstdio>
using namespace std;

int a[100],n,m,tot;
bool b[100];

int Search(int k){
    if(k>m){
        tot++;
        for(int i=1;i<=m;i++){
            cout<<a[i]<<" ";
        }cout<<endl;
    }
    else{
        for(int i=1;i<=n;i++)
            if(i>=a[k-1]&&!b[i]){
                a[k]=i;
                b[i]=true;
                Search(k+1);
                b[i]=false;
            }
    }
}

int main(){
    cin>>n>>m;
    Search(1);
    cout<<tot<<endl;
    return 0;
}

【例3】任何一个大于1的自然数n，总可以拆分成若干个小于n的自然数之和。

【问题分析】

（1）本题需要注意，任给自然数n，能否给出所有不同的拆分。

10=3+7与10=7+3是同一种拆分。

（2）如何求出所有的拆分。

下面分析拆分过程：

取n=7来说明：

第一步：将n拆分为2项之和

7=1+6

7=2+5

7=3+4

拆分的特点是第2个加数总大于第1个加数。

第二步：只要第2个加数仍然大于1，就可按第一步重复拆分，例如：

7=1+6 可以继续拆分获得

7=1+1+5

7=1+2+4

7=1+3+3

其中7=1+1+5又可继续拆分获得

7=1+1+1+4

7=1+1+2+3

 

..................

 

最后获得共14种拆分法

 

#include<iostream>
#include<cstdio>
using namespace std;

int a[100],n,tot=1;

int print(int t){
    /*tot++;*/
    cout<<n<<"=";
    for(int i=1;i<=t-1;i++){
        cout<<a[i]<<"+";
    }cout<<a[t]<<endl;
}

void Search(int s,int t){
    for(int i=1;i<=s;i++){
        if(i>=a[t-1]&&i<n){
            a[t]=i;
            s-=i;
            if(s==0) print(t);
            else Search(s,t+1);
            s+=i;
        }
    }    
}

int main(){
    cin>>n;
    Search(n,1);
    /*cout<<tot<<endl;*/
    return 0;
}

例4：n皇后问题

   在n×n的国际象棋棋盘上，放置n个皇后，使任何一个皇后都不能吃掉另一个,需满足的条件是：

  同一行、同一列、同一对角线上只能有一个皇后。求所有满足要求的放置方案。当n=4时有2种放置方法

（2，4，1，3），（3，1，4，2）

 

算法描述：

1.产生一种新放法

2.冲突，继续找，直到找到不冲突----不超范围

3.if 不冲突 then   k<nàk+1

                k=nà一组解

4.if 冲突 then 回溯

 

#include<iostream>
#include<cstdio>
using namespace std;

bool b[100],c[100],d[100];
int a[100],n,tot;

int print(){
    tot++;
    for(int i=1;i<=n;i++){
        cout<<a[i]<<" ";
    }cout<<endl;
}

int Search(int k){
    for(int i=1;i<=n;i++){
        if(!b[i]&&!c[k+i]&&!d[k-i+n-1]){
            a[k]=i;
            b[i]=true;
            c[k+i]=true;
            d[k-i+n-1]=true;
            if(k==n) print();
            else Search(k+1);
            b[i]=false;
            c[k+i]=false;
            d[k-i+n-1]=false;
        }
    }
}

int main()
{
    cin>>n;
    Search(1);
    cout<<tot<<endl;
    return 0; 
}