实验五、回溯法

桂 林 理 工 大 学
实 验 报 告
同组实验者
实验名称 实验五、回溯法 日期 2020年 12 月08 日
一、实验目的：
1、通过回溯法的示例程序理解回溯法的基本思想；
2、运用回溯法解决实际问题进一步加深对回溯法的理解和运用；

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

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

在一般情况下，符号三角形的第一行有n个符号。符号三角形问题要求对于给定的n，计算有多少个不同的符号三角形，使其所含的“+”和“-”的个数相同。
参考代码如下，请在此基础上，写出主函数，实现如下功能：
1.分别输出n的值为1----20时，对应的符号三角形个数，如没有满足条件的符号三角形，则输出0

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

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)
{
   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
	for(int i=0;i<2;i++)
	{//子树
	   p[1][t]=i;
	   count+=i;
	   for(int 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(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;
            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(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;
            X.Backtrack(1);
            for(int i=0;i<=n;i++)	
		       delete []p[i];	
	        delete []p;
	        p=0;
            return X.sum;
}

五、实验题
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）。
回溯法， 用子集树实现，子集树结构为：

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

import java.util.Scanner;

public class Main {
    static int n;//要变换的数
    static int m;//要变换成的数
    static int k;//变换的次数
    static boolean found;//查找结果
    static int []result =new int[100] ;//最多变换100次
    static void compute(){
        k = 1;
        found = false;
        while (!search(1, n)){
            k++;
            if (k > 100)
                break;
            if (found)
                break;
        }
    }

    static boolean search(int dep, int n){
//search实现回溯搜索
        if (dep>k){
            return false;
        }
        for (int i = 0; i<2; i++){
            int num = n;
            num = fg(num, i);
            result[dep] = i;
            if (num == m || search(dep + 1, num)){
                found = true;
                return true;
            }
        }
        return false;
    }

    static int fg(int n, int i){
        if (i == 0)
            return n / 2;
        else
            return 3 * n;
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println( "输入要变换的数： ");
        n = input.nextInt();
        System.out.println( "输入要变换成的数： ");
         m = input.nextInt();
        for (int i = 0; i<99; i++){
            result[i] = 0;
        }
        compute();
        if (found) {
            System.out.println("运算次数：" + k + "次" );
            System.out.println("运算过程：");
            for (int i = k; i >= 1; i--) {
                if (result[i] == 0)
                    System.out.print("g");
                else if (result[i] == 1)
                    System.out.print("f");
            }
            System.out.println();
        }
        else{
            System.out.println(n+"无法变换成"+m);
        }


    }
}

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

import java.util.Arrays;
import java.util.Scanner;

public class Solution {
    private static int n,c,i,sum=0;
   static int a[] = new int[10000],b[] = new int[10000],d[]= new int[10000];
    static boolean pd;

    public static void print(int dep)
    {
        int j;
        for (j=1;j<=dep;++j)
            System.out.print(d[j]+" ");
        System.out.println();
        return;
    }

    static void dfs(int dep)
    {
        int r;
        if (pd==true) return;//因为只需输出一组解，c++又没法结束整个程序，，怕超时到处加判断。。。（我智商低别理我）
        for (r=1;r<=n;++r)
            if (b[r] == 0&&c-a[r]>=0)
            {
                if (pd==true) return;
                c-=a[r];//用c减去每个数，其实就是几个数之和等于c
                d[dep]=a[r];//d是记录数组
                b[r]=1;
                if (c==0) //如果找到一组解，直接输出，完成任务
                {
                    if (pd==false)
                        print(dep);
                    pd=true;
                    return;
                }
                else dfs(dep+1);
                if (pd==true) return;
                c+=a[r];//回溯一步
                b[r]=0;
            }
    }
public static void main(String[] args){
    Scanner input = new Scanner(System.in);

    n = input.nextInt();

    c = input.nextInt();
    for (i=1;i<=n;++i)
    {
        a[i] = input.nextInt();
        sum+=a[i];
    }
    if (sum<c)//很重要的剪枝！！如果所有的数加起来都小于c，那么不可能有解。。之前有三组TLE，加了这一步竟然给蒙过了。。
    {
        System.out.println("No solution!");
        return ;
    }
    Arrays.fill(d, 0);
    Arrays.fill(b, 0);
    pd=false;
    dfs(1);
    if (!pd) System.out.println("No solution!");

}
}

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