实验5 回溯法

一、实验目的与要求：

1、通过回溯法的示例程序理解回溯法的基本思想；
2、运用回溯法解决实际问题进一步加深对回溯法的理解和运用；

二、实验内容：

1、分析并掌握“符号三角” 问题的回溯法求解方法；
2、练习使用回溯法求解问题。

三、实验步骤

1．理解回溯算法思想和算法示例；
2．上机输入和调试算法示例程序；
3．理解实验题的问题要求；
4．上机输入和调试自己所编的实验题程序；
5．验证并分析实验题的实验结果；
6．整理出实验报告；

四、示例程序：符号三角形问题

符号三角问题：下面都是“-”。 下图是由14个“+”和14个“-”组成的符号三角形。2个同号下面都是“+”，2个异号下面都是“-”。

+   +   -   +   -   +   +
   +   -   -   -   -   +
     -   +   +   +   -
       -   +   +   -
         -   +   -
           -   -
            +

在一般情况下，符号三角形的第一行有n个符号。符号三角形问题要求对于给定的n，计算有多少个不同的符号三角形，使其所含的“+”和“-”的个数相同。
参考代码如下，请在此基础上，写出主函数，实现如下功能：

1. 分别输出n的值为1----20时，对应的符号三角形个数，如没有满足条件的符号三角形，则输出0
2. 输入一个整数n，输出对应的符号三角形的个数，并依次显示出所有的符号三角形。

运行代码以及个人注释：

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

class Triangle
{    
    //用于创建数据初始化
    //使用友元函数可以不受在类中声明位置的影响
    friend int Compute(int n);
    private:
      //回溯函数的具体实现
      void Backtrack(int t);
      //n用来记录存放的数据，count用来记录‘-’出现的次数，而half用来一半的个数
      //用于剪枝操作
       int n, count, half;
       //用于创建二维数组
      int **p;
      //用于统计三角形的个数
      int sum;
};

/**
 * 
 * 使用基本的回溯框架
 * t用于表示第一行元素中的第t个数
 */
void Triangle::Backtrack(int t)
{
   if((count>half)||(t*(t-1)/2-count>half))return;//剪去不满足约束的子树
   if(t>n)
    {   cout<<endl;
        sum++; //找到一个满足要求的三角形
        for (int i=1;i<=n;i++)
        {   
            //用于对齐三角形
           for(int j=1; j<i; j++)
              cout<<" ";
           for(int j=1;j<=n-i+1;j++)
              if (p[i][j]==1)
                 cout<<'-'<<' ';
              else if (p[i][j]==0)
                 cout<<'+'<<' ';
           cout<<endl; 
        }
    } 
   else
   /**
    * 第一行中所有元素的状态要么为0，要么为1
    * 即‘+’或‘-’
    * 所以  i要么为1或为0
    * 
    */
    for(int i=0;i<2;i++)
    {//子树
       p[1][t]=i;
       count+=i;
       /**
        * 在这里用j来计算行
        */
       for(int j=2;j<=t;j++) //该子树形成的三角形
       { 
            //例如p[1][1]=0，p[1][2]=0 经过异或运算可以的出p[2][1]=0 
          p[j][t-j+1]=p[j-1][t-j+1]^p[j-1][t-j+2];
          count+=p[j][t-j+1];
       }          
       Backtrack(t+1);
       for(int j=2;j<=t;j++) //回溯恢复
         count-=p[j][t-j+1];
       count-=i;
   }
}
int Compute(int n)
{
            Triangle X; 
            X.n=n;
            X.count=0;
            X.sum=0;
            /**
             * 计算half
             */
            X.half=n*(n+1)/2;
            if (X.half%2==1) return 0;
            X.half=X.half/2;

           /**
            *创建动态二维数组的过程
            *如果这里使用vector感觉会更加方便
            */
            int**p=new int*[n+1];
            for(int i=0;i<=n;i++)   
               p[i]=new int[n+1];   
            for(int i=0; i<=n;i++)
                 for(int j=0; j<=n;j++)
                    p[i][j]=0;
            X.p=p;

            /**
             * 为了方便直接，所以从1开始
             */
            X.Backtrack(1);

            /**
             * 回收空间
             */
            for(int i=0;i<=n;i++)   
               delete []p[i];   
            delete []p;
            p=0;
            return X.sum;
}
int main()
{
 Triangle MainName;
 int n;
 cin>>n;
 cout<<Compute(n)<<endl;
 system("pause");
 return 0;
}

运行结果：

五、实验题

1.算法实现题：整数变换问题。

整数i的两种变换定义为 ， （向下取整）；设计一个算法求给定两个整数a和b，用最少次数的 和 变换将整数a变换为b；例如
实现提示：
观察f和g两个操作可知，f总是使得i变大，g总是使得i变小。因此在决定让x执行哪个操作之前可以先判断i和目标值m之间的大小关系。如果x>m，就让其执行g操作；反之，执行f操作。
问题的解分为两种情况，一种是有解，即n可以通过函数变换成m；另一种是无解，即n无法通过函数变换成m。
有解的情况比较容易，只需要判断最后的i是否等于m即可。如果i等于m，那么说明n已经被变换成m了，递归返回。
无解的情况可用下例分析。假设我们的输入n=9,m=5。
n>m,执行g,n=[9/2]=4
n<m,执行f,n=3*4=12
n>m,执行g,n=[12/2]=6
n>m,执行f,n=[6/2]=3

