目录
🍉概述
- 爬山算法（Hill Climbing Algorithm）是一种启发式搜索算法，用于寻找给定问题的局部最优解。它是一种贪婪算法，每一步都选择当前状态中最佳的邻居状态，直到不能再找到更好的邻居为止。
- 爬山算法通常用于优化问题中，如函数优化、路径规划等。尽管它可能会陷入局部最优解，但其简单性和有效性使得它在许多实际应用中得到广泛使用。
🍉 步骤
初始化：随机选择或者指定一个初始解作为起点。
评估：计算当前位置的解的价值或者成本，即目标函数的值。
邻域搜索：寻找当前位置的邻居解，即通过微小的变化产生相邻的解。
移动：选择最好的邻居解作为下一步的位置。如果该邻居解比当前解更优，则移动到该邻居解；否则算法停止，当前解即为局部最优解。
终止条件：根据特定条件判断是否达到停止搜索的条件，例如达到一定迭代次数、解的改进不显著等。
🍉 优缺点
🍈优点
简单易懂：爬山算法的概念和实现都非常简单，易于理解和编码。这使得它成为许多初学者和快速原型开发的首选算法。
计算效率高：由于每一步只需要比较有限的邻域解，爬山算法的单步计算速度较快，在搜索空间较小或结构较简单的问题上能快速收敛。
局部优化：在许多实际问题中，找到一个局部最优解已经可以满足需求。爬山算法擅长在局部区域内找到较好的解。
🍈缺点
容易陷入局部最优解：爬山算法很容易陷入局部最优解，而无法找到全局最优解。尤其是在复杂或具有多个局部最优解的问题上，这一缺点尤为明显。
缺乏全局视野：爬山算法没有跳出局部最优解的机制，因此在具有复杂地形（多峰）的搜索空间中，性能较差。
对初始解敏感：算法的最终结果依赖于初始解的选择，不同的初始解可能会导致不同的局部最优解。
不适用于大规模问题：对于大规模问题（如具有大量变量或复杂约束的优化问题），爬山算法的效果不佳，因为它无法有效探索大规模搜索空间。
🍈应对策略
为克服爬山算法的这些缺点，通常可以结合其他优化策略，如：
- 模拟退火算法（Simulated Annealing）：通过允许偶尔接受较差的解来跳出局部最优解。
- 遗传算法（Genetic Algorithm）：通过模拟自然选择和遗传变异的过程来探索更广阔的解空间。
- 禁忌搜索（Tabu Search）：通过记录最近访问过的解，避免重复搜索和陷入局部最优。
- 多次运行：多次运行爬山算法，每次使用不同的随机初始解，从而增加找到全局最优解的概率。
🍉示例
🍈旅行商问题
旅行商问题（TSP）是一个经典的组合优化问题，目标是在一组城市中找到最短的闭环路径，使得每个城市仅访问一次并最终回到起点城市。
🍍步骤
- 初始化：随机生成一个可行解，即生成一个随机的城市访问顺序。
- 评估：计算当前路径的总距离。
- 邻域搜索：生成当前路径的邻域解。邻域可以通过交换路径中的两个城市顺序、逆序某段路径等方式生成。
- 移动：选择邻域中距离最短的路径作为新的当前路径，如果新路径比当前路径更优，则移动到新路径；否则，算法停止。
- 终止条件：达到指定的迭代次数或没有更优的邻域解。
🍍分解代码
🍎包含头文件
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <climits>
using namespace std;
🍎定义函数（计算总距离）
double calculateTotalDistance(const vector<int>& solution, const vector<vector<double>>& distanceMatrix) {
double totalDistance = 0;
for (size_t i = 0; i < solution.size(); ++i) {
totalDistance += distanceMatrix[solution[i]][solution[(i + 1) % solution.size()]];
}
return totalDistance;
}
🍎生成初始解
vector<int> initialSolution(int numCities) {
vector<int> solution(numCities);
for (int i = 0; i < numCities; ++i) {
solution[i] = i;
}
random_shuffle(solution.begin(), solution.end());
return solution;
}
🍎生成邻域解
vector<vector<int>> getNeighbors(const vector<int>& solution) {
vector<vector<int>> neighbors;
for (size_t i = 0; i < solution.size(); ++i) {
for (size_t j = i + 1; j < solution.size(); ++j) {
vector<int> neighbor = solution;
swap(neighbor[i], neighbor[j]);
neighbors.push_back(neighbor);
}
}
return neighbors;
}
🍎爬山算法
pair<vector<int>, double> hillClimbing(const vector<vector<double>>& distanceMatrix, int maxIterations) {
int numCities = distanceMatrix.size();
vector<int> currentSolution = initialSolution(numCities);
double currentDistance = calculateTotalDistance(currentSolution, distanceMatrix);
for (int iteration = 0; iteration < maxIterations; ++iteration) {
vector<vector<int>> neighbors = getNeighbors(currentSolution);
vector<int> newSolution = currentSolution;
double newDistance = currentDistance;
for (const auto& neighbor : neighbors) {
double neighborDistance = calculateTotalDistance(neighbor, distanceMatrix);
if (neighborDistance < newDistance) {
newSolution = neighbor;
newDistance = neighborDistance;
}
}
if (newDistance < currentDistance) {
currentSolution = newSolution;
currentDistance = newDistance;
} else {
break;
}
}
return {currentSolution, currentDistance};
}
🍎主函数
int main() {
srand(time(0));
// 示例：城市间的距离矩阵
vector<vector<double>> distanceMatrix = {
{0, 29, 20, 21},
{29, 0, 15, 17},
{20, 15, 0, 28},
{21, 17, 28, 0}
};
int maxIterations = 1000;
auto result = hillClimbing(distanceMatrix, maxIterations);
vector<int> optimalPath = result.first;
double optimalDistance = result.second;
cout << "Optimal path: ";
for (int city : optimalPath) {
cout << city << " ";
}
cout << endl;
cout << "Total distance: " << optimalDistance << endl;
return 0;
}
🍍完整代码
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <climits>
using namespace std;
// 计算总距离函数
// 传入参数：solution（当前城市访问顺序），distanceMatrix（城市间距离矩阵）
// 返回值：当前路径的总距离
double calculateTotalDistance(const vector<int>& solution, const vector<vector<double>>& distanceMatrix) {
double totalDistance = 0;
for (size_t i = 0; i < solution.size(); ++i) {
// 计算从当前城市到下一个城市的距离（环形路径）
totalDistance += distanceMatrix[solution[i]][solution[(i + 1) % solution.size()]];
}
return totalDistance;
}
// 生成初始解函数
// 传入参数：numCities（城市数量）
// 返回值：随机生成的城市访问顺序
vector<int> initialSolution(int numCities) {
vector<int> solution(numCities);
for (int i = 0; i < numCities; ++i) {
solution[i] = i;
}
// 随机打乱城市访问顺序
random_shuffle(solution.begin(), solution.end());
return solution;
}
// 生成邻域解函数
// 传入参数：solution（当前城市访问顺序）
// 返回值：邻域解的集合（通过交换两个城市顺序生成）
vector<vector<int>> getNeighbors(const vector<int>& solution) {
vector<vector<int>> neighbors;
for (size_t i = 0; i < solution.size(); ++i) {
for (size_t j = i + 1; j < solution.size(); ++j) {
vector<int> neighbor = solution;
// 交换两个城市的顺序
swap(neighbor[i], neighbor[j]);
neighbors.push_back(neighbor);
}
}
return neighbors;
}
// 爬山算法函数
// 传入参数：distanceMatrix（城市间距离矩阵），maxIterations（最大迭代次数）
// 返回值：最优解及其对应的总距离
pair<vector<int>, double> hillClimbing(const vector<vector<double>>& distanceMatrix, int maxIterations) {
int numCities = distanceMatrix.size();
// 生成初始解
vector<int> currentSolution = initialSolution(numCities);
// 计算初始解的总距离
double currentDistance = calculateTotalDistance(currentSolution, distanceMatrix);
for (int iteration = 0; iteration < maxIterations; ++iteration) {
// 生成当前解的邻域解
vector<vector<int>> neighbors = getNeighbors(currentSolution);
vector<int> newSolution = currentSolution;
double newDistance = currentDistance;
// 寻找邻域中最优的解
for (const auto& neighbor : neighbors) {
double neighborDistance = calculateTotalDistance(neighbor, distanceMatrix);
if (neighborDistance < newDistance) {
newSolution = neighbor;
newDistance = neighborDistance;
}
}
// 如果找到更优解，更新当前解
if (newDistance < currentDistance) {
currentSolution = newSolution;
currentDistance = newDistance;
} else {
// 否则退出循环
break;
}
}
return {currentSolution, currentDistance};
}
int main() {
srand(time(0)); // 初始化随机数种子
// 示例：城市间的距离矩阵
vector<vector<double>> distanceMatrix = {
{0, 29, 20, 21},
{29, 0, 15, 17},
{20, 15, 0, 28},
{21, 17, 28, 0}
};
int maxIterations = 1000; // 最大迭代次数
auto result = hillClimbing(distanceMatrix, maxIterations); // 调用爬山算法
vector<int> optimalPath = result.first; // 最优路径
double optimalDistance = result.second; // 最优路径的总距离
// 输出最优路径
cout << "Optimal path: ";
for (int city : optimalPath) {
cout << city << " ";
}
cout << endl;
// 输出最优路径的总距离
cout << "Total distance: " << optimalDistance << endl;
return 0;
}
🍍代码说明
- 头文件：包含必要的头文件。
- 计算总距离：
calculateTotalDistance函数计算路径的总距离。- 生成初始解：
initialSolution函数生成一个随机的城市访问顺序。- 生成邻域解：
getNeighbors函数生成当前解的邻域解。- 爬山算法：
hillClimbing函数实现爬山算法，寻找旅行商问题的最优解。- 主函数：
main函数中定义了距离矩阵，并调用爬山算法找到最优路径和距离。
🍍代码分析
🍎时间复杂度分析
计算总距离函数 calculateTotalDistance
double calculateTotalDistance(const vector<int>& solution, const vector<vector<double>>& distanceMatrix)
- 该函数需要遍历路径中的所有城市，因此其时间复杂度为 O(n)，其中 n 是城市的数量。
生成初始解函数 initialSolution
vector<int> initialSolution(int numCities)
- 该函数需要初始化一个大小为 n 的向量，并对其进行随机打乱。初始化向量的时间复杂度为 O(n)，随机打乱的时间复杂度为 O(n)，因此总的时间复杂度为O(n)。
生成邻域解函数 getNeighbors
vector<vector<int>> getNeighbors(const vector<int>& solution)
- 该函数生成所有可能的邻域解，对于每对城市交换一次，生成一个新的邻域解。因此，其时间复杂度为O(n^2)。
爬山算法函数 hillClimbing
pair<vector<int>, double> hillClimbing(const vector<vector<double>>& distanceMatrix, int maxIterations)
该函数的主要步骤包括：
- 生成初始解，时间复杂度为 O(n)。
- 在每次迭代中：
- 生成邻域解，时间复杂度为 O(n^2)。
- 遍历邻域解并计算每个解的总距离，时间复杂度为 O(n^3)（每个邻域解计算距离为 O(n)，有 O(n^2) 个邻域解）。
- 迭代最多
maxIterations次。因此，爬山算法的总时间复杂度为 O(maxIterations×n^3)。
🍎空间复杂度分析
计算总距离函数 calculateTotalDistance
- 该函数使用常量空间，空间复杂度为 O(1)。
生成初始解函数 initialSolution
- 该函数返回一个大小为 n 的向量，因此空间复杂度为 O(n)。
生成邻域解函数 getNeighbors
- 该函数生成所有邻域解，最多有 O(n^2) 个邻域解，每个邻域解的大小为 n。因此，空间复杂度为 O(n^3)。
爬山算法函数 hillClimbing
- 该函数的主要空间开销来自：
- 因此，爬山算法的总空间复杂度为 O(n^3)。
- 初始解和当前解的存储，空间复杂度为 O(n)。
- 邻域解的存储，空间复杂度为 O(n^3)。
这些复杂度分析表明，爬山算法在解决旅行商问题时，对于较大的城市数量 �n 以及较高的迭代次数 maxIterations，可能会遇到计算和存储资源的限制。
🍉结论
- 爬山算法作为一种简单、快速的局部搜索优化算法，在解决一些中小规模问题时非常有效。然而，由于其容易陷入局部最优解且缺乏全局视野，在复杂或大规模优化问题上，需要结合其他优化策略以提升性能和解决问题的能力。
希望这些能对刚学习算法的同学们提供些帮助哦！！！
扫一扫
6765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
