数据结构与算法_五大算法之--回溯算法

于 2022-12-31 08:30:41 发布
阅读量772 收藏 5
点赞数 1
分类专栏： 数据结构与算法 文章标签： 回溯算法 解空间 子集树 排列树 穷举法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43916755/article/details/128500593
版权

1 回溯算法

回溯算法具有通用性，但是算法的效率不高，通常可以通过剪枝等操作提高算法的效率。
算法思想：
在包含问题的所有解空间树中，按照深度优先搜索的策略，从根节点出发，深度搜索解空间树。当搜索到某一个节点时候，先判断该节点是否包含问题的解，如果包含就从该节点触发继续深度搜索下去，否则回溯；
解空间：
解空间就是所有解的可能取值构成的空间，一个解往往包含了得到这个解的每一步，往往就是对应解空间树中一条从根节点到叶子节点的路径。子集树和排列树都是一种解空间，它们不是真实存在的数据结构，也就是说并不是真的有这样一颗树，只是抽象出的解空间树。

1.1 解空间—子集树

子集树通常用于求某个问题的子集，涉及到子集的问题，看是否可以用子集树方式。

void func(int arr[], int i, int length,int x[])
{
	if (i == length)
	{
		for (int j = 0; j < length; j++)
		{
			if (x[j] == 1)
			{
				cout << arr[j] << " ";
			}
		}
		cout << endl;
	}
	else
	{
		x[i] = 1;  // 选择i节点
		func(arr, i + 1, length,x); // 遍历 i 的左孩子
		
		x[i] = 0; // 不选择i节点
		func(arr, i + 1, length,x); // 遍历i的右孩子
		//func(arr, i + 1, length); // 三叉树
	}
}

int main()
{
	int arr[] = { 1, 2, 3 };
	int length = sizeof(arr) / sizeof(arr[0]);
	int x[3] = { 0 };
	func(arr, 0, length,x);
	system("pause");
	return 0;
}

对代码的理解：

子集树中的两个循环，在逻辑上生成二叉树。
上面在递归过程中，一个节点（栈帧），向左递归标记为1，向右标记为0，打印时候，按照条件打印。
上边对递归左右走做一个标记，出来的就是子集树。算法时间复杂度，O(2^n)。

子集树总结

1 , 新开辟的栈帧中，从第一句代码开始执行；即使，第二句代码开辟的栈帧，仍然从新开辟的栈帧的第一句开始执行；
2 ， 回溯就是结束，回溯到上一个节点后，如果后边有语句，继续执行后边的语句；
3 ， 每一层栈帧中i节点相同，也就是层数相同。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.2 解空间— 排列树

排列树就是获取某个集合的全排列，比如求1 2 3这组数的全排列；
假如求1 2 3 全排列

