算法设计与分析实验报告c++实现(连续邮资问题、卫兵布置问题、圆排列问题、求解填字游戏问题、分支限界法求解旅行售货员（TSP）问题)

一、实验目的

1．加深学生对算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；
2．提高学生利用课堂所学知识解决实际问题的能力；
3．提高学生综合应用所学知识解决实际问题的能力。

二、实验任务

1.连续邮资问题
连续邮资问题：某国家发行了n种不同面值的邮票，并且规定每张信封上最多只允许贴m张邮票。连续邮资问题要求对于给定的n和m的值，给出邮票面值的最佳设计。
2.卫兵布置问题
一个博物馆由排成m×n个矩阵陈列的陈列室组成，需要在陈列室中设立哨位，每个哨位上的哨兵除了可以监视自己所在陈列室外，还可以监视他上、下、左、右四个陈列室。试给出一个最佳哨位安排方法，使得所有陈列室都在监视之下，但使用的哨兵最少。
3.圆排列问题
给定n个大小不等的圆c1,c2,…,cn，现要将这n个圆排进一个矩形框中，且要求各圆与矩形框的底边相切。圆排列问题要求从n个圆的所有排列中找出有最小长度的圆排列。
4.求解填字游戏问题
在3*3个方格中要填入1~10的某9个数字，每个方格填一个整数，使所有相邻两个方格的两个整数之和为素数。编写一个程序，求出所有满足这个要求的数字填法。
5、采用分支限界法求解旅行售货员（TSP）问题

三、实验设备

实验设备：Win10 电脑
开发工具：Microsoft Visual C++

四、实验过程设计（算法设计过程）

（一）、连续邮资问题

1、算法分析：
在代码实现中，递归函数Backtrack实现对整个解空间的回溯搜索。 maxvalue记录当前已经找到的最大连续邮资区间，bestx是相应的当前最优解。数组y用来记录当前已经选定的邮票面值x[1:i]能贴出各种邮资所需的最少邮票数。也就是说,y[k]是用不超过m张面值为x[1:i]的邮票，贴出邮资k所需的最少邮票张数。在函数Backtrack中，当i>n时，表示算法已经搜索到一个叶结点，得到一个新的邮票面值设计方案x[1:n]。如果该方案能贴出的最大连续邮资区间大于当前已经找到的最大连续邮资区间maxvalue，则更新当前最优值maxvalue和相应的最优解。当i <= n时，当前扩展结点z是解空间中的一个内部结点，在该结点处x[1:i-1] 能贴出的最大邮资区间为r-1.因此在结点z处x[i]的可取范围是[x[i-1]+1:r]，从而，结点z有r-x[i-1]个儿子结点。算法对当前扩展结点z的每一个儿子结点,以深度优先的方式递归地对相应子树进行搜索。

2、代码实现：

#include <stdio.h>
#include <string.h>
int n,m;//n为邮票种类,m为一封信上最多贴的邮票个数
int Max;
int ans[10000];//最终答案数组
int min(int a,int b)
{
    return a<b?a:b;
}
int panduan(int x[10000],int n,int sum)
//dp[i][j]表示用到第i种邮票，表示邮资为j的最少邮票
 {
     int i,j,k;
     int dp[15][1005];
     for (i=0;i<=n;i++)
        dp[i][0]=0;
       for (i=0;i<=sum;i++)
        dp[1][i]=i;
     for (i=2;i<=n;i++)
        for (j=1;j<=sum;j++)
     {
         dp[i][j]=9999;
         for (k=0;k<=j/x[i];k++)
            dp[i][j]=min(dp[i][j],dp[i-1][j-x[i]*k]+k);  //使用min函数
     }
     if (dp[n][sum]>m)
        return 0;
        return 1;
 }
