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

news2024/11/18 8:23:54

一、 实验目的

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、实验结果

img

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。

img

当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、实验结果

img

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、实验结果

img

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、实验结果

img

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、 实验结果

img

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

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

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1573561.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

最好用的安卓按钮(3)

最好用的安卓按钮(3)

属性解释 按钮文字 app:text“床前明月光” 按钮文字颜色 app:textColor“color/color_white” 按钮文字大小 app:textSize“22sp” 按钮背景颜色 app:color_normal“color/color_accent” 0x2 单独设置每个圆角 效果 代码 <top.androidman.SuperButton android:layo…
阅读更多...
软考 系统架构设计师系列知识点之数据库基本概念（4）

软考 系统架构设计师系列知识点之数据库基本概念（4）

接前一篇文章&#xff1a;软考 系统架构设计师系列知识点之数据库基本概念&#xff08;3&#xff09; 所属章节&#xff1a; 第6章. 数据库设计基础知识 第1节 数据库基本概念 6.1.3 数据库管理系统 DBMS&#xff08;DataBase Management System&#xff0c;数据库管理系统&am…
阅读更多...
【Linux】SSH协议应用

【Linux】SSH协议应用

SSH协议 SSH简介实现OpenSSH ssh中的四个文件~/.ssh文件路径实验解析 SSH 简介 SSH&#xff08;secure shell&#xff09;只是一种协议&#xff0c;存在多种实现&#xff0c;既有商业实现&#xff0c;也有开源实现。本文针对的实现是OpenSSH&#xff0c;它是自由软件&#xf…
阅读更多...
ZYNQ实验--CIC插值滤波器实验

ZYNQ实验--CIC插值滤波器实验

一、CIC滤波器介绍 CIC (Cascaded Integrator-Comb) 滤波器是一种常用的数字信号处理滤波器&#xff0c;主要用于降采样&#xff08;decimation&#xff09;和升采样&#xff08;interpolation&#xff09;操作。它具有简单的硬件实现、高效的运算速度以及适用于需要快速处理的…
阅读更多...
应届生选导师的创业公司，还是去中厂？

应届生选导师的创业公司，还是去中厂？

点击上方&#xff0c;选择“置顶/星标公众号” 福利干货&#xff0c;第一时间送达 导师是做自动化设备的控制软件&#xff0c;公司做纯软件。导师能给一样的工资&#xff0c;五人左右团队&#xff0c;潜在收入可能要高一些。纠结哪个对今后的发展更好一些。 大家好&#xff0…
阅读更多...
【论文阅读笔记】Mamba模型代码理解

【论文阅读笔记】Mamba模型代码理解

0.开源代码地址 官方实现&#xff1a;state-spaces/mamba (github.com) 最简化实现&#xff1a;johnma2006/mamba-minimal: Simple, minimal implementation of the Mamba SSM in one file of PyTorch. (github.com) 直接实现&#xff1a;alxndrTL/mamba.py: A simple and e…
阅读更多...
Java 接口提示500，但console并不报错。

Java 接口提示500，但console并不报错。

因为习惯了C语言printf打印&#xff0c;且当时并不明白try catch意义所在 如图所示&#xff0c;下添加了行号打印 但只打印出了line 89&#xff0c;无line 91&#xff0c;也无报错 所以使用try catch 包裹Sql查询封装函数 e.printStackTrace(); 果真打印出了 查看Entity类&…
阅读更多...
【经典算法】LeetCode25:K 个一组翻转链表(Java/C/Python3,Hard)

【经典算法】LeetCode25:K 个一组翻转链表(Java/C/Python3,Hard)

#算法 目录 题目描述思路及实现方式一&#xff1a;递归思路代码实现Java 版本C 语言版本Python3 版本 复杂度分析 方式二&#xff1a;迭代和原地反转思路代码实现Java 版本C 语言版本Python3 版本 复杂度分析 总结相似题目 标签&#xff1a;链表、递归 题目描述 给你链表的头…
阅读更多...
DFS：floodfill算法解决矩阵联通块问题

DFS：floodfill算法解决矩阵联通块问题

floodfill&#xff0c;翻译为洪水灌溉&#xff0c;而floodfill算法本质上是为了解决在矩阵中性质相同的联通块问题。 一、图像渲染 . - 力扣&#xff08;LeetCode&#xff09; class Solution { public:int dx[4]{0,0,1,-1};int dy[4]{1,-1,0,0};int prev;//记住初始值int m,…
阅读更多...
什么是广播系统语言传输指数 STIPA

什么是广播系统语言传输指数 STIPA

基础知识 通过广播系统播放一个确定的信号&#xff08;STIPA 测试信号&#xff09;&#xff0c;再在待测点测量其到达后的质量即可。IEC 60268-16 标准中定义通过单一值表示清晰度结果&#xff0c;0 表示完全无法理解&#xff0c;1 表示完美理解。测量单位是 STI&#xff08;语…
阅读更多...
C#探索之路基础夯实篇(3)：面向对象的三大特性和五大原则详解