void swap(int arr[], int i, int j)
{
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

void func(int arr[], int i, int length)
{
	if (i == length)
	{
		for (int j = 0; j < length; j++)
		{
			cout << arr[j] << " ";
		}
		cout << endl;
	}
	else
	{
		for (int k = i; k < length; k++)
		{
			swap(arr, i, k);
			func(arr, i + 1, length);
			swap(arr, i, k);
		}
	}
}

int main()
{
	int arr[] = { 1,2,3 };
	int length = sizeof(arr) / sizeof(arr[0]);

	func(arr, 0, length);

	system("pause");
	return -1;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 整数选择问题

整数选择：给定一组整数，从里面挑选出一组整数，让选择的整数的和 与 剩下的整数的和的差最小；

int min = 10000;
int result = 0;
int Xsum = 0;   //  记录选择的元素之和
int Ysum = 0;	//  记录没有选择的元素之和
void func(int arr[],int i,int length,int x[])
{
	if (i == length)
	{
		for (int j = 0; j < length; j++)
		{
			if (x[j] == 1)
			{
				
			}
			else
			{
				Ysum += arr[j];	// 记录未选择的元素之和
			}
		}
		result = abs(Xsum - Ysum);
		Xsum = 0;
		Ysum = 0;
		if (result <= min)
		{
			min = result;
		}
		cout << endl;
	}
	else
	{
		x[i] = 1;// 1 从当前节点向左走
		Xsum += arr[i];
		func(arr, i + 1, length,x);

		Ysum += arr[i];
		x[i] = 0;		// 2 回溯到父节点，然后从父节点向右走
		func(arr, i + 1, length,x);
	}
}

int main()
{
	int arr[] = { 12,6,7,11,16,3,8 };
	int length = sizeof(arr) / sizeof(arr[0]);
	int x[7] = { 0 };
	func(arr, 0, length,x);
	cout << "选择和剩下的整数之和为：" << min << endl;
	system("pause");
	return 0;
}

1.4 2N整数选择问题-加入剪枝操作

给2n个整数，从里面挑选出n个整数，让选择的整数的和 与 剩下的整数的和的差值最小;

int arr[] = { 12,6,7,11,16,3,5,23};
int length = sizeof(arr) / sizeof(arr[0]);
vector<int> bestM;		// 记录选择的最小值
vector<int> M;			// 记录子集中选择的元素 
unsigned int minval = 0xffffffff;
int sumR = 0;	// 记录数组中未被选择的元素之和
int sumS = 0;	// 记录选中的数组元素总和
int cnt = 0;  // 记录遍历的子集的个数
int left1 = length;
// 未加入剪枝操作
void func1(int i)
{
	if (i == length)
	{
		cnt++;
		if (M.size() != length / 2)
		{
			return;
		}

		int result = abs(sumS - sumR);
		if (result < minval)
		{
			minval = result;
			bestM = M;
		}
	}
	else
	{
		M.push_back(arr[i]);   // 记录选择的元素
		sumR -= arr[i];
		sumS += arr[i];
		func1(i + 1);
		// a
		cout << endl;
		sumS -= arr[i];
		sumR += arr[i];
		M.pop_back();

		func1(i + 1);
	}
}
// 加入剪枝操作 
void func(int i)
{
	if (i == length)
	{	
		cnt++;
		if (M.size() != length / 2)
		{
			return;
		}
	
		int result = abs(sumS - sumR);
		if (result < minval)
		{
			minval = result;
			bestM = M;
		}
	}
	else
	{
		left1--;
		if (M.size() < length / 2)   // 减左树枝，还未选择够n个整数
		{
			// 下面三行，递归做的事情
			M.push_back(arr[i]);   // 记录选择的元素
			sumR -= arr[i];
			sumS += arr[i];

			func(i + 1);
			// 回溯
			sumS -= arr[i];
			sumR += arr[i];
			M.pop_back();
		}
		// 右树枝可以选吗？已选择的数字的个数 + 未来能选择的所有数组个数(i+1,i+2,...i+n) >= n个元素
		//				   已选择的数字的个数 + 未来能选择的所有数组个数(i+1,i+2,...i+n) <= n个元素  则不执行 
		if (M.size() + left1 >= length / 2)
		{
			func(i + 1);
		}
		left1++;
	}
}

int main()
{
	// 计算出数组总和
	for (int v : arr)
	{
		sumR += v;
	}
	func(0);
	
	cout << "最小值" << minval << endl;
	for (int v : bestM)
	{
		cout << v << " ";
	}
	cout << endl;
	cout << "cnt:  " << cnt << endl;
	system("pause");
	return 0;
}

1.5 挑选一组数字，让他们的和等于指定的值

挑选数字：有一组整数，请挑选出一组数字，让他们的和等于指定的值，存在解打印，不存在打印

int arr[] = { 12,6,7,11,16,3,5,23 };
const int number = 34;
int length = sizeof(arr) / sizeof(arr[0]);
vector<int> x;  // 记录选择的数字
int sum = 0;	// 记录选择的数字之和
int r = 0;		// 记录未处理的数字的和

void func(int i)
{
	if (i == length)
	{
		if (sum != number)
		{
			return;
		}
		for (int v : x)
		{
			cout << v << " ";
		}
		cout << endl;

	}
	else
	{
		r -= arr[i];
		// 加入剪枝操作，减左枝:  如果已选择的数字的和 + 加上即将选择的的数字的和 < number 
		if (sum + arr[i] <= number)
		{
			sum += arr[i];		 // 记录所选数字之和
			x.push_back(arr[i]);
			func(i + 1);

			sum -= arr[i];		 // 减去右子树中的元素
			x.pop_back();
		}
		if (sum + r >= number)
		{
			func(i + 1);
		}

		r += arr[i];
	}
		
}

int main()
{
	for (int v : arr)
	{
		r += v;
	}

	func(0);
	// 计算出数组总和
	system("pause");
	return 0;
}

在这里插入图片描述

1.6 穷举法 （挑选数字）

穷举法和子集树的关系：穷举法所有的可能是子集树的子集；子集树能解决的问题，穷举法可能解决不了；
对代码的理解：
for的第一层 1 2 3 4 ；以1为确定的值第二层 2 3 4 ，以2为可能值的第2层，3,4；等等。
在这里插入图片描述

int arr[] = { 12,6,7,11,16,5,5,23 };
int number = 34;
int length = sizeof(arr) / sizeof(arr[0]);
vector<int> vec;  // 存放选择的数字

void func(int i, int number)
{
	if (number == 0)
	{
		for (int v : vec)
		{
			cout << v << " ";
		}
		cout << endl;
	}
	else
	{
		for (int k = i; k < length; k++)
		{
			if (number >= arr[k])// number大于下一个元素，比如number=8,下一个元素为13，不满足；如果下一个元素为3，number>=3，满足
			{
				vec.push_back(arr[k]);

				func(k + 1, number - arr[k]); // Andy: k+1这种方式表示不允许重复选择元素，只能遍历当前元素的孩子节点
				//func(k, number - arr[k]);// Andy: k这种方式表示允许重复选择元素，只能遍历当前元素的孩子节点

				vec.pop_back();
			}
		}
	}
}

int main()
{
	func(0,number);
	// 计算出数组总和
	system("pause");
	return 0;
}

1.7 0-1背包

有一组物理，其重量分别是w1 w2 w3,，其价值分别是v1 v2 ,vn，现在有一个背包，其容量是C,问怎么把物品装入背包，能够使背包的价值最大化。
解法：用子集树求解

int w[] = { 12,5,8,9,6 };  // 物品的重量
int v[] = { 9,2,4,7,8 };   // 物品的价值,物品和价值是一对一关系 
int C = 25;

const int length = sizeof(w) / sizeof(w[0]);

int cw = 0; // 已经选择的物品的重量；
int cv = 0; // 已经选择的物品的价值 

vector<int> x; // 记录已经选择的物品 
vector<int> bestx; // 记录最优解 
int bestv = 0;
int r = 0; // 记录剩余元素的总价值
int cnt = 0;

void func(int i)
{
	if (i == length)
	{
		cnt++;
		if (C == cw)
		{
			if (bestv < cv)
			{
				bestv = cv;
				bestx = x;
			}
		}

	}
	else
	{
		r -= v[i];
		// 开始加入剪枝操作,减左枝
		if (cw + w[i] <= C)  // 已选择物品重量 + 即将选择的物品重量，小于总容量再操作 
		{
			x.push_back(w[i]);
			cw += w[i];
			cv += v[i];

			func(i + 1);

			x.pop_back();
			cw -= w[i];
			cv -= v[i];
		}
		
		// 加入减右枝操作
		if (cv + r > bestv)
		{
			func(i + 1);
		}
		r += v[i];
	}
}

int main()
{

	for (int v : v)
	{
		r += v;
	}
	func(0);
	cout << "cnt" <<  cnt << endl;
	cout << "选择的物品重量为：";
	for (int w : bestx)
	{
		cout << w << " ";
	}
	cout << endl;
	cout << "最优值为：" << bestv << endl;

	system("pause");
	return 0;

}

1.8 排列树解决N-皇后问题

8*8的格子中，任意两个棋子不能出现在同一行，同一列，同一条斜线上。

int cnt = 0;
// 8皇后问题
bool judge(int arr[], int i)
{
	for (int j = 0; j < i; j++)
	{
		if (i == j || arr[i] == arr[j] || abs(i - j) == abs(arr[i] - arr[j]))
		{
			return false;
		}
	}
	return true;
}

// 
void swap(int arr[], int i, int j)
{
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

void func(int arr[], int i, int length)
{
	if (i == length)
	{
		cnt++;
		for (int j = 0; j < length; j++)
		{
			cout << arr[j] << " ";
		}
		cout << endl;
	}
	else
	{
		for (int k = i; k < length; ++k)
		{
			
			swap(arr, i, k);
			if (judge(arr, i))
			{
				func(arr, i + 1, length);   // 每次从上层遍历到下层的过程中，每向下一层，理解为选择每行每列的过程；
			}								// 遍历到第i层时候，都要判断0 -- i-1层，是否满足条件
			swap(arr, i, k);
		}
	}
}


int main()
{
	int arr[] = { 1,2,3,4 ,5,6,7,8};   // arr数组下标表示行，下标对应位置表示列；
	int n = 8;
	int length = sizeof(arr) / sizeof(arr[0]);
	func(arr, 0, length);

	cout << "cnt = " << cnt << endl;
	system("pause");
	return -1;
}

1.9 穷举法生成排列树

int arr[] = { 1,2,3 };
int length = sizeof(arr) / sizeof(arr[0]);
vector<int> vec;
int state[3] = { 0 };  // 1表示选择了，0表示未选择

void func(int i)
{
	if (i == length)
	{
		for (int v : vec)
		{
			cout << v << " ";
		}
		cout << endl;
	}
	else
	{
		for (int k = 0; k < length; ++k)
		{
			if (state[k] == 0)
			{
				state[k] = 1;
				vec.push_back(arr[k]);
				func(i + 1);
				vec.pop_back();
				state[k] = 0;
			}
		}
	}
}

int main()
{
	func(0);

	system("pause");
	return -1;
}

在这里插入图片描述

1.10穷举法func(k+1) 与 排列树中的fun(i+1)中，i 和 k区别？

穷举法中的k表示可选择的元素的起始下标，并且选择的数量不同，树的深度不同。
在这里插入图片描述
排列树中的i表示的是层数，排列树最后生成的是平衡树，树的深度相同。
在这里插入图片描述

weixin_43916755
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法学习笔记-11.回溯算法
chb414751843的博客
08-02 592
回溯算法学习
【数据结构与算法】——回溯法
weixin_46146755的博客
03-03 1218
回溯法在解决问题时的每一步都尝试所有可能的选项，最终找出所有可行的方案 回溯法非常适合解决由多个步骤组成的问题，并且每个步骤都有多个选项 在某一步选择了其中一个选项之后，就进入下一步，然后会面临新的选项 就这样重复选择，直至到达最终的状态 用回溯法解决问题的过程可以形象地用一个树形结构表示，求解问题的每个步骤可以看作树中的一个节点，如果在某一步有n个可能的选项，每个选项是树中的一条边，然后经过这些边就可以到达该节点的n个子节点 在采用回溯法解决问题时如果到达树形结构的叶节点，就找到了问题的一个解。 如果希.
数据结构 --- 回溯算法
jc15274630894的博客
08-02 686
数据结构 --- 回溯算法
算法：什么是回溯
OceanStar的博客
05-16 4749
回溯是递归的一种形式。 通常情况下，你会面临很多选择，你必须从中选择一个。在你做出选择后，你会得到一组新的选项；你得到的选择取决于你做出的选择。这个过程反复进行，直到达到最终状态。如果你做出了一系列正确的选择，你的最终状态就是目标状态；如果你没有，那就不是正确答案了 从概念上讲，你从树根开始，这棵树可能有一些叶子，这些叶子有可能是好的，又有可能是坏的。你要找到一片好叶子。 在每个节点上，从根节点开始，选择它的一个子节点进行移动，并一直这样做，直到到达叶节点。 假设你碰到一片坏叶子，通过撤销最近的选择，并尝
数据结构与算法（一）回溯
大漠帝国的博客
10-12 1223
数据结构与算法（一）回溯(backtrack) 回溯算法是对树形或者图形结构执行一次深度优先遍历，实际上类似枚举的搜索尝试过程，在遍历的过程中寻找问题的解。 深度优先遍历有个特点：当发现已不满足求解条件时，就返回，尝试别的路径。此时对象类型变量就需要重置成为和之前一样，称为「状态重置」。 许多复杂的，规模较大的问题都可以使用回溯法，有「通用解题方法」的美称。实际上，回溯算法就是暴力搜索算法，它是早期的人工智能里使用的算法，借助计算机强大的计算能力帮助我们找到问题的解。 回溯算法实际上一个类似枚举的搜索尝
五大常见算法策略之——回溯策略，算法数据结构
04-07
五大常见算法策略之——回溯策略，算法数据结构 五大常用算法
五大常用算法之回溯法，算法数据结构
04-07
五大常用算法之回溯法，算法数据结构 五大常用算法
五大常用算法：回溯算法，算法数据结构
04-07
五大常用算法：回溯算法，算法数据结构 五大常用算法
五大常用算法之回溯法详解及经典例题，算法数据结构
04-07
五大常用算法之回溯法详解及经典例题，算法数据结构 五大常用算法
五大常用经典算法—回溯算法，算法数据结构 五大常用算法
04-07
五大常用经典算法—回溯算法，算法数据结构 五大常用算法
N皇后问题 数据结构 用回溯法和栈解决 c++
12-21
N皇后问题 数据结构 用回溯法和栈解决 c++ 栈用的有点牵强 其实用一个数组记录就可以了 总共有92种摆法(8皇后)
算法设计与分析学习笔记（6）——排列树与子集树
qq_45976312的博客
04-14 5179
常见的解空间结构 1.子集树 概述：子集树是使用回溯法解题时经常遇到的一种典型的解空间树。当所给的问题是从n个元素组成的集合S中找出满足某种性质的一个子集时，相应的解空间树称为子集树。此类问题解的形式为n元组（x1,x2…xn），分量xi(1,2,…n)表示第i个元素是否在要找的子集中。xi的取值为0或者1，xi=0 表示第i个元素不在要找的子集中；xi=1 表示第i个元素在要找的子集中。 树的根结点：初始状态 中间结点：某种情况下的中间状态 叶子结点：结束状态 分支：从一个状态过渡到另一个状态的行为 从
【数据结构与算法（十）】——回溯法
OldBowl
05-19 1277
回溯法 C++引用与指针的区别
数据结构与算法--回溯的理解以及实现
lvguangaho的博客
06-20 2496
文章目录一、什么是回溯算法？二、如何实现回溯算法呢?三、总结 一、什么是回溯算法？ 回溯，也就是回退。举个例子，你从A地出发，要到B地去，但是从A地出发有多条路，在每条路上可能会遇到多条路口，回溯就是你先走其中一条路，比如路1，走完路1然后再回到A地，然后走路2，依次走剩下的路，直到走完所有的路。为了简单说明,只画了几个点辅助理解. 从A点出发时,前面有两条路,1号线和2号线,选择1号线出发,走完1号线所有的路再回来走2号线(当然,如果走1号线时满足了要求就不必回来了),选择1号线出发: 到达中间点M,
回溯算法详解
蛰伏神兽的专栏
03-06 5796
<br /><br />转自 ：http://zhuiqiuyongheng.zhaou.com.cn/20110112/44683.html<br /><br />回溯法是什么东西,<br /><br />回溯法(探索与回溯法)是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。<br /><br />一般表达<br />可用回溯法求解的问题P，通常要能表达
回溯法子集树和排列树
weixin_46147758的博客
07-24 3295
回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。 常用剪枝函数： 1、用约束函数在扩展结点处剪去不满足约束的子树； 2、用限界函数剪去得不到最优解的子树。 树状结构主要有如下两类：子集树和排列树； 1、装载问题（01背包问题） 问题描述： 有一批共n 个集装箱要装上艘载重量为c 的轮船，其中集装箱i 的重量为w.
C++实现：请编程实现：将两个两位数的正整数a, b合并成一个整数放在c中。合并的方式是：将a数的十位和个位依次放在c数的千位和十位上，b数的十位和个位数依次放在c数的百位和个位上。
热门推荐
weixin_43916755的博客
01-19 1万+
//【问题描述】请编程实现：将两个两位数的正整数a, b合并成一个整数放在c中。合并的方式是：将a数的十位和个位依次放在c数的千位和十位上，b数的十位和个位数依次放在c数的百位和个位上。 //【输入形式】输入2个2位的正整数，以空格隔开，以回车结束 //【输出形式】输出4位正整数 //【样例输入】12 34 //【样例输出】1324 //【样例输入】10 20 //【样例输出】1200 主要考察的...
算法与数据结构_计算两点之间的距离（欧氏距离）
weixin_43916755的博客
08-27 9315
距离公式： 在C++中实现时，用到了math.h文件中的pow(double x,double y)函数，这个函数的功能是求x的y次幂，例子如下： #include <iostream> #include <math.h> using namespace std; int main() { double x = 2, y = 8, z; z = pow(x, y);/...
数据结构与算法_求两个向量的夹角
weixin_43916755的博客
11-30 7787
已知两个非零向量，作在空间任取一点O，作，则称为向量的夹角，如下图当，两向量同向，否则等于180度两向量反向。 求两向量的公式为： C++代码如下： #include<iostream> #include<cmath> using namespace std; #define PI 3.141592653 int main() { float a[4];// 存放第一...
数据结构与算法基础（青岛大学-王卓
最新发布
08-26
数据结构与算法基础（青岛大学-王卓）是一个40个小时的教学视频系列，共有173集。该系列视频主要讲解了数据结构与算法的基础知识。如果你想学习这方面的知识，我建议你可以观看这个系列的教学视频。你可以在以下链接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值