void DFS(int x[10000],int cur,int max)//x数组储存当前的解，cur代表目前到第几种面值，当到n为止，max表示到目前为止的最大可到达邮资。
{
    int i,next;
    if (cur==n)//如果已经得出了n种邮票
    {
        if (max>Max)//并且它的最大值已经大于当前最大邮资数
        {
            Max=max;
            for (i=1;i<=cur;i++)
                ans[i]=x[i];//更新答案数组
        }
         return;
    }
        for (next=x[cur]+1;next<=max+1;next++)//如果还没得到n中邮票，那么从x[cur]+1~max+1选一个作为下一个邮资，
			                         //因为max+1没法表示，所以必定到max+1为止
        {
          x[cur+1]=next;//用种类为cur+1,数目分别为x[1..cur+1]的邮票,最多使用m张，能否表示出大于max的某个数
            for (i=max+1;i<=m*x[cur+1];i++)          //这个数最少要为max+1,最多是x[cur+1]*m
                if (panduan(x,cur+1,i)==0)
                break;
                if (i>max+1)
                DFS(x,cur+1,i-1);
       }
 
}
  int main()
  {
      int i,max,cur;
      int x[1000]; //中间传递的数组，存储当前的邮票值的解
	  printf("输入邮票种类数:");
      scanf("%d",&n);
	  printf("输入最多粘贴邮票数:");
	  scanf("%d",&m);
      Max=0;
      max=m;
      cur=1;
      x[cur]=1;
      DFS(x,cur,max); //x存储当前的解,cur表示当前传递到第几种邮票,max表示目前能表示到的最大值
      printf("生成的最大邮资是:%d\n",Max);
	  printf("邮票面值为：");
      for (i=1;i<=n;i++)
      printf("%d ",ans[i]);
	  printf("\n");
      return 0;
  }

连续邮资问题
1、实验结果

2、时间复杂度：O（n）

（二）、卫兵布置问题

1、算法分析：
从上到下、从左到右的顺序依次考查每一个陈列室设置警卫机器人哨位的情况，以及该陈列室受到监视的情况，用[i,j]表示陈列室的位置，用x[i][j]表示陈列室[i,j]当前设置警卫机器人哨位的状态。当x[i][j]=1时，表示陈列室[i,j]设置了警卫机器人，当x[i][j]=0时，表示陈列室[i,j]没有设置了警卫机器人。用y[i][j]表示陈列室[i,j]当前受到监视的的警卫机器人的数量。当y[i][j]>0时，表示陈列室[i,j]受到监视的警卫机器人的数量，当y[i][j]=0时，表示陈列室[i,j]没有受到监视。设当前已经设置的警卫机器人的哨位数为k，已经受到监视的陈列室的数量为t，当前最优警卫机器人哨位数为bestc。
设回溯搜索时，当前关注的陈列室是[i,j]，假设该陈列室已经受到监视，即y[i][j]==1，
此时在陈列室[i,j]处设置一个警卫机器人哨位，即x[i][j]==1，相应于解空间树的一个节点q，在陈列室[i+1,j]处设置一个机器人哨位，x[i+1][j]==1，相应于解空间树的另一个节点p。容易看出，以q为根的子树的解，不优于以p为根的子树的解，以q为根的子树可以剪去。因此，在以从上到下，从左到右的顺序依次考察每一个陈列室时，已受监视的陈列室不必设置警卫机器人哨位。
设陈列室[i,j]是从上到下、从左到右搜索到的第一个未受监视的陈列室，为了使陈列室[i,j]受到监视，可在陈列室[i+1,j]、[i,j]、[i,j+1]处设置警卫机器人哨位，在这3处设置哨位的解空间树中的结点分别为p、q、r。

当y[i][j+1]==1时，以q为根的子树的解，不优于以p为根的子树的解，当y[i][j+1]==1且y[i][j+2]==1时，以r为根的子树的解，不优于以p为根的子树的解。搜索时应按照p、q、r的顺序来扩展结点，并检测节点p对节点q和节点r的控制条件。

2、代码实现：

#include <iostream>
#include <fstream>
#include <algorithm>
using namespace std;
const int MAX = 50;
int board[MAX][MAX];  //记录方格被监视情况
int root[MAX][MAX];      //记录机器人位置
int m, n;             //矩阵为 m * n
int k = 0;                //机器人个数
int bestk;

