梯级水库动态规划调度代码python

根据提供的引用内容，我找到了两种与梯级水库动态规划调度相关的Python代码实现。请参考以下两种方法：

方法一：基于粒子群算法的梯级水火电力优化调度研究[^1]

# 导入所需的库
import numpy as np

# 定义粒子群算法类
class PSO:
    def __init__(self, n, dim, max_iter):
        self.n = n  # 粒子数量
        self.dim = dim  # 粒子维度
        self.max_iter = max_iter  # 最大迭代次数
        self.c1 = 2  # 学习因子1
        self.c2 = 2  # 学习因子2
        self.w = 0.8  # 惯性权重
        self.X = np.random.uniform(0, 1, (n, dim))  # 粒子位置
        self.V = np.random.uniform(0, 1, (n, dim))  # 粒子速度
        self.pbest = self.X.copy()  # 个体最优位置
        self.gbest = self.pbest[np.argmax(self.fitness(self.pbest))]  # 全局最优位置

    # 适应度函数
    def fitness(self, X):
        return np.sum(X, axis=1)

    # 更新粒子位置和速度
    def update(self):
        for i in range(self.n):
            r1 = np.random.uniform(0, 1, self.dim)
            r2 = np.random.uniform(0, 1, self.dim)
            self.V[i] = self.w * self.V[i] + self.c1 * r1 * (self.pbest[i] - self.X[i]) + self.c2 * r2 * (self.gbest - self.X[i])
            self.X[i] = self.X[i] + self.V[i]
            self.X[i] = np.clip(self.X[i], 0, 1)
            if self.fitness(self.X[i]) > self.fitness(self.pbest[i]):
                self.pbest[i] = self.X[i]
            if self.fitness(self.pbest[i]) > self.fitness(self.gbest):
                self.gbest = self.pbest[i]

    # 粒子群算法主函数
    def optimize(self):
        for _ in range(self.max_iter):
            self.update()
        return self.gbest

# 示例调用
pso = PSO(n=10, dim=5, max_iter=100)
gbest = pso.optimize()
print("最优解：", gbest)

方法二：基于动态规划的水库优化调度[^2]

# 导入所需的库
import numpy as np

# 定义动态规划函数
def dynamic_programming(V, C, R):
    n = len(V)  # 阶段数
    m = len(V[0])  # 状态数
    dp = np.zeros((n, m))  # 动态规划表
    path = np.zeros((n, m), dtype=int)  # 最优路径表

    # 初始化第一阶段
    for i in range(m):
        dp[0][i] = V[0][i]

    # 动态规划过程
    for i in range(1, n):
        for j in range(m):
            max_value = -np.inf
            max_index = -1
            for k in range(m):
                value = dp[i-1][k] + C[i][j] - R[i][j][k]
                if value > max_value:
                    max_value = value
                    max_index = k
            dp[i][j] = max_value
            path[i][j] = max_index

    # 回溯最优路径
    optimal_path = []
    optimal_path.append(np.argmax(dp[-1]))
    for i in range(n-1, 0, -1):
        optimal_path.append(path[i][optimal_path[-1]])

    return dp[-1][-1], optimal_path[::-1]

# 示例调用
V = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  # 状态变量
C = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  # 成本
R = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]]  # 收益
max_value, optimal_path = dynamic_programming(V, C, R)
print("最大值：", max_value)
print("最优路径：", optimal_path)