C#探索之路基础夯实篇(3)：面向对象的三大特性和五大原则详解

文章目录 前提&#xff1a;一、特性&#xff1a;二、原则&#xff1a;三、示例1. 单一职责原则 (Single Responsibility Principle, SRP)&#xff1a;2. 开放-封闭原则 (Open-Closed Principle, OCP)&#xff1a;3. 里氏替换原则 (Liskov Substitution Principle, LSP)&#xf…
阅读更多...
移动硬盘能当u盘重装系统吗？做启动数据还能恢复吗

移动硬盘能当u盘重装系统吗？做启动数据还能恢复吗

在数字时代&#xff0c;随着技术的不断发展&#xff0c;我们越来越依赖于各种存储设备&#xff0c;其中移动硬盘以其大容量和便携性受到广大用户的青睐。不过&#xff0c;有时我们可能会遇到需要使用U盘来重装系统的情况&#xff0c;而手头又没有合适的U盘。这时&#xff0c;我…
阅读更多...
Spring Boot-01-通过一个项目快速入门

Spring Boot-01-通过一个项目快速入门

官方参考文档&#xff1a;Spring Boot Reference Documentation 0. 概述 Spring的缺点&#xff1a; 1. 配置繁琐&#xff1a;虽然Spring的组件代码是轻量级&#xff0c;但它的配置却是重量级的。 2. 依赖繁琐&#xff1a;项目的依赖管理也是一件耗时耗力的事情。分析要导入哪…
阅读更多...
03-JAVA设计模式-工厂模式详解

03-JAVA设计模式-工厂模式详解

工厂模式 工厂设计模式是一种创建型设计模式&#xff0c;它提供了一种封装对象创建过程的机制&#xff0c;将对象的创建与使用分离。 这种设计模式允许我们在不修改客户端代码的情况下引入新的对象类型。 在Java中&#xff0c;工厂设计模式主要有三种形式&#xff1a;简单工厂…
阅读更多...
【CNN】ConvMixer探究ViT的Patch Embedding: Patches Are All You Need?

【CNN】ConvMixer探究ViT的Patch Embedding: Patches Are All You Need?

Patches Are All You Need? 探究Patch Embedding在ViT上的作用&#xff0c;CNN是否可用该操作提升性能&#xff1f; 论文链接&#xff1a;https://openreview.net/pdf?idTVHS5Y4dNvM 代码链接&#xff1a;https://github.com/tmp-iclr/convmixer 1、摘要 ViT的性能是由于T…
阅读更多...
基于Spark中随机森林模型的天气预测系统

基于Spark中随机森林模型的天气预测系统

基于Spark中随机森林模型的天气预测系统 在这篇文章中&#xff0c;我们将探讨如何使用Apache Spark和随机森林算法来构建一个天气预测系统。该系统将利用历史天气数据&#xff0c;通过机器学习模型预测未来的天气情况&#xff0c;特别是针对是否下雨的二元分类问题。 简介 Ap…
阅读更多...
【unity】【C#】延时调用（协程）和场景管理

【unity】【C#】延时调用（协程）和场景管理

文章目录 什么是协程协程的应用 - IEnumerator如何控制协程的暂停协程的另一种写法 - Invoke场景管理 多看代码块中的注释 什么是协程 A coroutine alows vou to spreacwhere it left off on the following anc return control toolinencoeframe. 协程允许您将任务分布在多个帧…
阅读更多...
Android14应用启动流程（源码+Trace）

Android14应用启动流程（源码+Trace）

1.简介 应用启动过程快的都不需要一秒钟&#xff0c;但这整个过程的执行是比较复杂的&#xff0c;无论是对手机厂商、应用开发来说启动速度也是核心用户体验指标之一&#xff0c;本文采用Android14源码与perfetto工具进行解析。 源码参考地址&#xff1a;Search trace分析工…
阅读更多...
【二分查找】Leetcode 在排序数组中查找元素的第一个和最后一个位置

【二分查找】Leetcode 在排序数组中查找元素的第一个和最后一个位置

题目解析 34. 在排序数组中查找元素的第一个和最后一个位置 我们使用暴力方法进行算法演化&#xff0c;寻找一个数字的区间&#xff0c;我们可以顺序查找&#xff0c;记录最终结果 首先数组是有序的&#xff0c;所以使用二分法很好上手&#xff0c;但是我们就仅仅使用上一道题…
阅读更多...
第四百四十二回 再谈flutter_launcher_icons包

第四百四十二回 再谈flutter_launcher_icons包

文章目录 1. 概念介绍2. 使用方法3. 示例代码4. 经验与总结4.1 经验分享4.2 内容总结 我们在上一章回中介绍了"overlay_tooltip简介"相关的内容&#xff0c;本章回中将 再谈flutter_launcher_icons包.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1. 概念介绍 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023