void compute()
{
    memset(root, 0, sizeof(root));
    bool ok = false;
    int i, k;
    if(m == 1)  //矩阵只有一行的情况
    {
        k = n / 3;
        if(n%3 == 1)
        {
            for(i=0; i<=k; i++)
                root[1][3*i+1] = 1;
        }
        else
        {
            if(n%3 == 0)
                k--;
            for(i=0; i<=k; i++)
                root[1][3*i+2] = 1;
        }
        bestk = k + 1;
        ok = true;
    }
    if(n == 1) //矩阵只有一列的情况
    {
        k = m / 3;
        if(m%3 == 1)
        {
            for(i=0; i<=k; i++)
                root[1][3*i+1] = 1;
        }
        else
        {
            if(m%3 == 0)
                k--;
            for(i=0; i<=k; i++)
                root[1][3*i+2] = 1;
        }
        bestk = k + 1;
        ok = true;
    }
	if(m==2 && n%2 == 1) //矩阵有2行，且列数为奇数
    {
        int k = n / 4;
        if(m%4 == 0)
            k--;
        for(i=0; i<=k; i++)
        {
            root[1][4*i+3] = 1;
            root[2][4*i+1] = 1;
        }
        bestk = 2 * k + 2;
        ok = true;
    }
    if(n==2 && m%2 == 1) //矩阵有2列，且行数为奇数
    {
        int k = m / 4;
        if(n%4 == 0)
            k--;
        for(i=0; i<=k; i++)
        {
            root[1][4*i+3] = 1;
            root[2][4*i+1] = 1;
        }
        bestk = 2 * k + 2;
        ok = true;
    }
    if(n==4 && m==4)  //4行4列
    {
        root[1][1] = 1;
        root[1][4] = 1;
        root[4][1] = 1;
        root[4][4] = 1;
        bestk = 4;
        ok = true;
    }
    if(ok)
    {
        cout << "最少的机器人个数为：" << bestk << endl;
        cout << "机器人位置为：\n";
        for(int i=1; i<=m; i++)
        {   
            for(int j=1; j<=n; j++)
                cout << root[i][j] << "\t";
            cout << endl;
        }
    }
    else
        cout << "No Solution!\n";
}

int main()
{
    cout << "输入矩阵行数：";
    cin >> m;   
    cout << "输入矩阵列数：";
    cin >> n;   

    compute();

    cout << endl;
    return 0;
}

卫兵布置问题
1、实验结果

2、时间复杂度：O（1）

（三）、圆排列问题

1、算法分析：
圆排列问题的解空间是一棵排列树。按照回溯法搜索排列树的算法框架，设开始时a=[r1,r2,……rn]是所给的n个元的半径，则相应的排列树由a[1:n]的所有排列构成。
解圆排列问题的回溯算法中，CirclePerm(n,a)返回找到的最小的圆排列长度。初始时，数组a是输入的n个圆的半径，计算结束后返回相应于最优解的圆排列。center计算圆在当前圆排列中的横坐标，由x^2 = sqrt((r1+r2)^2-(r1-r2)2)推导出x = 2sqrt(r1r2)。Compoute计算当前圆排列的长度。变量min记录当前最小圆排列长度。数组r表示当前圆排列。数组x则记录当前圆排列中各圆的圆心横坐标。
在递归算法Backtrack中，当i>n时，算法搜索至叶节点，得到新的圆排列方案。此时算法调用Compute计算当前圆排列的长度，适时更新当前最优值。当i<n时，当前扩展节点位于排列树的i-1层。此时算法选择下一个要排列的圆，并计算相应的下界函数。

2、代码实现：

