lower_bound和upper_bound函数生成实例代码

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main() {
// 初始化一个vector
vector<int> v = {1, 3, 3, 3, 5, 7, 7, 9};

// lower_bound示例
int x = 3;
auto lb = lower_bound(v.begin(), v.end(), x);
if(lb != v.end() && *lb == x) {
cout << "找到了" << x << endl;
} else {
cout << "没找到" << endl;
}

// upper_bound示例
x = 7;
auto ub = upper_bound(v.begin(), v.end(), x);
if(ub != v.end()) {
cout << "找到了大于" << x << "的第一个数: " << *ub << endl;
} else {
cout << "没找到" << endl;
}

return 0;
}

相关问题

举一个分支限界法解决实际问题中含有上下界剪枝函数的代码实例

在分支限界法中，为了提高效率并避免探索不必要的解决方案，通常会利用上界（upper bound）和下界（lower bound）的概念进行剪枝。以下是一个简单的0-1背包问题的C++代码片段，展示了如何使用上下界进行剪枝[^1]：

#include <vector>
using namespace std;

// 上下界函数，这里假设物品的价值大于其重量
bool hasUpperBound(int weight, int value, vector<int>& items, int capacity, int ub) {
    double ratio = static_cast<double>(value) / weight;
    return ratio <= ub || (items.empty() && ratio <= static_cast<double>(capacity));
}

void branchAndBound(int capacity, const vector<int>& weights, const vector<int>& values, vector<vector<bool>>& solution) {
    // ...
    // 剪枝部分
    if (!hasUpperBound(totalWeight, totalValue, items, capacity, UB)) {
        return; // 如果当前路径的上界大于背包容量，直接剪枝
    }

    // ... (继续搜索)
}

在这个例子中，`hasUpperBound` 函数用于检查当前路径（由`weights`和`values`决定的一组物品组合）的上界是否小于等于背包容量。如果满足剪枝条件（即上界大于等于背包容量），则不会进一步探索这条路径。

粒子群算法的python代码实例

粒子群算法（Particle Swarm Optimization, PSO）是一种启发式优化算法，用于解决优化问题。下面是一个简单的粒子群算法的Python代码实例：

import numpy as np

# 定义目标函数（这里以求解最小值为例）
def objective_function(x):
    return x**2

# 粒子群算法类
class ParticleSwarmOptimization:
    def __init__(self, num_particles, num_dimensions, max_iterations, lower_bound, upper_bound):
        self.num_particles = num_particles  # 粒子数量
        self.num_dimensions = num_dimensions  # 维度数量
        self.max_iterations = max_iterations  # 最大迭代次数
        self.lower_bound = lower_bound  # 变量下界
        self.upper_bound = upper_bound  # 变量上界
        self.particles = np.random.uniform(low=self.lower_bound, high=self.upper_bound,
                                           size=(self.num_particles, self.num_dimensions))  # 初始化粒子位置
        self.velocities = np.zeros_like(self.particles)  # 初始化粒子速度
        self.best_positions = self.particles.copy()  # 最佳位置
        self.best_values = np.zeros(self.num_particles) + np.inf  # 最佳值
        self.global_best_position = None  # 全局最佳位置
        self.global_best_value = np.inf  # 全局最佳值

    # 更新粒子位置和速度
    def update(self):
        for i in range(self.num_particles):
            for j in range(self.num_dimensions):
                r1 = np.random.random()
                r2 = np.random.random()
                # 更新粒子速度
                self.velocities[i][j] = self.velocities[i][j] + 2 * r1 * (self.best_positions[i][j] - self.particles[i][j]) \
                                        + 2 * r2 * (self.global_best_position[j] - self.particles[i][j])
                # 限制粒子速度范围
                self.velocities[i][j] = np.maximum(self.velocities[i][j], self.lower_bound)
                self.velocities[i][j] = np.minimum(self.velocities[i][j], self.upper_bound)
                # 更新粒子位置
                self.particles[i][j] = self.particles[i][j] + self.velocities[i][j]
                # 限制粒子位置范围
                self.particles[i][j] = np.maximum(self.particles[i][j], self.lower_bound)
                self.particles[i][j] = np.minimum(self.particles[i][j], self.upper_bound)

    # 计算适应值
    def evaluate(self):
        for i in range(self.num_particles):
            fitness = objective_function(self.particles[i])
            if fitness < self.best_values[i]:
                self.best_values[i] = fitness
                self.best_positions[i] = self.particles[i]
            if fitness < self.global_best_value:
                self.global_best_value = fitness
                self.global_best_position = self.particles[i]

    # 执行粒子群算法
    def optimize(self):
        for _ in range(self.max_iterations):
            self.update()
            self.evaluate()

# 设置参数并运行粒子群算法
num_particles = 50  # 粒子数量
num_dimensions = 1  # 维度数量
max_iterations = 100  # 最大迭代次数
lower_bound = -10  # 变量下界
upper_bound = 10  # 变量上界

pso = ParticleSwarmOptimization(num_particles, num_dimensions, max_iterations, lower_bound, upper_bound)
pso.optimize()

# 输出结果
print("最优解:", pso.global_best_position)
print("最优值:", pso.global_best_value)

这个代码实例演示了如何使用粒子群算法求解一个简单的一维优化问题。你可以根据自己的需求，修改目标函数和参数设置来解决不同的优化问题。