算法设计与分析--回溯算法

 

01:素数环-子集树和排列树分别实现（重点）

总时间限制: 

3000ms

内存限制: 

65535kB

描述

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

输出可能的方案数

输入

一个整数n(n<=20)

输出

可能的方案个数

样例输入

2

样例输出

2

子集数

#include 
#include 
#include 
using namespace std;

bool b[21]={0};//标志i是否出现在素数环中
int total=0,a[21]={0};//a记录素数环中的每一个数
void search(int t);//回溯过程。形参表示素数环中的数的编号
void print();//输出方案
bool pd(int,int);//判断两数之和是不是素数

void search(int t)//寻找所有解
{
    int i;
    for(i=1;i<=20;i++)
    {
        if(pd(a[t-1],i)&&(!b[i])) //与前一个数是否构成素数及该数是否可用

        {
            a[t]=i;//i进入素数环
            b[i]=1;//标志1
            if(t==20)//到最后得到一个解
            {
                if(pd(a[20],a[1]))//判断最后一个和第一个
                    print();
            }
            else
                search(t+1);
            b[i]=0;
        }
    }
}

void print()
{
    total++;
    cout<<"<"<";
    for(int j=1;j<=20;j++)
        cout<sqrt(i))
        return 1;
    else
        return 0;
}

int main()
{
    for(int i=1;i<=20;i++)
        a[i]=i;
    search(1);
    cout<

排列树

#include 
#include 
#include 
using namespace std;

bool b[21]={0};//标志i是否出现在素数环中
int total=0,a[21]={0};//a记录素数环中的每一个数
void search(int t);//回溯过程。形参表示素数环中的数的编号
void print();//输出方案
bool pd(int,int);//判断两数之和是不是素数

void search(int t)//寻找所有解
{
    int i;
    for(i=t;i<=20;i++)
    {
        swap(a[t],a[i]);
        if(pd(a[t-1],a[t]))
        {
            if(t==20)
            {
                if(pd(a[20],a[1]))
                    print();
            }
            else
                search(t+1);
        }
        swap(a[t],a[i]);
    }
}

void print()
{
    total++;
    cout<<"<"<";
    for(int j=1;j<=20;j++)
        cout<sqrt(i))
        return 1;
    else
        return 0;
}

int main()
{
    for(int i=1;i<=20;i++)
        a[i]=i;
    search(1);
    cout<

02:装载问题--最大装载量（重点）

分析： 由于集装箱问题是从n个集装箱里选择一部分集装箱，假设解向量为X(x1, x2, …, xn)，其中xi∈{0, 1}， xi =1表示集装箱i装上轮船， xi =0表示集装箱i不装上轮船。

输入:每组测试数据：第1行有2个整数c和n。c是轮船的载重量（0＜c＜30000），n是集装箱的个数（n≤20）。第2行有n个整数w1, w2, …, wn，分别表示n个集装箱的重量。

输出:对每个测试例，输出两行：第1行是装载到轮船的最大载重量，第2行是集装箱的编号。

#include 
#include
#include
#include
using namespace std;

class goods{
    int weight;//集装箱重量
public:
    goods(int w=0):weight(w)
    {}
    int get_w()
    {
        return weight;
    }
    void set(int w)
    {
        weight=w;
    }
};

void load(goods *g, int *x, int t, int n,int cw, int &bestcw ,int *best,int r,int c)//轮船载重

//goods *g集装箱列表,*x满足当前最大荷载的装载方案,t子集树的层号,n集装箱的总数

//cw当前的轮船的荷载,bestcw当前的最大荷载,*best待求解的最优装载方案;r剩余的未考察的集装箱重量和
{
    if(t==n)//已经遍历的到叶子结点
    {
        if(cw>bestcw)//当前的轮船的荷载>当前的最大荷载
        {
            for(int i=0;ibestcw)//限界规则
            {
                x[t]=0;
                load(g,x,t+1,n,cw,bestcw,best,r,c);
            }
            r=r+g[t].get_w(); //回溯的需要
        }
}

int main()
{
    int n,c,bestcw=0;
    int *x,*best, r=0;
    cout<< "请输入轮船的装载重量c和物品的件数n：";
    cin>>c>>n;
    goods *g;
    g=new goods[n];
    x=new int [n];
    best=new int[n];
    cout<<"请输入每件物品的重量：";
    for(int i=0;i>w;
        g[i].set(w);
        r=r+w;
    }
    load(g,x,0,n,0,bestcw,best,r,c);
    cout<

03:0-1背包问题（重点）

输入： 第一个数据是背包的容量为c（1≤c≤1500），第二个数据是物品的数量为n（1≤n≤50）。接下来n行是物品i的重量是wi，其价值为vi。所有的数据全部为整数，且保证输入数据中物品的总重量大于背包的容量。当c＝0时，表示输入数据结束。

输出： 对每组测试数据，输出装入背包中物品的最大价值。

分析：0-1背包问题（子集数）

令cw(i)表示目前搜索到第i层已经装入背包的物品总重量
令cv(i)表示目前到第i层结点已经装入背包的物品价值
对于左子树， xi =1 ，其约束函数为：construction(i)=cw(i-1)+wi。若constraint(i)＞W，则停止搜索左子树，否则继续搜索。
对于右子树，r(i)表示剩余物品的总价值，限界函数Bound(i)=cv(i)+r(i)
r(i)越小， Bound(i)越小，剪掉的分支就越多（越靠近树根剪枝，剪掉的分支越多。从而能加快搜索速度）。
为了构造更小的r(i) ，将物品以单位重量价值比di=vi/wi递减的顺序进行排列（贪心策略）

#include 
using namespace std;

int c,n;//背包容量、物品数量
int cw,cv;//背包当前重量，当前价值
int bestv;//当前最优价值

struct bag
{
    int w; //物品的重量
    int v; //物品的价值
    double d; //物品的单位重量价值比
}a[101];

bool cmp(bag a,bag b)//按照价值比从大到小排序
{
    if(a.d>=b.d)
        return true;
    else
        return false;
}

int Bound(int i)//限界函数
{
    int cleft=c-cw;//背包剩余的容量
    int b=cv;//上界
    //尽量装满背包
    while(ibestv)//大于当前最优价值,满足条件不剪枝
    {
        ff(i+1);
    }
    return 0;
}

int main()
{
    cin>>c>>n;
    for(int i=0;i>a[i].w>>a[i].v;
        a[i].d=1.0*a[i].v/a[i].w;
    }
    sort(a,a+n,cmp);
    ff(0);
    cout<

04:n皇后问题（重点）

 

 

#include
using namespace std;

int n;//棋盘大小
int x[101];//解向量
int sum=0;//当前已经找到的可行方案数

inline bool Place(int t)//判断是否在同一行，同一列，同一对角线
{
    int i;
    for(i=1;in)//到达叶子结点
    {
        sum++;//方案数+1
        for(i=1;i<=n;i++)
            cout<>n;
    Back(1);
    cout<