#include <stdio.h>
#include <iostream>
#include <cmath>
using namespace std;
float CirclePerm(int n,float *a);
template <class Type>
inline void Swap(Type &a, Type &b);
int main()
{
	float *a = new float[4];
	a[1] = 2,a[2] = 3,a[3] = 4;
	cout<<"圆排列中各圆的半径分别为："<<endl;
	for(int i=1; i<4; i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
	cout<<"最小圆排列长度为：";
	cout<<CirclePerm(3,a)<<endl;
	return 0;
}
class Circle
{
	friend float CirclePerm(int,float *);
	private:
		float Center(int t);//计算当前所选择的圆在当前圆排列中圆心的横坐标
		void Compute();//计算当前圆排列的长度
		void Backtrack(int t);
 
		float min,	//当前最优值
			  *x,   //当前圆排列圆心横坐标
			  *r;   //当前圆排列
	    int n;      //圆排列中圆的个数
};
// 计算当前所选择圆的圆心横坐标
float Circle::Center(int t)
{
    float temp=0;
    for (int j=1;j<t;j++)
	{
		//由x^2 = sqrt((r1+r2)^2-(r1-r2)^2)推导而来
        float valuex=x[j]+2.0*sqrt(r[t]*r[j]);
        if (valuex>temp)
		{
			temp=valuex;
		}
    }
    return temp;
}
// 计算当前圆排列的长度
void Circle::Compute(void)
{
    float low=0,high=0;
    for (int i=1;i<=n;i++)
	{
        if (x[i]-r[i]<low)
		{
			low=x[i]-r[i];
		}
        if (x[i]+r[i]>high)
		{
			high=x[i]+r[i];
		}
    }
    if (high-low<min)
	{
		min=high-low;
	}
}
void Circle::Backtrack(int t)
{
    if (t>n)
	{
		Compute();
	}
    else
	{
		for (int j = t; j <= n; j++)
		{
			Swap(r[t], r[j]);
			float centerx=Center(t);
			if (centerx+r[t]+r[1]<min)//下界约束
			{
				x[t]=centerx;
				Backtrack(t+1);
			}
			Swap(r[t], r[j]);
		}
	}
}
float CirclePerm(int n,float *a)
{
	Circle X;
	X.n = n;
	X.r = a;
	X.min = 100000;
	float *x = new float[n+1];
	X.x = x;
	X.Backtrack(1);
	delete []x;
	return X.min;
}
template <class Type>
inline void Swap(Type &a, Type &b)
{  
	Type temp=a; 
	a=b; 
	b=temp;
}

圆排列问题
1、实验结果

2、时间复杂度：O（n）

（四）、求解填字游戏问题

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

int a[11]={0,1,2,3,4,5,6,7,8,9,10};
int x[11]; 
int sum=0;

bool unprime(int a,int b)
{
	int c=a+b,counter=0;
	for(int i=2;i<=sqrt(c);i++)
	{
		if(c%i==0)counter++;
	 } 
	if(counter!=0)return true;
	else return false;
 } 

void func(int i)
{
	if(i==11)
	{
		for(int i=1;i<9;i++)
		{
			if(unprime(x[i],x[i+1]))return; 
		}
		if(unprime(x[8],x[1])||unprime(x[9],x[2])||unprime(x[9],x[4])||unprime(x[9],x[6]))return;
		sum++;
		for(i=1;i<=3;i++)cout<<x[i]<<' ';
		cout<<endl;
		cout<<x[8]<<' '<<x[9]<<' '<<x[4]<<endl;
		cout<<x[7]<<' '<<x[6]<<' '<<x[5]<<endl<<endl<<endl; 
	}
	else
	{
		for(int j=i;j<=10;j++)
		{
			swap(a[i],a[j]);
			x[i]=a[i];
			func(i+1);
			swap(a[i],a[j]);
		}
	}
 } 

int main()
{
	
	func(1);
    cout<<"填法总数：\n"<<sum;
	printf("\n");
	return 0; 
 }

求解填字游戏问题
1、实验结果

2、时间复杂度：O（n！）

（五）、（分支限界法）求解旅行商问题

1、算法分析：
输入：城市数量n和城市之间路程的代价矩阵
输出：城市之间固定起点的哈密顿回路的最短路程
1）计算初始上下界，使用暴力排序对代价矩阵排序算出下界，使用贪心算法计算出上界。
2）定义一个类保存开始节点、结束节点、已遍历的城市及其数量、已遍历的路径长度、当前节点的目标函数值，类中定义一个方法计算当前节点的目标函数值，由当前已遍历的路径的二倍加上进出其余未遍历城市的最短路径，再加上出当前城市的最短路径和进起始城市的最短路径，取其二分之一，是当前节点的目标函数值，即当前节点的下界。
3）把起始节点加入优先队列，当优先队列不为空时，取出当前优先级最高的节点，若当前已遍历n-1个城市，则计算当前路径长度加上最后一个节点的路径长度和记为ans,若ans小于所有目标函数值，则跳出循环并把ans作为最优解输出。若ans不小于所有目标函数值，则更新上界和可行解继续循环。若当前已遍历城市个数小于n-1,则判断当前取出节点的子节点的目标函数是否小于上界，若小于则添加进优先队列，否则继续判断下一个子节点。

2、代码实现：

#include <stdio.h>
#include <istream>
using namespace std;
//---------------------宏定义------------------------------------------
#define MAX_CITY_NUMBER 10          //城市最大数目
#define MAX_COST 10000000           //两个城市之间费用的最大值
//---------------------全局变量----------------------------------------
int City_Graph[MAX_CITY_NUMBER][MAX_CITY_NUMBER];
                            //表示城市间边权重的数组
int City_Size;              //表示实际输入的城市数目
int Best_Cost;              //最小费用
int Best_Cost_Path[MAX_CITY_NUMBER];
                            //最小费用时的路径  
//------------------------定义结点---------------------------------------
typedef struct Node{
	int lcost;              //优先级
	int cc;                 //当前费用
	int rcost;              //剩余所有结点的最小出边费用的和
	int s;                  //当前结点的深度，也就是它在解数组中的索引位置
	int x[MAX_CITY_NUMBER]; //当前结点对应的路径
	struct Node* pNext;     //指向下一个结点
}Node;
//---------------------定义堆和相关对操作--------------------------------
typedef struct MiniHeap{
	Node* pHead;             //堆的头
}MiniHeap;
//初始化
void InitMiniHeap(MiniHeap* pMiniHeap){
	pMiniHeap->pHead = new Node;
	pMiniHeap->pHead->pNext = NULL;
}
//入堆
void put(MiniHeap* pMiniHeap,Node node){
	Node* next;
	Node* pre; 
	Node* pinnode = new Node;         //将传进来的结点信息copy一份保存
                                   //这样在函数外部对node的修改就不会影响到堆了
	pinnode->cc = node.cc;
	pinnode->lcost = node.lcost;
	pinnode->pNext = node.pNext;
	pinnode->rcost = node.rcost;
	pinnode->s = node.s;
	pinnode->pNext = NULL;
	for(int k=0;k<City_Size;k++){
		pinnode->x[k] = node.x[k];
	}
	pre = pMiniHeap->pHead;
	next = pMiniHeap->pHead->pNext;
	if(next == NULL){
		pMiniHeap->pHead->pNext = pinnode;
	}
	else{
		while(next != NULL){
		if((next->lcost) > (pinnode->lcost)){ //发现一个优先级大的，则置于其前面
				pinnode->pNext = pre->pNext;
				pre->pNext = pinnode;
				break;                            //跳出
			}
			pre = next;
			next = next->pNext;
		}
		pre->pNext = pinnode;                           //放在末尾
	}	
}
//出堆
Node* RemoveMiniHeap(MiniHeap* pMiniHeap){
	Node* pnode = NULL;
	if(pMiniHeap->pHead->pNext != NULL){
		pnode = pMiniHeap->pHead->pNext;
		pMiniHeap->pHead->pNext = pMiniHeap->pHead->pNext->pNext;
	}
	return pnode;
}
//---------------------分支限界法找最优解--------------------------------
void Traveler(){
	int i,j;
	int temp_x[MAX_CITY_NUMBER];
	Node* pNode = NULL;
	int miniSum;                    //所有结点最小出边的费用和
	int miniOut[MAX_CITY_NUMBER];
							        //保存每个结点的最小出边的索引
	MiniHeap* heap = new MiniHeap;  //分配堆
	InitMiniHeap(heap);             //初始化堆
	                                
	miniSum = 0;
	for (i=0;i<City_Size;i++){
		miniOut[i] = MAX_COST;      //初始化时每一个结点都不可达
		for(j=0;j<City_Size;j++){
			if (City_Graph[i][j]>0 && City_Graph[i][j]<miniOut[i]){
				                    //从i到j可达，且更小
				miniOut[i] = City_Graph[i][j];
			}
		}
		if (miniOut[i] == MAX_COST){// i 城市没有出边
			Best_Cost = -1;
			return ;
		}
		miniSum += miniOut[i];   
	}
	for(i=0;i<City_Size;i++){       //初始化的最优路径就是把所有结点依次走一遍
		Best_Cost_Path[i] = i;
	}
    Best_Cost = MAX_COST;           //初始化的最优费用是一个很大的数
	pNode = new Node;	            //初始化第一个结点并入堆
	pNode->lcost = 0;               //当前结点的优先权为0 也就是最优
	pNode->cc = 0;                  //当前费用为0（还没有开始旅行）
	pNode->rcost = miniSum;         //剩余所有结点的最小出边费用和就是初始化的miniSum
	pNode->s = 0;                   //层次为0
	pNode->pNext = NULL;
	for(int k=0;k<City_Size;k++){
		pNode->x[k] = Best_Cost_Path[k];      //第一个结点所保存的路径也就是初始化的路径
	}
    put(heap,*pNode);               //入堆
	while(pNode != NULL && (pNode->s) < City_Size-1){
									//堆不空 不是叶子
		for(int k=0;k<City_Size;k++){
			Best_Cost_Path[k] = pNode->x[k] ;      //将最优路径置换为当前结点本身所保存的
		}
/*
* *	 pNode 结点保存的路径中的含有这条路径上所有结点的索引
* *  x路径中保存的这一层结点的编号就是x[City_Size-2]
* *	 下一层结点的编号就是x[City_Size-1]
*/
		if ((pNode->s) == City_Size-2){ //是叶子的父亲
			int edge1 = City_Graph[(pNode->x)[City_Size-2]][(pNode->x)[City_Size-1]];
			int edge2 = City_Graph[(pNode->x)[City_Size-1]][(pNode->x)[0]];
			if(edge1 >= 0 && edge2 >= 0 &&  (pNode->cc+edge1+edge2) < Best_Cost){
															//edge1 -1 表示不可达
			                                              //叶子可达起点费用更低
				   Best_Cost = pNode->cc + edge1+edge2;
				   pNode->cc = Best_Cost;
				   pNode->lcost = Best_Cost;              //优先权为 Best_Cost
				   pNode->s++;									 //到达叶子层
			}
		}
		else{																  //内部结点
			for (i=pNode->s;i<City_Size;i++){                 //从当前层到叶子层
				if(City_Graph[pNode->x[pNode->s]][pNode->x[i]] >= 0){   //可达
								   	//pNode的层数就是它在最优路径中的位置
		Int temp_cc = pNode->cc+City_Graph[pNode->x[pNode->s]][pNode->x[i]];
					int temp_rcost = pNode->rcost-miniOut[pNode->x[pNode->s]];
											//下一个结点的剩余最小出边费用和等于当前结点的rcost减去当前这个结点的最小出边费用
					if (temp_cc+temp_rcost<Best_Cost){      //下一个结点的最小出边费用和小于当前的最优解，说明可能存在更优解
						for (j=0;j<City_Size;j++){	//完全copy路径，以便后续修改
							temp_x[j]=Best_Cost_Path[j];
						}
						temp_x[pNode->x[pNode->s+1]] = Best_Cost_Path[i];
										//将当前结点的编号放入路径的深度为s+1的地方
						temp_x[i] = Best_Cost_Path[pNode->s+1]; 
								      //将原路径中的深度为s+1的结点编号放入当前路径
				//相当于将原路径中的的深度为i的结点与深度W为s+1的结点交换
						Node* pNextNode = new Node;
						pNextNode->cc = temp_cc;
						pNextNode->lcost = temp_cc+temp_rcost;
						pNextNode->rcost = temp_rcost;
						pNextNode->s = pNode->s+1;
						pNextNode->pNext = NULL;
						for(int k=0;k<City_Size;k++){
							pNextNode->x[k] = temp_x[k];
						}
						put(heap,*pNextNode);
						delete pNextNode;
					}
				}
			}
		}
		pNode = RemoveMiniHeap(heap);
	}
}
int main(){
	int i,j;
	printf("输入城市的个数：");
	scanf("%d",&City_Size);
	printf("输入城市之间的距离矩阵：");
	for(i=0;i<City_Size;i++){
		for(j=0;j<City_Size;j++){
			scanf("%d",&City_Graph[i][j]);
		}
	}
	Traveler();
	printf("最短路径为%d\n",Best_Cost);
	return 1;
}

（分支限界法）求解旅行商问题
1、实验结果

2、时间复杂度：O(n²)

五、实验小结（包括问题和解决方法、心得体会等）

回溯法类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。