目录
一，回溯算法
回溯算法 = DFS + 剪枝函数
不过这个结论也不绝对，并不能完全概括什么是回溯算法。
回溯和DFS的区别并不大，我理解DFS往往是无状态的，或者是单点状态的，而回溯是路径状态的。
二，大学实验
1. 编写一个简单的程序，解决8皇后问题。
#include<iostream>
using namespace std;
bool backtrack(int list[8], int t)
{
if (t >= 8)return true;
for (int i = 0; i < 8; i++)
{
list[t] = i;
bool place = true;
for (int j = 0; j < t; j++)if (list[j] == i || j-t==list[j]-i || j-t==i-list[j])place = false;
if (place && backtrack(list, t+1))return true;
continue;
}
return false;
}
int main()
{
int list[8];
for (int i = 0; i < 8; i++)list[i] = 0;
backtrack(list, 0);
for (int i = 0; i < 8; i++)cout << list[i] << " ";
system("pause>nul");
return 0;
}2. 批处理作业调度问题
[问题描述]给定n个作业的集合J=(J1, J2, … , Jn)。每一个作业Ji都有两项任务需要分别在2台机器上完成。每一个作业必须先由机器1处理，然后再由机器2处理。作业Ji需要机器j的处理时间为tji，i=1,2, … ,n; j=1,2。
对于一个确定的作业调度，设Fji是作业i在机器j上完成处理的时间。则所有作业在机器2上完成处理的时间和成为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业，制定一个最佳的作业调度方案，使其完成时间和达到最小。
要求输入：
1）作业数
2）每个作业完成时间表：
| 作业完成时间 | 机器1 | 机器2 |
| 作业1 | 2 | 1 |
| 作业2 | 3 | 1 |
| 作业3 | 2 | 3 |
要求输出： 1）最佳完成时间 2）最佳调度方案
提示：算法复杂度为O(n!),建议在测试的时候n值不要太大，可以考虑不要超过12。
<iostream>
using namespace std;
void backtrack(int *t1, int *t2, int *list1, int *list2, int *list, int &sumTime, int &time, int t, int n)
{
if (t >= n)
{
if (sumTime > time)sumTime = time;
return;
}
for (int i = 0; i < n; i++) //选择1个作业
{
bool place = true;
for (int j = 0; j < t; j++)if (list[j] == i)place = false; //判断这个作业是否可选
if (!place)continue;
list[t] = i;
if (t)t1[t] = t1[t - 1];
else t1[t] = 0;
t1[t] += list1[i];
if (t)t2[t] = (t1[t]>t2[t - 1]) ? t1[t] : t2[t - 1]; //这3行计算t2[i]
else t2[t] = t1[t];
t2[t] += list2[i];
time += t2[t];
if (time <= sumTime)backtrack(t1, t2, list1, list2, list, sumTime, time, t + 1, n);
time -= t2[t];
}
}
int main()
{
int n;
cin >> n;
int *list1 = new int[n]; //作业在机器1上运行的时间t11-t1n
int *list2 = new int[n]; //作业在机器2上运行的时间t21-t2n
int *t1 = new int[n]; //作业在机器1上完成的时间F11-F1n
int *t2 = new int[n]; //作业在机器2上完成的时间F21-F2n
int sumTime = 0; //总时间上界
for (int i = 0; i < n; i++)
{
cin >> list1[i] >> list2[i];
sumTime += (list1[i] + list2[i])*(i + 1);
}
int *list = new int[n]; //记录作业运行的顺序
int time = 0; //总时间
backtrack(t1, t2, list1, list2, list, sumTime, time, 0, n);
cout << sumTime << endl;
system("pause>nul");
return 0;
}
3. 数字全排列问题
任意给出从1到N的N个连续的自然数，求出这N个自然数的各种全排列。如N=3时，共有以下6种排列方式：123，132，213，231，312，321。
注意：数字不能重复，N由键盘输入（N<=9）。
<iostream>
using namespace std;
void backtrack(int n,int t,int *list)
{
if (t >= n)
{
for (int i = 0; i < n; i++)cout << list[i]+1 << " ";
cout << endl;
}
for (int i = 0; i < n; i++)
{
bool flag = true;
for (int j = 0; j < t; j++)if (list[j] == i)flag = false;
if (flag)
{
list[t] = i;
backtrack(n, t + 1, list);
}
}
}
int main()
{
int n;
cin >> n;
int list[9];
backtrack(n, 0, list);
system("pause>nul");
return 0;
}4，0-1背包问题
#include<iostream>
using namespace std;
int n, c, bestp; //物品的个数，背包的容量，最大价值
int p[80], w[80], x[80], bestx[80]; //物品的价值，物品的重量，x[i]暂存物品的选中情况,物品的选中情况
void Backtrack(int i, int cp, int cw)
{ //cw当前包内物品重量，cp当前包内物品价值
int j;
if (i>n)//回溯结束
{
if (cp>bestp)
{
bestp = cp;
for (i = 0; i <= n; i++) bestx[i] = x[i];
}
}
else
for (j = 0; j <= 1; j++)
{
x[i] = j;
if (cw + x[i] * w[i] <= c)
{
cw += w[i] * x[i];
cp += p[i] * x[i];
Backtrack(i + 1, cp, cw);
cw -= w[i] * x[i];
cp -= p[i] * x[i];
}
}
}
int _tmain(int argc, _TCHAR* argv[])
{
bestp = 0;
cout << "输入背包最大容量,物品个数,物品的重量,物品的价值\n";
cin >> c;
cin >> n;
for (int i = 1; i <= n; i++)cin >> w[i];
for (int i = 1; i <= n; i++)cin >> p[i];
Backtrack(1, 0, 0);
cout << "最大价值为:" << bestp;
printf("\n被选中的物品依次是\n");
for (int i = 1; i <= n; i++)if (bestx[i])cout << "第" << i << "个物品" << endl;
system("pause>nul");
return 0;
}三，OJ实战
N皇后问题
https://blog.csdn.net/nameofcsdn/article/details/126005334
力扣 797. 所有可能的路径
给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）
graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。
示例 1：
输入：graph = [[1,2],[3],[3],[]]
输出：[[0,1,3],[0,2,3]]
解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
示例 2：
输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
提示：
n == graph.length
2 <= n <= 15
0 <= graph[i][j] < n
graph[i][j] != i（即不存在自环）
graph[i] 中的所有元素 互不相同
保证输入为 有向无环图（DAG）
class Solution {
public:
void dfs(vector<vector<int>>& graph)
{
int k = path[path.size() - 1];
if (k == graph.size()-1) {
ans.push_back(path);
return;
}
for (auto i : graph[k]) {
path.push_back(i);
dfs(graph);
path.pop_back();
}
}
vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
ans.clear();
path.push_back(0);
dfs(graph);
return ans;
}
vector<int> path;
vector<vector<int>> ans;
};
力扣 2065. 最大化一张图中的路径价值
给你一张 无向 图，图中有 n 个节点，节点编号从 0 到 n - 1 （都包括）。同时给你一个下标从 0 开始的整数数组 values ，其中 values[i] 是第 i 个节点的 价值 。同时给你一个下标从 0 开始的二维整数数组 edges ，其中 edges[j] = [uj, vj, timej] 表示节点 uj 和 vj 之间有一条需要 timej 秒才能通过的无向边。最后，给你一个整数 maxTime 。
合法路径 指的是图中任意一条从节点 0 开始，最终回到节点 0 ，且花费的总时间 不超过 maxTime 秒的一条路径。你可以访问一个节点任意次。一条合法路径的 价值 定义为路径中 不同节点 的价值 之和 （每个节点的价值 至多 算入价值总和中一次）。
请你返回一条合法路径的 最大 价值。
注意：每个节点 至多 有 四条 边与之相连。
示例 1：
输入：values = [0,32,10,43], edges = [[0,1,10],[1,2,15],[0,3,10]], maxTime = 49 输出：75 解释： 一条可能的路径为：0 -> 1 -> 0 -> 3 -> 0 。总花费时间为 10 + 10 + 10 + 10 = 40 <= 49 。 访问过的节点为 0 ，1 和 3 ，最大路径价值为 0 + 32 + 43 = 75 。
示例 2：
输入：values = [5,10,15,20], edges = [[0,1,10],[1,2,10],[0,3,10]], maxTime = 30 输出：25 解释： 一条可能的路径为：0 -> 3 -> 0 。总花费时间为 10 + 10 = 20 <= 30 。 访问过的节点为 0 和 3 ，最大路径价值为 5 + 20 = 25 。
示例 3：
输入：values = [1,2,3,4], edges = [[0,1,10],[1,2,11],[2,3,12],[1,3,13]], maxTime = 50 输出：7 解释： 一条可能的路径为：0 -> 1 -> 3 -> 1 -> 0 。总花费时间为 10 + 13 + 13 + 10 = 46 <= 50 。 访问过的节点为 0 ，1 和 3 ，最大路径价值为 1 + 2 + 4 = 7 。
示例 4：
输入：values = [0,1,2], edges = [[1,2,10]], maxTime = 10 输出：0 解释： 唯一一条路径为 0 。总花费时间为 0 。 唯一访问过的节点为 0 ，最大路径价值为 0 。
提示：
n == values.length1 <= n <= 10000 <= values[i] <= 1080 <= edges.length <= 2000edges[j].length == 30 <= uj < vj <= n - 110 <= timej, maxTime <= 100[uj, vj]所有节点对 互不相同 。- 每个节点 至多有四条 边。
- 图可能不连通。
class Solution {
public:
int maximalPathQuality(vector<int>& values, vector<vector<int>>& edges, int maxTime) {
UndirectedGraphData<> g(edges);
map<int, bool>visit;
visit[0] = true;
dfs(values, g, visit, 0, maxTime, values[0]);
return ans;
}
void dfs(vector<int>& values, UndirectedGraphData<> &g, map<int, bool>&visit,int id, int t,int s)
{
if (t < 0)return;
if(id==0)ans = max(ans, s);
for (auto x : g.adjaList[id]) {
bool flag = visit[x];
visit[x] = true;
dfs(values, g, visit, x, t - g.edgeMap[make_pair(id, x)], s + (flag ? 0 : values[x]));
visit[x] = flag;
}
}
int ans = 0;
};
492
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