n<m,执行g,n=3*3=9
n>m,执行f,n=[9/2]=4
如果n的值陷入了一个重复的循环，如果在递归的过程中，出现了前面计算过的元素，那就说明n是无法转换成m的。这种方法实现稍微复杂，需要判断当前所求出的数值之前是否出现过。 另一种简单的处理方式： 对于m无论如何变换都不能变为n的情况，可以加一个判断条件，比如深度达一个较大值为止（如1000）。

运行代码：

#include<iostream>
using namespace std;
int a,b;
int k,found;
int *p;

int f(int i)
 {
   return 3*i;
 }

int g(int i)
   {
   return i/2;
   }

//判断是否存在，m代表层数，n表示需要变化的数

int changed(int m,int n)
 {
  int i,s;
  //终止条件
  if(m>k)return 0;
  for(i=0;i<2;i++)
{
  s=n;
 if(i==0)s=g(s);
 else s=f(s);
 p[m]=i;
 //回溯
 if(s==b||changed(m+1,s))
{
   found=1;
   return 1;
}
}
   return 0;
}
void compared()
{
 k=1;
 found=0;
 while(!changed(1,a))
{
  k++;
 if(k>100)break;
 if(found!=0)break;
}
}
int  main()
{
p=new int[100];

int i;

for(i=0;i<100;i++)p[i]=0;

cout<<"请依次输入a和b的值: "<<endl;

cin>>a>>b;

compared();

if(found)

{
cout<<"运算次数为:"<<k<<endl;
cout<<"运算转换过程为: ";

for(i=k;i>=1;i--)

{
if(p[i]==0)cout<<"g";

if(p[i]==1)cout<<"f";

}

}

else cout<<a<<" 无法转换成 "<<b<<endl;

system("pause");
return 0;

}

2. 子集和问题。

问题描述：给定集合S，S中有n个正整数，M是一个正整数。子集和问题判定是否存在S的一个子集S1，使得S1中各元素之和等于M。请设计回溯法求解子集和问题，如果问题无解，输出“No Solution”,问题有解，则输出满足子集S1中各元素的值。
子集树问题：
运行代码：

#include<iostream>
using namespace std;
bool found=false;
int sum,tempSum;
int n,*p,*number;
void Backtrack(int t)
{
    if(t==n) 
    {
        if(sum==tempSum)
        {
          found=true;
          cout<<"子集为:";
          for(int i=0;i<n;i++)
           {
               if(p[i]) cout<<" "<<number[i];
           }
           cout<<endl;
        }
        return;
    }

    for(int i=0;i<2;i++)
    {
        p[t]=i;
        if(i==1) tempSum=tempSum+number[t];
        Backtrack(t+1);
        if(i==1) tempSum=tempSum-number[t];
    }
   
}
int main()
{
    cout<<"输入数组长度：";
    cin>>n;

    cout<<endl<<"输入数据和：";
    cin>>sum;
    tempSum=0;
    number=new int [n];
    p=new int [n];
    cout<<endl<<"输入数组：";
    for(int i=0;i<n;i++)
     {
         p[i]=0;
         cin>>number[i];
     }
     Backtrack(0);
     if(!found) cout<<"No Solution! "<<endl;
     system("pause");
    return 0;
}

运行结果:

3. 工作分配问题。

问题描述：设有n件工作分配给n个人。将工作i分配给第j个人的费用为cij,请设计算法，为每个人都分配1件不同的工作，并使得总费用达到最小。
实现提示：该问题的解空间是一棵排列树，可用搜索排列树的回溯框架实现。
运行代码：

#include<iostream>
#include<string.h>
#define MaxSize 20
using namespace std;
int nowVal=0,minVal=10000;
int a[MaxSize][MaxSize];//二维数组
int n,*work;//work数组代表工作是否被占领，初始化为0
void Input()
{
    int i,j;
    cin>>n;
    work=new int[n];
    for(i=0;i<n;i++) work[i]=0;
    for(i=0;i<n;i++)
      for(j=0;j<n;j++)
        cin>>a[i][j];

}
void BackTrack(int row)
{
    int col;
    if(row==n&&nowVal<minVal)
    {
     minVal=nowVal;
     return ;
    }
    else
    {
        for(col=0;col<n;col++)
        {
            if(work[col]==0)
            {
             work[col]=1;
             nowVal=nowVal+a[row][col];
             if(nowVal<minVal) BackTrack(row+1);//剪枝操作
             nowVal=nowVal-a[row][col];//回溯算法实现
             work[col]=0;
            }
        }
        
    }
    
}

int main()
{
    Input();
    BackTrack(0);
    cout<<minVal<<endl;
    system("pause");
    return 0;
}

运行结果：