2020-12-15 实验五 回溯法

实验目的

1、通过回溯法的示例程序理解回溯法的基本思想；

2、运用回溯法解决实际问题进一步加深对回溯法的理解和运用；

实验环境

VC6.0

实验内容

1、分析并掌握“符号三角” 问题的回溯法求解方法；

2、练习使用回溯法求解问题。

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

符号三角问题：下面都是“-”。 下图是由14个“+”和14个“-”组成的符号三角形。2个同号下面都是“+”，2个异号下面都是“-”。
n个符号。符号三角形问题要求对于给定的n，计算有多少个不同的符号三角形，使其所含的“+”和“-”的个数相同。

参考代码如下，请在此基础上，写出主函数，实现如下功能：

1. 分别输出n的值为1----20时，对应的符号三角形个数，如没有满足条件的符号三角形，则输出0。

源代码：

#include <iostream>
using namespace std;
class Triangle
{
 friend int Compute(int n);
private:
 void Backtrack(int t);
 int n, count, half;
 int **p;
 int sum;
};
void Triangle::Backtrack(int t)
{
 int i,j;
 if((count>half)||(t*(t-1)/2-count>half))return;//剪去不满足约束的子树
 if(t>n)
 {   //cout<<endl;
  sum++; //找到一个满足要求的三角形
 } 
 else
 for(i=0;i<2;i++)
 {//子树
  p[1][t]=i;
  count+=i;
  for(j=2;j<=t;j++) //该子树形成的三角形
  {
   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(j=2;j<=t;j++) //回溯恢复
   count-=p[j][t-j+1];
 count-=i;
 }
}
int Compute(int n)
{
 int i,j;
 Triangle X; 
 X.n=n;
 X.count=0;
 X.sum=0;
 X.half=n*(n+1)/2;
 if (X.half%2==1) return 0;
 X.half=X.half/2;
 int**p=new int*[n+1];
 for(i=0;i<=n;i++) 
  p[i]=new int[n+1]; 
 for(i=0; i<=n;i++)
  for(j=0; j<=n;j++)
   p[i][j]=0;
 X.p=p;
 X.Backtrack(1);
 for(i=0;i<=n;i++) 
  delete []p[i]; 
 delete []p;
 p=0;
 return X.sum;
}
int main()
{
 int i,sum;
 for(i=1;i<=20;i++)
 {
  cout<<"当n= "<<i<<endl;
  sum=Compute(i);
  cout<<"对应的符号三角形个数为 "<<sum<<endl;
 }
 return 0;
}

截图：

2. 输入一个整数n，输出对应的符号三角形的个数，并依次显示出所有的符号三角形。
   源代码：

#include <iostream>
using namespace std;
class Triangle
{
 friend int Compute(int n);
private:
 void Backtrack(int t);
 int n, count, half;
 int **p;
 int sum;
};
void Triangle::Backtrack(int t)
{
 int i,j;
 if((count>half)||(t*(t-1)/2-count>half))return;//剪去不满足约束的子树
 if(t>n)
 {   cout<<endl;
  sum++; //找到一个满足要求的三角形
  for(i=1;i<=n;i++)
  {
   for(j=1;j<=i;j++)
    cout<<" ";
   for(j=1;j<=n-i+1;j++)
   {
    if(p[i][j]==1)
     cout<<"-"<<" ";
    else if(p[i][j]==0)
     cout<<"+"<<" ";
   }
   cout<<endl;
  }
 } 
 else
 for(i=0;i<2;i++)
 {//子树
  p[1][t]=i;
  count+=i;
  for(j=2;j<=t;j++) //该子树形成的三角形
  {
   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(j=2;j<=t;j++) //回溯恢复
   count-=p[j][t-j+1];
 count-=i;
 }
}
int Compute(int n)
{
 int i,j;
 Triangle X; 
 X.n=n;
 X.count=0;
 X.sum=0;
 X.half=n*(n+1)/2;
 if (X.half%2==1) return 0;
 X.half=X.half/2;
 int**p=new int*[n+1];
 for(i=0;i<=n;i++) 
  p[i]=new int[n+1]; 
 for(i=0; i<=n;i++)
  for(j=0; j<=n;j++)
   p[i][j]=0;
 X.p=p;
 X.Backtrack(1);
 for(i=0;i<=n;i++) 
  delete []p[i]; 
 delete []p;
 p=0;
 return X.sum;
}
int main()
{
 int i,sum;
 cout<<"请输入一个整数n：";
 cin>>i;
 sum=Compute(i);
 cout<<"对应的符号三角形个数为 "<<sum<<endl;
 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=34=12
n>m,执行g,n=[12/2]=6
n>m,执行f,n=[6/2]=3
n<m,执行g,n=33=9
n>m,执行f,n=[9/2]=4
如果n的值陷入了一个重复的循环，如果在递归的过程中，出现了前面计算过的元素，那就说明n是无法转换成m的。这种方法实现稍微复杂，需要判断当前所求出的数值之前是否出现过。 另一种简单的处理方式： 对于m无论如何变换都不能变为n的情况，可以加一个判断条件，比如深度达一个较大值为止（如1000）。
回溯法， 用子集树实现，子集树结构为：

回溯返回条件有两个，一个是i等于m，另一个是出现了重复的数字。第二个返回条件可以用一个函数test来判断。
剪枝条件：
显式约束：如果x>m，就剪掉它的左子树；如果x<m，就剪掉它的右子树；
隐式约束：如果在某次计算的过程中发现当前的计算次数已经大于或等于最少计算次数了，那么就剪掉这个分支。
源代码：

#include <iostream>
using namespace std;
int n,m;
int max=1000;
int a[1000];
int f(int x)
{
 return x*3;
}
int g(int x)
{
 return x/2;
}
int test(int x,int y)
{
 int i;
 for(i=0;i<y;i++)
  if(x==a[i])
   return 0;
  else
   return 1;
}
void Backtrack(int x,int y)
{
 a[y]=x;
 if(y>max||test(x,y)==0)
  return;
 if(x==m)
 {
  if(y<max)
   max=y;
  return;
 }
 if(x<m)
  Backtrack(f(x),++y);
 else
  Backtrack(g(x),++y);
}
int main()
{
 cout<<"请输入两个整数：";
 cin>>n>>m;
 Backtrack(n,0);
 if(max==1000)
  cout<<"超出较大值，无解"<<endl;
 else
  cout<<"结果为 "<<max<<endl;
 return 0;
}

截图：

2. 子集和问题。
   

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

源代码：

#include <iostream>
using namespace std;
int n,M;
int flag=0;
int t=1;
int s[1000],a[1000];
void backtrack(int num,int sum,int j)
{
 int i;
 if(sum==M)
 {
  flag=1;
  cout<<"第 "<<t<<"种解法："<<endl;
  for(i=0;i<num;i++)
   cout<<a[i]<<" ";
  cout<<endl;
  t++;
  return;
 }
 for(i=j;i<n;i++)
 {
  if(s[i]+sum<=M&&s[i]!=-1)
  {
   a[num]=s[i];
   s[i]=-1;
   backtrack(num+1,sum+a[num],i);
   s[i]=a[num];
   a[num]=-1;
  }
 }
 return;
}
int main()
{
 int i;
 int sum=0;
 cout<<"请输入整数n："<<endl;
 cin>>n;
 cout<<"请输入n个正整数："<<endl;
 for(i=0;i<n;i++)
 {
  cin>>s[i];
  sum=sum+s[i];
 }
 cout<<"请输入整数M："<<endl;
 cin>>M;
 if(sum<M)
  cout<<"No Solution"<<endl;
 else
  backtrack(0,0,0);
 if(flag==0)
  cout<<"No Solution"<<endl;
 return 0;
}

截图：

3.工作分配问题。

问题描述：设有n件工作分配给n个人。将工作i分配给第j个人的费用为cij,请设计算法，为每个人都分配1件不同的工作，并使得总费用达到最小。

实现提示：该问题的解空间是一棵排列树，可用搜索排列树的回溯框架实现。

源代码：

#include <iostream>
using namespace std;
int n,sum;
int a[1000][1000];
void backtrack(int x,int y)
{
 int i;
 if(x>n&&y<sum)
 {
  sum=y;
  return;
 }
 if(y<sum)
 {
  for(i=1;i<=n;i++)
  {
   if(a[0][i]==0)
   {
    a[0][i]=1;
    backtrack(x+1,y+a[x][i]);
    a[0][i]=0;
   }
  }
 }
}
int main()
{
 int i,j;
 cin>>n;
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
  {
   cin>>a[i][j];
   a[0][j]=0;
  }
  sum+=a[i][i];
 }
 backtrack(1,0);
 cout<<sum<<endl;
 return 0;
} 

截图：