木子识时务
木子识时务

算法导论 第 15 章：动态规划 (更新中)

github 项目地址
colab 查看

import imp
import random

15.0 序论

  • 动态规划与分治方法类似，都是通过组合子问题的解来求解原问题
    • 但动态规划适用于子问题重叠的情况，即不同的子问题具有公共的子子问题
  • 动态规划通常用来求解最优化问题
    • 通常求解的是问题的一个最优解，而不是最优解，因为最优解可能有多个
  • 通常按以下 4 个步骤来设计动态规划算法
    1. 刻划一个最优解的结构特征
    2. 递归的定义最优解的值
    3. 计算最优解的值，通常采用自底向上的方法
    4. 利用计算的信息构造出最优解

15.1 钢条切割问题

  • 问题描述
    • 给定一条长度为 的钢管和一个价格表 ，求使销售收益 最大的钢条切割方案
      • 如果长度为 英寸的钢条的价格 足够大，最优解可能是完全不需要切割

最优子结构

  • 对于 ，可以用更短的钢条的最优切割收益来描述：
      • 对应不切割
      • 其它方案对应先将钢条切割成 和 两段，接着求解这两段的最优切割收益 和
  • 钢条切割问题满足最优子结构的性质
    • 问题的最优解由相关子问题的最优解组合而成，而这些子问题可以独立求解
  • 简化子问题
    • 可以先将钢条从左边切下长度为 的一段，然后只对右边剩下的长度为 的钢条进行切割
      • 简化后，原问题的最优解只包含一个相关子问题的解，而不是两个

自底向下的递归实现

代码实现
%%writefile ch15/cut_rod.py
"""钢条切割问题"""

def cut_rod(p, n):
  if n == 0:
    return 0
  q = float('-inf')
  for i in range(1, n+1):
    q = max(q, p[i-1] + cut_rod(p, n-i))
  return q

Overwriting ch15/cut_rod.py

import ch15.cut_rod
from ch15.cut_rod import cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
cut_rod(p, 4)

10
复杂度分析
  • 时的调用过程
    • 长度为 的钢条切割共有 个节点，对应 种切割方案
      • 对于 处的切割点，可以选择切割或者不切割
  • 总的调用次数

使用动态规划方法求解最优钢条切割问题

  • 朴素的递归算法效率极低，因为其会反复求解相同的子问题。而动态规划方法会仔细安排求解顺序，对每个子问题只求解一次
  • 子问题的求解结果会被保存起来，下次再需要时，直接查询即可
    • 动态规划付出额外的内存空间来节省计算时间，是典型的时空权衡(time-memory trade-off)的例子
    • 动态规划在时间上的节省可能是非常巨大的
      • 可以将一个指数时间的解转化为一个多项式时间的解
  • 动态规划有两种等效的实现方法
    1. 带备忘录的自顶向下法(top-down with memoization)
    • 仍按递归的形式编写过程，但过程会保存每个子问题的解，当需要子问题的解时，过程会首先检查是否保存了此解。
    1. 自底向上法(bottom-up method)
    • 此方法需要恰当的定义子问题“规模”，使得任何子问题都只能依赖“更小的”子问题的求解
    • 可以将子问题按规模排序，按由小至大的顺序进行求解
    • 两种方法有相同的渐近运行时间，但在特殊情况下有差异
      • 自顶向下算法可能不用计算所有可能的子问题
      • 由于没有递归函数调用的开销，自底向上方法的时间复杂性函数通常具有更小的系数
带备忘录的自顶向下法的代码实现
%%writefile -a ch15/cut_rod.py



def memoized_cut_rod(p, n):
  """带备忘发的自顶向下法"""
  r = [float('-inf')] * (n+1)
  return memoized_cut_rod_aux(p, n, r)


def memoized_cut_rod_aux(p, n, r):
  """"带备忘录的自顶向下法的辅助函数"""
  if r[n] >=0:
    return r[n]
  if n == 0:
    q = 0
  else:
    q = float('-inf')
    for i in range(1, n+1):
      q = max(q, p[i-1] + memoized_cut_rod_aux(p, n-i, r))
  r[n] = q
  return q 

Appending to ch15/cut_rod.py

imp.reload(ch15.cut_rod)
from ch15.cut_rod import memoized_cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
memoized_cut_rod(p, 4)

10
自底向上法的代码实现
%%writefile -a ch15/cut_rod.py


def bottom_up_cut_rod(p, n):
  """自底向上法"""
  r = [float('-inf')] * (n + 1)
  r[0] = 0
  for i in range(1, n+1):
    q = float('-inf')
    for j in range(1, i+1):
      q = max(q, p[j-1] + r[i-j])
    r[i] = q
  return r[-1]


Appending to ch15/cut_rod.py

imp.reload(ch15.cut_rod)
from ch15.cut_rod import bottom_up_cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
bottom_up_cut_rod(p, 4)

10
复杂度分析
  • 自底向上算法和自顶向下算法具有相同的渐近运行时间，均为
子问题图
  • 思考动态规划问题时，应该弄清楚所涉及的子问题及子问题之间的依赖关系，可以借助子问题图来实现
  • 子问题图
    • 是一个有向图，每个顶点唯一地对应一个子问题
    • 若求子问题的最优解时需要直接用到子问题的最优解，那么在子问题图中就会有一条从子问题的顶点到子问题的顶点的有向边
      • 可以将子问题图看做自顶向下递归调用树的“简化版”或“收缩版”
        • 因为树中所有对应相同子问题的结点合并为图中的单一顶点，相关的所有边都从父结点指向子结点
    • 钢条切割问题的子问题图
  • 子问题图 的规模可以用来确定动态规划算法的运行时间
    • 每个子问题只求解一次，一个子问题的求解时间与子问题中对应顶点的度（出射边的数目） 成正比
    • 子问题的数目等于子问题中的顶点数
    • 因此，动态规划算法的运行时间与项点和边的数量呈线性关系
重构解
  • 可以扩展钢条切割的动态规划算法，使得对每个子问题，不仅保存最优收益值，还保存相应的切割方案
代码实现
%%writefile -a ch15/cut_rod.py



def extend_bottom_up_cut_rod(p, n):
  """保存最优切割方案"""
  r = [float('-inf')] * (n+1)  # 存放最优收益
  s = [0] * n  # 保留最佳切割方案
  r[0] = 0
  for i in range(1, n+1):
    for j in range(1, i+1):
      if r[i] < p[j-1] + r[i-j]:
        r[i] = p[j-1] + r[i-j]
        s[i-1] = j
  return r, s


def print_cut_rod(s, n=None):
  """打印出最佳切割方案"""
  n = len(s) - 1 if n == None else n
  while n >= 0:
    print(s[n], end=" ")
    n = n - s[n]

Appending to ch15/cut_rod.py

import ch15.cut_rod
imp.reload(ch15.cut_rod)
from ch15.cut_rod import print_cut_rod, extend_bottom_up_cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
_, s = extend_bottom_up_cut_rod(p, 7)
print_cut_rod(s)

1 6

练习

15.1-1

  • 可采用数学归纳法证明

    • 假设 时，
    • 则当 时，有
    • 证毕

15.1-2

  • 当 时，如果采用贪心法，方案为 3 + 1， 收益为 9。而最优方案为 2 + 2, 收益为 10

15.1-3

  • 切割成本为 ， 相当于需要添加选择成本
%%writefile -a ch15/cut_rod.py



def cut_rod_with_cost(p, n, c):
  """练习题 15.1-3，需要考虑切割成本"""
  r = [float('-inf')] * (n+1)
  s = [0] * n
  r[0] = c  # 避免后续判断是否需要加上切割成本
  for i in range(1, n+1):
    for j in range(1, i+1):
      t = p[j-1] + r[i-j] - c
      if t > r[i]:
        r[i] = t
        s[i-1] = j
  return r, s

Appending to ch15/cut_rod.py

import ch15.cut_rod
imp.reload(ch15.cut_rod)
from ch15.cut_rod import cut_rod_with_cost, print_cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
r, s = cut_rod_with_cost(p, 10, 1)

r[1:]

[1, 5, 8, 9, 12, 17, 17, 21, 24, 30]

s

[1, 2, 3, 2, 2, 6, 1, 2, 3, 10]

15.1-4

%%writefile -a ch15/cut_rod.py



def extend_memoized_cut_rod(p, n):
  """返回切割方案的带备忘发的自顶向下法"""
  r = [float('-inf')] * (n+1)
  s = [0] * n
  extend_memoized_cut_rod_aux(p, n, r, s)
  return r, s
  


def extend_memoized_cut_rod_aux(p, n, r, s):
  """"返回切割方案的带备忘录的自顶向下法的辅助函数"""
  if r[n] >=0:
    return r[n]
  if n == 0:
    q = 0
  else:
    q = float('-inf')
    for i in range(1, n+1):
      t = p[i-1] + extend_memoized_cut_rod_aux(p, n-i, r, s)
      if t > q:
        q = t
        s[n-1] = i
  r[n] = q
  return q 

Appending to ch15/cut_rod.py

import ch15.cut_rod
imp.reload(ch15.cut_rod)
from ch15.cut_rod import extend_memoized_cut_rod, print_cut_rod

p = [1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
r, s = extend_memoized_cut_rod(p, 7)
print("最优收益为： ", r[-1])
print("最优切割方案为")
print_cut_rod(s)

最优收益为：  18
最优切割方案为
1 6

15.1-5

  • 使用一张表储存前 个计算的斐波那契数即可

%%writefile ch15/fibonacci.py
def fibonacci(n):
  """使用动态规划法计算斐波那契数列"""
  if n == 0: return 0
  if n == 1: return 1
  r = [0] * (n+1)
  r[0], r[1] = 0, 1
  for i in range(2, n+1):
    r[i] = r[i-1] + r[i-2]
  return r[-1]

Overwriting ch15/fibonacci.py

from ch15.fibonacci import fibonacci
for i in range(11):
  print(fibonacci(i), end=" ")

0 1 1 2 3 5 8 13 21 34 55
  • 子问题图有 条边
    • 因为从 至 ， 每条边的度都为 2
  • 有 个顶点
  • 由边数和顶点数，可推得运行时间为

15.2 矩阵链乘法

  • 完全括号化的矩阵乘积链

    • 此矩阵乘积链要么是单一的矩阵，要么是两个完全括号化的矩阵乘积链的积
    • 如果矩阵链为 ， 则共有 5 种完全括号化的矩阵乘积链
      • \begin{aligned} &\left(A_{1}\left(A_{2}\left(A_{3} A_{4}\right)\right)\right)\\ &\left(A_{1}\left(\left(A_{2} A_{3}\right) A_{4}\right)\right)\\ &\left(\left(A_{1} A_{2}\right)\left(A_{3} A_{4}\right)\right)\\ &\left(\left(A_{1}\left(A_{2} A_{3}\right)\right) A_{4}\right)\\ &\left(\left(\left(A_{1} A_{2}\right) A_{3}\right) A_{4}\right) \end{aligned}

  • 矩阵乘法所需的乘法次数

    • 两个矩阵 只有相容，才能相乘
      • 相容是指 的列数等于 的行数
      • 设 为 的矩阵， 是 的矩阵，则 需要的标量乘法次数为

  • 矩阵链乘法问题

    • 给定 个矩阵的链 ，矩阵 的规模为 ，求完全括号化方案，使得计算乘积 所需要标量乘法次数最少

计算括号化方案的数量

  • 对 个矩阵的链，设 表示可供选择的括号化方案数量
  • 时，完全括号化的矩阵乘积可以描述成两个完全括号化的部分积相乘的形式，设划分点在第 个矩阵和第 个矩阵之间，其中 中的任意一个值，可得如下递推公式
    • 由思考题 12.4 可知，得到的结果为卡塔兰数，括号化方案数与 呈指数关系，暴力求解时间代价大

应用动态规划方法

1. 最优化括号方案的结构特征

  • 动态规划的第一步是寻找最优子结构

  • 对于矩阵链乘法问题，最优子结构如下：

    • 假设 的最优括号化方案的分割点在 和 之间。那么对 和 进行括号化，可以直接采用独立求解它们时所得的最优化方案

  • 利用最优子结构性质从子问题的最优解构造原问题的最优解

    • 一个非平凡的矩阵链乘法问题实例的任何解都需要划分链，而任何最优解都是由子问题实例的最优解构成的
    • 因此，可按下述步骤构造最优解
      1. 将问题划分为两个子问题（ 和 的最优括号化问题
      2. 求出子问题实例的最优解，然后将子问题的最优解组合起来
      • 必须保证在确定分割点时，已经考察了所有可能的划分点，这样就可以保证不会遗漏最优解。
2. 一个递归的求解方法
  • 用 表示 ， 用 表示计算 所需标量乘法次数的最小值。则原问题的最优解即等价于求解
  • 递归公式为：
  • 为了构造最优解，需要使用 来保存 的最优化括号方案的分割点位置
3. 计算最优代价
  • 计算 只用依赖于少于 个矩阵链相乘的最优计算代价
    • 因此，采用自底向上法求解时，应按长度递增的顺序求解矩阵链括号化问题
代码实现
%%writefile ch15/matrix_chain.py
""""矩阵链乘法的动态规划算法"""
def matrix_chain_order(p):
  """计算矩阵链乘法所需要的最少标量乘法"""
  length = len(p) - 1  # 矩阵链中矩阵的个数
  m = [[ 0 for i in range(length)] for j in range(length)]  # 存放 m[i, j] 的最优解
  s = [[ 0 for i in range(length-1)] for j in range(length-1)]  # 存放 m[i, j]（i < j）最优解对应的分割点 k , 其中 m[i, j] 对应的值存放在 s[i, j-1] 中
  for matrix_length in range(2, length+1):
    for i in range(1, length - matrix_length + 2):
      j = i + matrix_length - 1
      m[i-1][j-1] = float('inf')
      for k in range(i, j):
        q = m[i-1][k-1] + m[k][j-1] + p[i-1]*p[k]*p[j]
        if q < m[i-1][j-1]:
          m[i-1][j-1] = q
          s[i-1][j-2] = k
  return m, s

Overwriting ch15/matrix_chain.py

import ch15.matrix_chain
from ch15.matrix_chain import matrix_chain_order

p = [30, 35, 15, 5, 10, 20, 25]
m, s = matrix_chain_order(p)

m

[[0, 15750, 7875, 9375, 11875, 15125],
 [0, 0, 2625, 4375, 7125, 10500],
 [0, 0, 0, 750, 2500, 5375],
 [0, 0, 0, 0, 1000, 3500],
 [0, 0, 0, 0, 0, 5000],
 [0, 0, 0, 0, 0, 0]]

s

[[1, 1, 3, 3, 3],
 [0, 2, 3, 3, 3],
 [0, 0, 3, 3, 3],
 [0, 0, 0, 4, 5],
 [0, 0, 0, 0, 5]]

  • 运行过程分析

4. 构造最优解
  • 可以借助矩阵 中的信息，递归的输出最优化括号方案
%%writefile -a ch15/matrix_chain.py


def print_optimal_parents(s, i, j):
  """根据矩阵 s 中的信息，打印出最优化的括号方案"""
  if i == j:
    print("A{}".format(i), end="")
  else:
    print("(", end="")
    print_optimal_parents(s, i, s[i-1][j-2])
    print_optimal_parents(s, s[i-1][j-2]+1, j)
    print(")", end="")

Appending to ch15/matrix_chain.py

imp.reload(ch15.matrix_chain)
from ch15.matrix_chain import print_optimal_parents, matrix_chain_order

p = [30, 35, 15, 5, 10, 20, 25]
m, s = matrix_chain_order(p)
print_optimal_parents(s, 1, len(p)-1)

((A1(A2A3))((A4A5)A6))

练习

15.2-1

import ch15.matrix_chain
imp.reload(ch15.matrix_chain)
from ch15.matrix_chain import print_optimal_parents, matrix_chain_order

p = [5, 10, 3, 12, 5, 50, 6]
m, s = matrix_chain_order(p)
print_optimal_parents(s, 1, len(p)-1)

((A1A2)((A3A4)(A5A6)))

m[0][-1]

2010

15.2-2

%%writefile -a ch15/matrix_chain.py



def matrix_chain_multiply(A, s, i, j):
  """计算矩阵链的乘积"""
  if i == j:
    return A[i-1]
  l = matrix_chain_multiply(A, s, i, s[i-1][j-2])
  r = matrix_chain_multiply(A, s, s[i-1][j-2]+1, j)
  return [[ sum([l[i][k] * r[k][j] for k in range(len(l[0]))])  # 计算两个矩阵的乘积
        for j in range(len(r[0]))]
        for i in range(len(l))]


Appending to ch15/matrix_chain.py

import ch15.matrix_chain
imp.reload(ch15.matrix_chain)
from ch15.matrix_chain import print_optimal_parents, matrix_chain_order, matrix_chain_multiply

from functools import reduce
import numpy as np  # 利用 numpy 判断计算结果是否正确

p = [5, 10, 3, 12, 5, 50, 6]
A = []
for index, item in enumerate(p[:-1], 1):
  A.append(np.random.randint(0, 10, (item, p[index])))

m, s = matrix_chain_order(p)
(matrix_chain_multiply(A, s, 1, len(A)) == reduce(np.dot, A)).all()

True

15.2-3

  • 递推公式如下：

  • 由递推公式可得：

  • 假设 ， ，可得：

  • 证毕

15.2-4

  • 子问题图的顶点个数为:

  • 对于 的矩阵链，其需求解的子问题数为 ，所以包含的边数为：

    • \begin{aligned} \sum_{i=1}^{n}\sum_{j=i}^{n}{2(j-i)} &= n(n-1) + (n-1)(n-2) + \cdots + 2 * 1 \\ &= \sum_{i=1}^{n-1}{i(i+1) = {n(n-1)(n+1) \over 3}} && 此处可通过归纳法证明 \end{aligned}

  • 这些边连接一个问题所需要求解的子问题

15.2-5

  • 此问题的解即为问题 15.2-4 中的子问题图中的边的总数目

15.2-6

  • 可通过归纳法进行证明

  • 对于 ，不需要进行括号化，需要 对括号，符合要求

  • 假设 ，其完全括号化需要 对括号

  • 则当有 个元素时，在第 个元素添加括号，可得到完全括号化方案。则 有 对括号， 有 对括号，在 处分割会引入两对括号，由此可得需要的总括号对数为:

15.3 动态规划原理

最优子结构

  • 用动态规划方法求解问题的第一步即是刻画最优解的结构
  • 如果一个问题的最优解包含其子问题的最优解，就称此问题具有最优子结构的性质
  • 在发掘最优子结构性质的过程中，遵循如下的通用模式
    1. 证明问题最优解的第一个组成部分是作出一个选择，做出这个选择会产生一个或多个待解的子问题
    2. 对于一个给定问题，在其可能的第一步选择中，假定已经知道哪种选择才会得到最优解
    3. 给定可获得最优解的选择后，确定这次选择会产生哪些子问题，以及如何最好地刻画子问题空间
    4. 利用“剪切一粘贴”(cut-and-paste)技术证明：作为构成原问题最优解的组成部分，每个子问题的解就是它本身的最优解
    • 证明这一点是利用反证法：假定子问题的解不是其自身的最优解，那么就可以从原问题的解中“剪切”掉这些非最优解，将最优解“粘贴”进去，从而得到原问题一个更优的解，这与最初的解是原问题最优解的前提假设矛盾
    • 如果原问题的最优解包含多个子问题，通常它们都很相似，可以将针对一个子问题的“剪切一粘贴”论证方法稍加修改，用于其他子问题
  • 对于不同领域的问题，最优子结构主要体现在两个方面
    1. 原问题的最优解中涉及到多少个子问题
    2. 在确定最优解使用哪些子问题时，需要考察多少种选择
  • 由这两个方面，也可以初步确定算法的运行时间
    • 钢条切割问题有 个子问题，每个子问题有 种选择，因此总的运行时间为
    • 矩阵链乘法问题有 个子问题，每个子问题有 种选择，因此总运行时间为
  • 原问题最优解的代价通常等于其子问题最优解的代价再加上由于选择直接产生的代价
    • 钢条切割问题每次选择产生的代价为
    • 矩阵链乘法问题中，选择本身产生的代价为
  • 子问题需要是无关的，才能满足最优子结构
    • 子问题无关的含义是，同一个原问题的一个子问题的解不能影响另一个子问题的解
    • 子问题相关的实例： 无权最长简单路径

重叠子问题

  • 适合用动态规划方法求解的最优化问题应该具备的第二个性质是子问题的空间必须足够"小"，这样问题的递归算法会反复的求解相同的子问题，而不是一直生成新的子问题
  • 如果递归算法反复求解相同的子问题，就称最优化问题具有重叠子问题的性质
    • 动态规划算法通常对每个子问题求解一次，将解存入一个表中，当再次需要这个子问题时直接查表，每次查表的代价为常量时间。
  • 适合用分治方法求解的问题通常在递归的每一步都生成全新的子问题

重构最优解

  • 通常将每个子问题所做的选择存入一个表中，这样就可以重构最优解

备忘

  • 与自底向上的方法相比，可能不需要求解所有的子问题。但是递归调用会消耗额外的空间

练习题

15.3-1

  • RECURSIVE-MATRIX-CHAIN 方法较优

  • 对于 来说，假设 第 个元素是其最优的分割点

    • 对于穷举法来说，其需要遍历 和 的所有可能的分割方法，然后将左右两边所有可能
      的方法组合起来，得到最优的解。需要时间为
    • 对于递归法来说，其得到最优解只需对 和 中的最优结果进行组合即可，需要时间为

15.3-2

  • 递归调用树如下

  • 备忘技术对分治算法无效，主要是因为分治算法每步产生的子问题都是新的子问题，想互之间不重叠

15.3-3

  • 任然具有最优子结构的性质，假设 为 的最优分割点
  • 则 和 也需要为最大化矩阵序列括号化方案，才能得到总体的最大化矩阵序列括号化方案
    • 可以通过 "剪切-粘贴法" 进行证明

15.3-4

  • 设

  • 则按照题述的方法，最优的括号化方案为

    • 所需的乘法次数为

  • 完全括号化方案为

    • 所需的乘法次数为

15.3-5

  • 证明：
    • 左边钢条的切割方案会影响右边钢条的切割方案，两个子问题不再相互独立，因此最优子结构的性质不再成立

15.3-6

  • 佣金为

    • 设 是从 到 进行兑换时所需要经过的中间货币，为了达到最大的收益，则从 到 和从 到 的货币兑换也需要获得最大收益，才能满足要求
      • 可以通过“剪切-粘贴”法进行确认

  • 佣金 可能为任意值

    • 此时会导致当 为中间货币时，左右两边的子问题不再相互独立，而是可能相互影响，因此不一定再具有最优子结构的性质

15.4 最长公共子序列

  • 应用于 DNA 序列的相似度比较

相关概念

  • 子序列
    • 一个给定序列的子序列，就是将给定序列中的零个或多个元素去掉之后的结果
    • 形式化定义： 给定一个序列 ， 另一个序列 满足如下条件时称为 的子序列
      • 存在一个严格递增的 的下标序列 ，对于所有的 ，满足
  • 公共子序列
    • 如果 即是 的子序列，又是 的子序列，则称 是 和 的公共子序列
  • 最长公共子序列（longest-common-subsequence problem LCS），即是求两个序列 和 的长度最长的公共子序列

1. 刻画最长公共子序列的特征

  • LCS 的最优子结构
    • 令 和 为两个序列， 为 和 的任意 LCS
      1. 如果 ，则 且 是 和 的一个 LCS
      2. 如果 ，那么 意味着 是 和 的一个 LCS
      3. 如果 ，那么 意味着 是 和 的一个 LCS
    • 证明可以采用剪切-粘贴法

2. 一个递归解

  • 由 LCS 的最优子结构，可得如下性质
    • 表示 和 的 LCS 长度
    • 在递归公式中，通过限制条件限定了需要求解哪类子问题

3. 计算 LCS 的长度

  • 将 的值保存在表 ，并按行主次序计算表项
  • 为了构造最优解，维护另一个表项 ，其中 对应计算 时所选择的子问题的最优解
%%writefile ch15/lcs.py
"""最长公共子序列问题"""


def lcs_length(X, Y):
  """求两个序列的最长公共子序列"""
  m, n = len(X), len(Y)
  c = [[0]*(n+1) for i in range(m+1)]
  b = [[None]*n for i in range(m)]
  for i in range(1, m+1):
    for j in range(1, n+1):
      if X[i-1] == Y[j-1]:
        c[i][j] = c[i-1][j-1] + 1
        b[i-1][j-1] = '↖'
      elif c[i-1][j] >= c[i][j-1]:
        c[i][j] = c[i-1][j]
        b[i-1][j-1] = '↑'
      else:
        c[i][j] = c[i][j-1]
        b[i-1][j-1] = '←'
  return c, b

Overwriting ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length

X = ['A', 'B', 'C', 'B', 'D', 'A', 'B']
Y = ['B', 'D', 'C', 'A', 'B', 'A']
c, b = lcs_length(X, Y)

c

[[0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1],
 [0, 1, 1, 1, 1, 2, 2],
 [0, 1, 1, 2, 2, 2, 2],
 [0, 1, 1, 2, 2, 3, 3],
 [0, 1, 2, 2, 2, 3, 3],
 [0, 1, 2, 2, 3, 3, 4],
 [0, 1, 2, 2, 3, 4, 4]]

b

[['↑', '↑', '↑', '↖', '←', '↖'],
 ['↖', '←', '←', '↑', '↖', '←'],
 ['↑', '↑', '↖', '←', '↑', '↑'],
 ['↖', '↑', '↑', '↑', '↖', '←'],
 ['↑', '↖', '↑', '↑', '↑', '↑'],
 ['↑', '↑', '↑', '↖', '↑', '↖'],
 ['↖', '↑', '↑', '↑', '↖', '↑']]
  • 具体执行过程：

4. 构造 LCS

  • 可以根据表 中的信息，来构造出 LCS
    • 当在 中碰到一个 “↖” 时， 意味着碰到了 LCS 中的一个元素
%%writefile -a ch15/lcs.py


def print_LCS(b, X, i, j):
  """打印出最长公共子序列"""
  if i == 0 or j == 0:
    return
  if b[i-1][j-1] == '↖':
    print_LCS(b, X, i-1, j-1)
    print(X[i-1], end=" ")
  elif b[i-1][j-1] == '↑':
    print_LCS(b, X, i-1, j)
  else:
    print_LCS(b, X, i, j-1)

Appending to ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length, print_LCS

X = ['A', 'B', 'C', 'B', 'D', 'A', 'B']
Y = ['B', 'D', 'C', 'A', 'B', 'A']
c, b = lcs_length(X, Y)
print_LCS(b, X, len(X), len(Y))

B C B A

算法改进

  • 可以去掉表 ，因为在不改变渐近运行时间的前提上，借助表 也能判断出箭头的方向
    • 因为每个 只依赖于表 中的其他三项， ，可在在 的时间内判断出计算 时用到了这三项中的哪一个
    • 可以减小空间占用，但并未渐近的减少计算 LCS 所需的辅助空间
  • 如果不需要重构 LCS 序列，只需要保留表 中的两行即可（当前正在计算的一行和前一行）

练习

15.4-1

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length, print_LCS

X = [1, 0, 0, 1, 0, 1, 0, 1]
Y = [0, 1, 0, 1, 1, 0, 1, 1, 0]
c, b = lcs_length(X, Y)
print_LCS(b, X, len(X), len(Y))

1 0 0 1 1 0

15.4-2

%%writefile -a ch15/lcs.py



def print_LCS_without_b(c, X, Y, i, j):
  """15.4-2: 在没有表 b 的情况下输出最长公共子序列"""
  if i == 0 or j == 0:
    return
  if c[i][j] == c[i-1][j-1] + 1:
    print_LCS_without_b(c, X, Y, i-1, j-1)
    print(X[i-1], end=' ')
  elif c[i][j] == c[i-1][j]:
    print_LCS_without_b(c, X, Y, i-1, j)
  else:
    print_LCS_without_b(c, X, Y, i, j-1)

Appending to ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length, print_LCS_without_b

X = [1, 0, 0, 1, 0, 1, 0, 1]
Y = [0, 1, 0, 1, 1, 0, 1, 1, 0]
c, b = lcs_length(X, Y)
print_LCS_without_b(c, X, Y, len(X), len(Y))

1 0 1 0 1 1

15.4-3

%%writefile -a ch15/lcs.py



def memoized_lcs_length(X, Y):
  """15.4-3: 带备忘的 lcs 算法"""
  m, n = len(X), len(Y)
  c = [[None] * (n+1) for i in range(m+1)]
  b = [[None]* n for i in range(m)]
  memoized_lcs_length_aux(X, Y, len(X), len(Y), c, b)
  return c, b


def memoized_lcs_length_aux(X, Y, i, j, c, b):
  """带备忘的 lcs 算法的辅助函数"""
  if i == 0 or j == 0:
    return 0
  if X[i-1] == Y[j-1]:
    c[i][j] = 1 + memoized_lcs_length_aux(X, Y, i-1, j-1, c, b)
    b[i-1][j-1] = '↖'
  else:
    up = memoized_lcs_length_aux(X, Y, i-1, j, c, b)
    left = memoized_lcs_length_aux(X, Y, i, j-1, c, b)
    b[i-1][j-1], c[i][j] = ('↑', up) if up >= left else ('←', left)
  return c[i][j]

Appending to ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import memoized_lcs_length, print_LCS

X = ['A', 'B', 'C', 'B', 'D', 'A', 'B']
Y = ['B', 'D', 'C', 'A', 'B', 'A']
c, b = memoized_lcs_length(X, Y)
print_LCS(b, X, len(X), len(Y))

B C B A 

b

[['↑', '↑', '↑', '↖', None, None],
 ['↖', '←', '←', '↑', None, None],
 ['↑', '↑', '↖', '←', None, None],
 ['↖', '↑', '↑', '↑', '↖', None],
 [None, '↖', '↑', '↑', '↑', None],
 [None, None, None, '↖', None, '↖'],
 [None, None, None, None, '↖', '↑']]

c

[[None, None, None, None, None, None, None],
 [None, 0, 0, 0, 1, None, None],
 [None, 1, 1, 1, 1, None, None],
 [None, 1, 1, 2, 2, None, None],
 [None, 1, 1, 2, 2, 3, None],
 [None, None, 2, 2, 2, 3, None],
 [None, None, None, None, 3, None, 4],
 [None, None, None, None, None, 4, 4]]
  • 从 数组的值可看出，带备忘的算法并没有计算所有的子问题

15.4-4

  • 每次计算 时，只需要利用 这三个值即可，因此可以只储存之前一行和当前计算行的信息，便可完成计算

    • 所需表项的长度为
  • 设每行的元素数为 ，则按行主次序计算 时 与 之间相差 个元素，与 之间相差 个元素，与 之间相差 个元素
    • 由此可以使用一个长为 的队列，储存计算 所需要的信息
    • 实际程序编写时，需要注意一些边界条件
%%writefile -a ch15/lcs.py



from collections import deque


def lcs_length_queue(X, Y):
  """15.4-4: 借助队列来减小表项所需的额外空间"""
  m, n = len(X), len(Y)
  if m < n:
    m, n = n, m
    X, Y = Y, X
  dq = deque(maxlen=n)
  a = 0  # 初始时的 c[i-1][j-1]
  for i in range(m):
    for j in range(n):
      if X[i] == Y[j]:
        b = a + 1  if j != 0 else 1 # b 为 c[i][j]
        a = dq.popleft() if i != 0 else 0 # 下一次循环时的 c[i-1][j-1]
        dq.append(b)
      else:
        a = dq.popleft() if i != 0 else 0 # 此次循环的 c[i-1][j], 下一次循环的 c[i-1][j-1]
        d = dq[-1] if j != 0 else 0 # c[i][j-1]
        dq.append(max(a, d))
  return dq[-1]

Appending to ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length_queue

X = ['A', 'B', 'C', 'B', 'D', 'A', 'B']
Y = ['B', 'D', 'C', 'A', 'B', 'A']
lcs_length_queue(X, Y)

4

X = [1, 0, 0, 1, 0, 1, 0, 1]
Y = [0, 1, 0, 1, 1, 0, 1, 1, 0]
lcs_length_queue(X, Y)

6

15.4-5

  • 设序列为 ，将 中的元素按递增的顺序排列得到序列 ， 则 与 的最大公共子序列即为 中最长的单调递增子序列

%%writefile -a ch15/lcs.py



def longest_increasing_subsequence_by_LCS(X):
  """15.4-5: 在 O(n^2) 的时间内求一个序列的最长单调递增子序列"""
  Y = sorted(X)  
  c, b = memoized_lcs_length(X, Y)
  print_LCS(b, X, len(X), len(Y))

Appending to ch15/lcs.py

import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import longest_increasing_subsequence_by_LCS

X = list(range(10))
random.shuffle(X)
print(X, "中的最长单调递增子序列为： ")
longest_increasing_subsequence_by_LCS(X)

[8, 5, 7, 4, 1, 2, 6, 9, 3, 0] 中的最长单调递增子序列为： 
1 2 6 9

15.4-6

  • 提示描述的有问题，应为：

    • 长度为 的子序列中的最小尾元素至少不小于长度为 的候选子序列的尾元素
    • 证明可通过反证法实现

  • 算法描述

    • 可构造一个长度为 的序列 ，初始时所有元素均赋值为 ， 为待求解序列 的长度
      • 表示长度为 的单调递增序列中最小的尾元素
    • 依次遍历 中的元素, 第 ()次遍历时
      • 如果 ，则令
      • 否则，借助二分法查找最大的 ，使得 ， 进行赋值操作
      • 此时，可证明 是 中长度为 的单调递增序列中的最小尾元素
    • 中不为 的元素数量，即为最长单调递增子序列的长度，设最长长度为
    • 构造最长单调递增子序列
      • 在 的未尾追加一个元素
      • 令 ，逆序遍历 中的元素
        • 找出一个元素 满足 ，然后将 自减 ，继续遍历，直至 为
          • 如果 中包含长度为 的单调递增序列，则其也一定包含长度为 的递增序列，由此性质可知 一定存在
      • 将遍历得到的元素逆序输出，即为一个最长单调递增子序列
%%writefile ch15/longest_increasing_subsequence.py



from bisect import bisect

def longest_increasing_subsequence(X):
  """15.4-6: 在 O(nlgn) 的时间内求解一个序列的最长单调递增子序列"""
  s = [float('inf')] * len(X)
  L = 0  # s 中非 inf 的元素数目
  for i in range(len(X)):
    j = bisect(s, X[i])
    s[j] = X[i]
    if j + 1 > L:
      L = j + 1
  res = [None] * L
  k = len(X)
  s.append(float('inf'))
  for i in reversed(range(L)):
    while k > 0:
      k -= 1
      if s[i+1] >= X[k] >= s[i]:
        res[i] = X[k]
        break
  return res

Overwriting ch15/longest_increasing_subsequence.py

import ch15.longest_increasing_subsequence
imp.reload(ch15.longest_increasing_subsequence)
from ch15.longest_increasing_subsequence import longest_increasing_subsequence

X = list(range(10))
random.shuffle(X)
# X = [1, 2, 3, 4, 1, 2, 5, 4]
print(X, "中的最长单调递增子序列为： ", longest_increasing_subsequence(X))

[0, 4, 7, 2, 3, 5, 9, 8, 6, 1] 中的最长单调递增子序列为：  [0, 2, 3, 5, 6]

15.5 最优二叉搜索树

  • 实际应用： 英语到法语的翻译

最优二叉搜索树的问题描述

  • 给定 个不同关键字的已排序序列 ， 希望用这些关键字构造一棵二叉搜索树
    • 对于每一个关键字 ，都有一个概率 表示其搜索频率
  • 有些要搜索的值可能不在 中， 因此还有 个 “伪关键字” 表示不在 中的值
    • 表示所有小于 的值， 表示所有大于 的值
    • 表示所有在 和 之间的值
    • 对于每一个 ，也都有一个概率 表示其搜索频率
  • 每次搜索要么成功，要么失败，有下式成立：
  • 示例
  • 在树 中进行一次搜索的期望代价为
    • \begin{aligned} \mathrm{E}[\text { search cost in } T] &=\sum_{i=1}^{n}\left(\operatorname{depth}_{T}\left(k_{i}\right)+1\right) \cdot p_{i}+\sum_{i=0}^{n}\left(\operatorname{depth}_{T}\left(d_{i}\right)+1\right) \cdot q_{i} \\ &=1+\sum_{i=1}^{n} \operatorname{depth}_{T}\left(k_{i}\right) \cdot p_{i}+\sum_{i=0}^{n} \operatorname{depth}_{T}\left(d_{i}\right) \cdot q_{i} \end{aligned}
    • 从图中可看出，最优二叉搜索树不一定是最矮的，概论最高的关键字也不一定出现在根结点
  • 对于一个给定的概率集合，希望构建一颗期望代价最小的二叉搜索树，称之为最优二叉搜索树

1. 最优二叉搜索树的结构

  • 子树的特征
    • 一棵二叉搜索树 的任意子树必须包含连续关键字 ，而且其叶结点必然是伪关键字
  • 最优子结构
    • 如果一棵最优的二叉搜索树 有一棵包含 的子树 , 那么 必然是包含关键字 和伪关键字 的子问题的最优解
    • 证明可采用剪切-粘贴法
  • 空子树
    • 对于包含关键字 的子问题
      • 如果选定 为根结点， 的左子树不包含任何实际关键字，只包含单一伪关键字
      • 如果选定 为根结点，则 的右子村不包含任何实际关键字，只包含单一伪关键字

2. 递归算法

  • 对于包含关键字 的子树，所有的概率之和为：
  • 若 为包含关键字 的最优二叉搜索树的根结点，可得
      • 代入： 可得：
  • 由此可得计算 的递推公式为

3. 计算最优二叉搜索树的期望搜索代价

  • 用表 来保存 的值
    • 对应的数组下标不同，因为还要计算空子树的值
  • 用表 来储存包含关键字 的最优二叉搜索树的根
  • 可以用另外一张表 来储存 的值，可按下式加速计算 
%%writefile ch15/optimal_bst.py
""""计算最优二叉搜索树"""


def optimal_bst(p, q):
  n = len(p)
  e = [[ q[i-1] if (i-1) == j else float('inf') for i in range(1, n+2)] for j in range(n+1)]
  w = [[ q[i-1] if (i-1) == j else 0 for i in range(1, n+2)] for j in range(n+1)]
  root = [[0] * n for i in range(n)]
  for l in range(1, n+1):
    for i in range(1, n-l+2):
      j = i + l - 1
      w[i-1][j] = w[i-1][j-1] + p[j-1] + q[j]
      for k in range(i, j+1):
        t = e[i-1][k-1] + e[k][j] + w[i-1][j]
        if t < e[i-1][j]:
          e[i-1][j] = t
          root[i-1][j-1] = k
  return e, root

Overwriting ch15/optimal_bst.py

import ch15.optimal_bst
imp.reload(ch15.optimal_bst)
from ch15.optimal_bst import optimal_bst

p = [0.15, 0.10, 0.05, 0.10, 0.20]
q = [0.05, 0.10, 0.05, 0.05, 0.05, 0.10]
e, root = optimal_bst(p, q)

e

[[0.05, 0.45000000000000007, 0.9, 1.25, 1.75, 2.75],
 [inf, 0.1, 0.4, 0.7, 1.2, 2.0],
 [inf, inf, 0.05, 0.25, 0.6, 1.2999999999999998],
 [inf, inf, inf, 0.05, 0.30000000000000004, 0.9],
 [inf, inf, inf, inf, 0.05, 0.5],
 [inf, inf, inf, inf, inf, 0.1]]

root

[[1, 1, 2, 2, 2],
 [0, 2, 2, 2, 4],
 [0, 0, 3, 4, 5],
 [0, 0, 0, 4, 5],
 [0, 0, 0, 0, 5]]
  • 运行过程分析

复杂度分析

  • 最优二叉搜索树的运行过程与矩阵链乘法基本相同，时间复杂度也为

练习

15.5-1

  • 相当于中序遍历

%%writefile -a ch15/optimal_bst.py



def construct_optimal_bst(root):
  """15.5-1: 构造最优二叉搜索树"""
  m, n = len(root), len(root[0])
  print("k{} 为根".format(root[0][n-1]))
  construct_optimal_bst_aux(root, 1, n)


def construct_optimal_bst_aux(root, i, j):
  """构造最优二叉搜索树的辅助函数"""
  r = root[i-1][j-1]
  if i == j:
    print("d{} 为 k{} 的左孩子".format(r-1, r))
    print("d{} 为 k{} 的右孩子".format(r, r))
    return
  if i == r:
    print("d{} 为 k{} 的左孩子".format(r-1, r-1))
  else:
    print("k{} 为 k{} 的左孩子".format(root[i-1][r-2], r))
    construct_optimal_bst_aux(root, i, r-1)
  if j == r:
    print("d{} 为 d{} 的右孩子".format(r, r))
  else:
    print("k{} 为 k{} 的右孩子".format(root[r][j-1], r))
    construct_optimal_bst_aux(root, r+1, j)

Appending to ch15/optimal_bst.py

import ch15.optimal_bst
imp.reload(ch15.optimal_bst)
from ch15.optimal_bst import optimal_bst, construct_optimal_bst

p = [0.15, 0.10, 0.05, 0.10, 0.20]
q = [0.05, 0.10, 0.05, 0.05, 0.05, 0.10]
e, root = optimal_bst(p, q)
construct_optimal_bst(root)

k2 为根
k1 为 k2 的左孩子
d0 为 k1 的左孩子
d1 为 k1 的右孩子
k5 为 k2 的右孩子
k4 为 k5 的左孩子
k3 为 k4 的左孩子
d2 为 k3 的左孩子
d3 为 k3 的右孩子
d4 为 d4 的右孩子
d5 为 d5 的右孩子

15.5-2

import ch15.optimal_bst
imp.reload(ch15.optimal_bst)
from ch15.optimal_bst import optimal_bst, construct_optimal_bst

p = [0.04, 0.06, 0.08, 0.02, 0.10, 0.12, 0.14]
q = [0.06, 0.06, 0.06, 0.06, 0.05, 0.05, 0.05, 0.05]
e, root = optimal_bst(p, q)
print("期望代价为：", e[0][-1])

期望代价为： 3.12

construct_optimal_bst(root)

k5 为根
k2 为 k5 的左孩子
k1 为 k2 的左孩子
d0 为 k1 的左孩子
d1 为 k1 的右孩子
k3 为 k2 的右孩子
d2 为 k2 的左孩子
k4 为 k3 的右孩子
d3 为 k4 的左孩子
d4 为 k4 的右孩子
k7 为 k5 的右孩子
k6 为 k7 的左孩子
d5 为 k6 的左孩子
d6 为 k6 的右孩子
d7 为 d7 的右孩子

15.5-3

  • 公式 (15.12) 如下：

  • 每次计算的时间代价为 ，因此不会影响渐近时间复杂性

15.5-4

代码实现
%%writefile -a ch15/optimal_bst.py



def improved_optimal_bst(p, q):
  """15.5-4: 改进最优二叉搜索树算法"""
  n = len(p)
  e = [[ q[i-1] if (i-1) == j else float('inf') for i in range(1, n+2)] for j in range(n+1)]
  w = [[ q[i-1] if (i-1) == j else 0 for i in range(1, n+2)] for j in range(n+1)]
  root = [[0] * n for i in range(n)]
  for l in range(1, n+1):
    for i in range(1, n-l+2):
      j = i + l - 1
      w[i-1][j] = w[i-1][j-1] + p[j-1] + q[j]
      if i != j:
        r = range(root[i-1][j-2], root[i][j-1])  # 利用相关的结论
      else:
        r = range(i, j+1)
      for k in range(i, j+1):
        t = e[i-1][k-1] + e[k][j] + w[i-1][j]
        if t < e[i-1][j]:
          e[i-1][j] = t
          root[i-1][j-1] = k
      
  return e, root

Appending to ch15/optimal_bst.py

import ch15.optimal_bst
imp.reload(ch15.optimal_bst)
from ch15.optimal_bst import improved_optimal_bst

p = [0.15, 0.10, 0.05, 0.10, 0.20]
q = [0.05, 0.10, 0.05, 0.05, 0.05, 0.10]
e, root = improved_optimal_bst(p, q)

e

[[0.05, 0.45000000000000007, 0.9, 1.25, 1.75, 2.75],
 [inf, 0.1, 0.4, 0.7, 1.2, 2.0],
 [inf, inf, 0.05, 0.25, 0.6, 1.2999999999999998],
 [inf, inf, inf, 0.05, 0.30000000000000004, 0.9],
 [inf, inf, inf, inf, 0.05, 0.5],
 [inf, inf, inf, inf, inf, 0.1]]

root

[[1, 1, 2, 2, 2],
 [0, 2, 2, 2, 4],
 [0, 0, 3, 4, 5],
 [0, 0, 0, 4, 5],
 [0, 0, 0, 0, 5]]
复杂度分析
  • 第 2 层循环所有的时间代价为 ，因为修改后的第三层循环，互不重叠
    • 假设 不变，此次循环，第三层循环的界为
    • 下次循环时， 均增加 ，第三层循环的下界为
    • 由于 的值在 之间，因此第二层循环的时间复杂度为
  • 由此可得整体的运行时间减为

思考题

15-1 有向无环图中的最长简单路径

  • 涉及到图论的相关知识，学完图后再回来补

  • 参考资料

15-2 最长回文子序列

借助 LCS 算法

  • 一种方式是直接借助 LCS 算法
    • 设待求的序列为 ，其逆序序列为 ，则 的 LCS 即为 中的最长回文子序列
  • 设 的长度为 ，则此算法的时间复杂度为 
import ch15.lcs
imp.reload(ch15.lcs)
from ch15.lcs import lcs_length, print_LCS

X = 'character'
Y = X[::-1]
c, b = lcs_length(X, Y)
print_LCS(b, X, len(X), len(Y))

c a r a c

针对本问题的动态规划算法

  • 如果要求序列 的最长回文字序列，可以借助 的最长回文序列来确定，具体如下：
    • c[i, j] = \left\{ \begin{aligned} &A[i] &&& if\ i == j\\ &A[i] + c[i+1, j-1] +A[j] &&& if\ i \neq j \ and \ A[i] == A[j]\\ &c[i+1, j]， c[i, j-1] 中的最长子序列 &&& if\ i \neq j \ and \ A[i] \neq A[j] \end{aligned} \right.
      • 表示 的最长回文子序列
储存 最长回文子序列
%%writefile ch15/longest_palindrome_subsequence.py
"""15-2 最长回文子序列"""


def longest_palindrome_subsequence(X):
  """空间复杂度为 O(n^3)"""
  n = len(X)
  c = [['' if i!=j else X[i] for j in range(n)] for i in range(n)]
  for l in range(2, n+1):
    for i in range(1, n-l+2):
      j = i + l - 1
      if X[i-1] == X[j-1]:
        c[i-1][j-1] = X[i-1] + c[i][j-2] + X[j-1]
      else:
        c[i-1][j-1] = c[i][j-1] if len(c[i][j-1]) > len(c[i-1][j-2]) else c[i-1][j-2]
  return c[0][n-1]

Overwriting ch15/longest_palindrome_subsequence.py

import ch15.longest_palindrome_subsequence
imp.reload(ch15.longest_palindrome_subsequence)
from ch15.longest_palindrome_subsequence import longest_palindrome_subsequence

X = 'character'
longest_palindrome_subsequence(X)

'carac'
  • 此种算法，时间复杂度为
  • 由于 的长度最大为 ，所以空间复杂度为 ，占用空间较大，可进一步优化
储存 的最长子序列的长度，然后根据 的信息重构生成最长回文子序列
  • 此时 的计算公式如下：
    • c[i, j] = \left\{ \begin{aligned} &1 &&& if\ i == j\\ &c[i+1, j-1] + 2 &&& if\ i \neq j \ and \ A[i] == A[j]\\ &max(c[i+1, j], c[i, j-1]) &&& if\ i \neq j \ and \ A[i] \neq A[j] \end{aligned} \right.
%%writefile -a ch15/longest_palindrome_subsequence.py



def improved_longest_palindrome_subsequence(X):
  """空间复杂度为 O(n^2)"""
  n = len(X)
  c = [[0 if i!=j else 1 for j in range(n)] for i in range(n)]

  # 计算 c 的值
  for l in range(2, n+1):
    for i in range(1, n-l+2):
      j = i + l - 1
      if X[i-1] == X[j-1]:
        c[i-1][j-1] = c[i][j-2] + 2
      else:
        c[i-1][j-1] = max(c[i][j-1], c[i-1][j-2])

  # 重构最长的回文子序列
  i, j = 1, n
  res = ''
  while i < j:
    if X[i-1] == X[j-1]:
      res = X[i-1] + res
      i += 1
      j -= 1
    elif c[i][j-1] > c[i-1][j-2]:
      i += 1
    else:
      j -= 1
  return res[::-1] + X[i-1] + res if i == j else res[::-1] + res

Appending to ch15/longest_palindrome_subsequence.py

import ch15.longest_palindrome_subsequence
imp.reload(ch15.longest_palindrome_subsequence)
from ch15.longest_palindrome_subsequence import improved_longest_palindrome_subsequence

X = 'character'
improved_longest_palindrome_subsequence(X)

'carac'
  • 重构最长回文子序列的时间复杂度为 ，因此程序总体的时间复杂度仍为 ，但是空间复杂度降低到

15-3 双调欧几里得旅行商问题

  • 将 个点按 轴坐标进行排序， 表示排序后第 个位置的坐标点

  • 表示第一条路线的终点为 ， 第二条路线的终点为 时，巡游路线的最小值， 由于两条路线的对称性，不妨设

  • 时， 可按以下递推式求得：

    • d[i, j] = \left\{ \begin{aligned} &d[i, j - 1] + P_{(j-1)j} && \ if \ i < j - 1\\ &\min\limits_{1\le u \lt j-1}{\{d[u, j-1] + P_{uj}\} } && \ if \ i == j - 1 \\ &d[j-1, j] + P_{(j-1)j} && \ if \ i == j\\ \end{aligned} \right.
      • 表示点 到点 的距离
      • 当 时，可以确保点 和 在一条路线上，可以直接使用递推式
      • 当 时， 和 不在同一条路线上，此时需要寻找连接点 的点，使整个巡游路线最短
      • 为了避免重复计算，可以使用表 来储存 的值，只需储存 的值即可
      • 相关初始值:

  • 的值即为最短路径

  • 为了重构两条路径，需要维护另外一张表，，其中 表示 时所选择的最优的点

    • 点 为两条路径共有，设第一条路径拥有点 ，则第二条路径拥有点 ， 而点 均在第一条路径中
    • 先交换两边线路，然后再对点 进行相同的操作
    • 的值需设为 
%%writefile ch15/bitonic_eucliden_travel.py
"""思考题15-3 双调欧几里得旅行商问题"""


def bitonic_euclidean_travel(coordinates):
  """应确保 coordinates 的 x 坐标按升序排列"""
  n = len(coordinates)
  p = [[ ((coordinates[i][0] - coordinates[j][0]) ** 2 + (coordinates[i][1] - coordinates[j][1]) ** 2)**0.5 if i < j else 0
        for j in range(n)]
        for i in range(n)]
  d = [[float('inf') if i == j-1 else 0
        for j in range(n)]
        for i in range(n)]
  d[0][0] = 0
  d[0][1] = p[0][1]
  d[1][1] = 2 * p[0][1]
  k = [[0]*n for i in range(n)]
  k[0][1] = 1
  for j in range(3, n+1):
    for i in range(1, j+1):
      if i == j - 1:
        for u in range(1, j-1):
          t = d[u-1][j-2] + p[u-1][j-1]
          if t < d[i-1][j-1]:
            d[i-1][j-1] = t
            k[i-1][j-1] = u
      elif i != j:
        d[i-1][j-1] = d[i-1][j-2] + p[j-2][j-1]
      else:
        d[i-1][j-1] = d[j-2][j-1] + p[j-2][j-1]
  # 重构解
  first, second = [], []
  i = n-1
  while i > 1:
    u = k[i-1][i]
    first.extend(reversed(range(u+1, i+1)))
    first, second = second, first
    i = u
  first = [coordinates[i-1] for i in first][::-1]
  second = [coordinates[i-1] for i in second][::-1]
  first.insert(0, coordinates[0])
  second.insert(0, coordinates[0])
  first.append(coordinates[-1])
  second.append(coordinates[-1])
  return d[-1][-1], first, second


if __name__ == "__main__":
  coordinates = ((0, 6), (1, 0), (2, 3), (5, 4), (6, 1), (7, 5), (8, 2))
  d, first, second = bitonic_euclidean_travel(coordinates)
  print("最短的双调欧几里得路径为：", d, "第一条路径为：", first, "第二条路径为：", second)

Overwriting ch15/bitonic_eucliden_travel.py

!python ch15/bitonic_eucliden_travel.py

最短的双调欧几里得路径为： 25.58402459469133 第一条路径为： [(0, 6), (2, 3), (5, 4), (7, 5), (8, 2)] 第二条路径为： [(0, 6), (1, 0), (6, 1), (8, 2)]

15-4 整齐打印

问题分析
  • 此问题的子问题为前 个单词所占行的空格立方和的最大值 。原问题即为求解 的最大值
  • 可借助 的值来求解
    • 设 为以 开头， 结尾这些单词为一行所剩的空格数，对于给定的 ， 设满足 的最小 值为
    • 则可得:
      • c[j] = \left\{ \begin{aligned} &\min\limits_{k\le i \le j}{w_{ij}^{3} + c[i-1]} && \ if \ j \neq n \\ &\min\limits_{k\le i \le j}{c[i-1]} && \ if \ j = n \ 最后一行不需要加上空格的立方 \end{aligned}\right.
      • 为了重构出最优解，需要另外一张表 ，其中 用来储存上式取得最小值时的
代码实现
%%writefile ch15/printing_neatly.py
"""思考题 15-4 整齐打印"""


def printing_neatly(X, M):
  n = len(X)
  c = [0] * (n+1)
  b = [1] * n
  for j in range(1, n+1):
    c[j] = float('inf')
    blanks = M + 1  # 补上 i == j 时所减去的空格
    for i in reversed(range(1, j+1)):
      blanks -= 1 + len(X[i-1])
      if blanks < 0:
        break
      if j == n:  # 最后一个元素，无需加上最后一行
        if c[j-1] < c[j]:
          b[j-1] = i
          c[j] = c[j-1]
      else:
        t = c[i-1] + blanks ** 3
        if t < c[j]:
          b[j-1] = i
          c[j] = t
  
  # 重构最优解
  last_word = []  # 储存每一行最后一个单词对应的下标
  i = n
  while i > 0:
    last_word.append(i)
    i = b[i-1] - 1
  return c[n], last_word[::-1]


if __name__ == "__main__":
  s = """
  The Zen of Python, by Tim Peters

  Beautiful is better than ugly.
  Explicit is better than implicit.
  Simple is better than complex.
  Complex is better than complicated.
  Flat is better than nested.
  Sparse is better than dense.
  Readability counts.
  Special cases aren't special enough to break the rules.
  Although practicality beats purity.
  Errors should never pass silently.
  Unless explicitly silenced.
  In the face of ambiguity, refuse the temptation to guess.
  There should be one-- and preferably only one --obvious way to do it.
  Although that way may not be obvious at first unless you're Dutch.
  Now is better than never.
  Although never is often better than right now.
  If the implementation is hard to explain, it's a bad idea.
  If the implementation is easy to explain, it may be a good idea.
  Namespaces are one honking great idea -- let's do more of those1G!
  """.split()
  M = 80
  cost, last_word = printing_neatly(s, M)
  print("除最后一行外， 空格数立方的最小值之和为： ", cost)
  print("最终的打印结果为: ")
  print('*'*80)
  for index, item in enumerate(last_word):
    if index == 0:
      print(" ".join(s[:item]).ljust(M, "|"))
    else:
      print(" ".join(s[last_word[index-1]:item]).ljust(M, "|"))


Overwriting ch15/printing_neatly.py

!python ch15/printing_neatly.py

除最后一行外， 空格数立方的最小值之和为：  1346
最终的打印结果为: 
********************************************************************************
The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit||||||||
is better than implicit. Simple is better than complex. Complex is better|||||||
than complicated. Flat is better than nested. Sparse is better than dense.||||||
Readability counts. Special cases aren't special enough to break the rules.|||||
Although practicality beats purity. Errors should never pass silently. Unless|||
explicitly silenced. In the face of ambiguity, refuse the temptation to guess.||
There should be one-- and preferably only one --obvious way to do it. Although||
that way may not be obvious at first unless you're Dutch. Now is better than||||
never. Although never is often better than right now. If the implementation is||
hard to explain, it's a bad idea. If the implementation is easy to explain, it||
may be a good idea. Namespaces are one honking great idea -- let's do more of|||
those1G!||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
复杂度分析
  • 程序总体有两个循环组成，因此时间复杂度为
  • 空间复杂度为

15-5 编辑距离

a

算法分析
  • 一对下标 对应一个子问题， 设变换到下标 ，总代价为
  • 目标是求解
  • 除终止处的其余5种操作的选用与 的值和字符串 和 本身相关
    • 复制
      • 前提：
    • 替换
      • 前提:
    • 删除
      • 无前提
    • 插入
      • 无前提
    • 交换
      • 前提：
  • 如果 且 ， 取上述 5 种操作的最小值（如果操作存在）即可
  • 如果 且 ，则需要考虑到终止操作，此时设上述 5 种操作的最小值为 ，则可得：
  • 序列值 为 ，相关初始值如下
  • 重构最优解
    • 为了重构最优解，需要另外一张表 ， 其中 用来记录变换到 所执行的操作
    • 相关初始值
    • 重构最优解时，还要根据 是否进行了 操作进行特殊处理
代码实现
%%writefile ch15/edit_distance.py
"""思考题15-5 编辑距离"""


def edit_distance(x, y, cost):
  """求最小的编辑距离"""
  m, n = len(x), len(y)
  c = [[float('inf')]*(n+1) for i in range(m+1)]
  d = [[None]*(n+1) for i in range(m+1)]
  # 相关表项的初始化
  c[0][0] = 0
  for i in range(1, m+1):
    c[i][0] = i * cost['delete']
    d[i][0] = 'delete'
  for j in range(1, n+1):
    c[0][j] = j * cost['insert']
    d[0][j] = 'insert'
  for i in range(1, m+1):
    for j in range(1, n+1):
      if x[i-1] == y[j-1]:  # copy
        t = c[i-1][j-1] + cost['copy']
        if t < c[i][j]:
          c[i][j] = t
          d[i][j] = 'copy'
      else:  # replace
        t = c[i-1][j-1] + cost['replace']
        if t < c[i][j]:
          c[i][j] = t
          d[i][j] = 'replace'
      if i >= 2 and j >= 2 and x[i-1] == y[j-2] and x[i-2] == y[j-1]:  # twiddle
        t = c[i-2][j-2] + cost['twiddle']
        if t < c[i][j]:
          c[i][j] = t
          d[i][j] = 'twiddle'
      t = c[i-1][j] + cost['delete']  # delete
      if t < c[i][j]:
        c[i][j] = t
        d[i][j] = 'delete'
      t = c[i][j-1] + cost['insert']  # insert
      if t < c[i][j]:
        c[i][j] = t
        d[i][j] = 'insert'
  kill_index = -1
  for k in range(0, m):  # kill 操作
    t = c[k][n] + cost['kill']
    if t < c[m][n]:
      kill_index = k + 1
      c[m][n] = t
  # 重构最优解
  res = []
  if kill_index == -1:
    i, j = m, n
  else:
    i, j = kill_index, n
    res.append('kill')
  while i > 0 or j > 0:
    if d[i][j] == 'copy':
      res.append('copy {}'.format(x[i-1]))
      i, j = i-1, j-1
    elif d[i][j] == 'replace':
      res.append('replace {} by {}'.format(x[i-1], y[j-1]))
      i, j = i-1, j-1
    elif d[i][j] == 'twiddle':
      res.append('twiddle {} with {}'.format(x[i-1], x[i-2]))
      i, j = i-2, j-2
    elif d[i][j] == 'delete':
      res.append('delete {}'.format(x[i-1]))
      i = i - 1
    elif d[i][j] == 'insert':
      res.append('insert {}'.format(y[j-1]))
      j = j -1
  return c[m][n], res[::-1]

Writing ch15/edit_distance.py

import ch15.edit_distance
imp.reload(ch15.edit_distance)
from ch15.edit_distance import edit_distance

cost = dict(zip(('copy', 'replace', 'delete', 'insert', 'twiddle', 'kill'), (1, 4, 2, 3, 2, 1)))
x, y = 'algorithm', 'altruistic'
total_cost, res= edit_distance(x, y, cost)
print("编辑距离为:{}".format(total_cost), "操作过程为：", "\n".join(res), sep="\n")

编辑距离为:24
操作过程为：
copy a
copy l
delete g
replace o by t
copy r
insert u
insert i
insert s
twiddle t with i
replace h by c
kill
复杂度分析
  • 时间复杂度和空间复杂度均为

b

  • 最优化对齐的最终目的可以等效于修改两个 DNA 序列，以让它们相同。插入操作相当于在 中插入空格，删除操作相当于在 中插入空格。

  • 由“打分”规则可知，复制操作的代价为 ， 替换操作的代价为 ， 插入和删除的代价为 ，算法的目的相当于是寻找最大编辑距离

  • 根据插入和删除操作，分别向 , 与 中插入空格，即可构造出最优解

%%writefile -a ch15/edit_distance.py



def align_sequences(x, y, cost):
  """借助编辑距离求序列对齐的最佳方案"""
  m, n = len(x), len(y)
  c = [[float('-inf')]*(n+1) for i in range(m+1)]
  d = [[None]*(n+1) for i in range(m+1)]
  # 相关表项的初始化
  c[0][0] = 0
  for i in range(1, m+1):
    c[i][0] = i * cost['delete']
    d[i][0] = 'delete'
  for j in range(1, n+1):
    c[0][j] = j * cost['insert']
    d[0][j] = 'insert'
  for i in range(1, m+1):
    for j in range(1, n+1):
      if x[i-1] == y[j-1]:  # copy
        t = c[i-1][j-1] + cost['copy']
        if t > c[i][j]:
          c[i][j] = t
          d[i][j] = 'copy'
      else:  # replace
        t = c[i-1][j-1] + cost['replace']
        if t > c[i][j]:
          c[i][j] = t
          d[i][j] = 'replace'
      t = c[i-1][j] + cost['delete']  # delete
      if t > c[i][j]:
        c[i][j] = t
        d[i][j] = 'delete'
      t = c[i][j-1] + cost['insert']  # insert
      if t > c[i][j]:
        c[i][j] = t
        d[i][j] = 'insert'
  # 重构最优解
  i, j, x_blanks, y_blanks= m, n, [], []
  while i > 0 or j > 0:
    if d[i][j] == 'copy':
      i, j = i-1, j-1
    elif d[i][j] == 'replace':
      i, j = i-1, j-1
    elif d[i][j] == 'delete':
      y_blanks.append(i-1)
      i = i - 1
    elif d[i][j] == 'insert':
      x_blanks.append(j-1)
      j = j -1
  x_aligned, y_aligned = x, y
  for item in x_blanks:
    x_aligned = x_aligned[:item] + "*" + x_aligned[item:]
  for item in y_blanks:
    y_aligned = y_aligned[:item] + "*" + y_aligned[item:]

  return c[m][n], x_aligned, y_aligned

Appending to ch15/edit_distance.py

import ch15.edit_distance
imp.reload(ch15.edit_distance)
from ch15.edit_distance import align_sequences

cost = dict(zip(('copy', 'replace', 'delete', 'insert'), (1, -1, -2, -2)))
x = "GATCGGCAT"
y = "CAATGTGAATC"
total_cost, x_aligned, y_aligned = align_sequences(x, y, cost)
print("最优对齐方案为：", x_aligned, y_aligned, sep="\n")
print("最优方案的分数为： ", total_cost)

最优对齐方案为：
*GATCGGCAT*
CAATGTGAATC
最优方案的分数为：  -3

15-6 公司聚会计划

算法分析
  • 为每个结点增加两个属性，分别是当前结点参加时，以当前结点为根的子树(包含当前结点)的宾客最大交际分数 和当前结点不参加时，以当前结点为根的子树的宾客的最大交际分数 。问题的子问题就相当于求解属性 和
  • 设树根为 , 则原问题则相当于求解
  • 设结点 的子结点组成的集合为 ， 则可得：
  • 构造最优解，可以通过遍历树，根据每个结点额外添加的两个属性以及当前结点的父结点是否能出席，来决定当前结点是否出席。为些需要在结点中添加 　属性来判断当前人员是否出席
代码实现
%%writefile ch15/party_plan.py
from collections import deque


class Node():
  """用来储存职员信息的结点"""
  def __init__(self, name=None, left_child=None, right_sibling=None, parent=None, point=0):
    self.name = name
    self.left_child = left_child
    self.right_sibling = right_sibling
    self.point = point
    self.parent = parent
    self.attend = None
    self.attend_points = None
    self.not_attend_points = None

  def __repr__(self):
    return str(self.name)

def calc_points(root):
  """计算特定结点的 attend_points 和 not_attend_points 属性"""
  if root.attend_points is not None:  # 避免重复计算
    return
  root.attend_points = root.point
  root.not_attend_points = 0
  child = root.left_child
  while child is not None:
    calc_points(child)
    root.attend_points += child.not_attend_points
    root.not_attend_points += max(child.attend_points, child.not_attend_points)
    child = child.right_sibling


def party_plan(root):
  """思考题 15-6 公司聚会计划"""
  calc_points(root)  # 自顶向下计算 attend_points 和 not_attend_points 属性
  # 层级遍历，构造出席人员
  res = []
  if root.attend_points > root.not_attend_points:
    root.attend, max_points = True, root.attend_points 
    res.append(root)
  else:
    root.attend, max_points = False, root.not_attend_points 
  if root.left_child is None:
    return max_points, res

  dq = deque()
  dq.append(root.left_child)
  while len(dq) > 0:
    x = dq.popleft()
    y = x
    while y is not None:
      if y.left_child is not None:
        dq.append(y.left_child)
      if y.parent.attend or y.attend_points < y.not_attend_points:
        y.attend = False
      else:
        y.attend = True
        res.append(y)
      y = y.right_sibling
  return max_points, res

Writing ch15/party_plan.py

import ch15.party_plan
imp.reload(ch15.party_plan)
from ch15.party_plan import Node, party_plan
  • 构造结点按此图进行， 分数随机生成 
points = [random.randint(1, 100) for i in range(14)]
N01 = Node(name='N01', point=points[0])
N11 = Node(name='N11', point=points[1])
N12 = Node(name='N12', point=points[2])
N13 = Node(name='N13', point=points[3])
N21 = Node(name='N21', point=points[4])
N22 = Node(name='N22', point=points[5])
N23 = Node(name='N23', point=points[6])
N24 = Node(name='N24', point=points[7])
N25 = Node(name='N25', point=points[8])
N26 = Node(name='N26', point=points[9])
N27 = Node(name='N27', point=points[10])
N31 = Node(name='N31', point=points[11])
N32 = Node(name='N32', point=points[12])
N33 = Node(name='N33', point=points[13])
N01.left_child = N11

N11.parent = N01
N12.parent = N01
N13.parent = N01
N11.right_sibling = N12
N12.right_sibling = N13
N11.left_child = N21
N12.left_child = N23
N13.left_child = N27

N21.parent = N11
N22.parent = N11
N21.right_sibling = N22
N22.left_child = N31

N23.parent = N12
N24.parent = N12
N25.parent = N12
N26.parent = N12
N23.right_sibling = N24
N24.right_sibling = N25
N25.right_sibling = N26
N25.left_child = N32

N27.parent = N13

N31.parent = N22

N32.parent = N25
N33.parent = N25
N32.right_sibling = N33

points

[38, 84, 11, 3, 14, 9, 86, 95, 34, 19, 46, 13, 82, 20]

max_points, res = party_plan(N01)
print("最高交际分数为：", max_points)
print("出席的人员为： ", ', '.join([str(item) for item in res]))

最高交际分数为： 445
出席的人员为：  N11, N23, N24, N26, N27, N31, N32, N33
复杂度分析
  • 算法对树中的每个元素都遍历的常数次，而且对每个结点额外添加了 3 个属性，因此时间和空间复杂度均为

15-7 译码算法

  • 与图算法相关，看完图的相关内容后再补

15-8 基于接缝裁剪的图像压缩

a

  • 当 时，每次至少有 种选择，如果其上一行选择的点不在边界，则至少有 种选择， 行至少有 种选择，为 的指数函数

b

算法分析
  • 设 表示 点被删除后，前 行(包括第 行)的最低破坏度之和，则原问题的解为：
  • 子问题 的解为：
    • c[i, j] = \left\{ \begin{aligned} &\min(c[i-1, j], c[i, j+1]) + d[i, j] && i \neq 1 \ and\ j = 1 \\ &\min(c[i-1, j-1], c[i-1, j], c[i-1, j+1]) + d[i, j] && i \neq 1 \ and \ 1 \lt j \lt n\\ &\min(c[i-1, j-1], c[i-1, j]) + d[i, j] && i \neq 1 \ and\ j = n \\ &d[i, j] && i = 1 \\ \end{aligned} \right.
  • 构造最优解根据序列 的值即可求出

代码实现

%%writefile ch15/seam_carving.py
def seam_carving(d):
  """思考题 15-8： 基于接链裁剪的图像压缩"""
  m, n = len(d), len(d[0])
  c = [[d[i][j] if i == 0 else 0 for j in range(n)] for i in range(m)]
  for i in range(1, m):
    c[i][0] = min(c[i-1][0], c[i-1][1]) + d[i][0]
    for j in range(1, n-1):
      c[i][j] = min(c[i-1][j-1], c[i-1][j] ,c[i-1][j+1]) + d[i][j]
    c[i][n-1] = min(c[i-1][n-2], c[i-1][n-1]) + d[i][j]
  
  # 重构最优解
  mini_cost, k = float('inf'), None
  for i, item in enumerate(c[m-1]):
    if item < mini_cost:
      mini_cost, k = item, i
  res = [None] * m
  i = m - 1
  res[i] = (m, k+1)  # 储存剪切的位置
  
  for j in reversed(range(m-1)):
    mini_index = k
    if k != 0 and c[j][k-1] < c[j][mini_index]:
      mini_index = k - 1
    if k != n-1 and c[j][k+1] < c[j][mini_index]:
      mini_index = k + 1
    i -= 1
    res[i] = ((j+1, mini_index+1))
    k = mini_index
  return mini_cost, res


if __name__ == "__main__":
  import random

  d = [[random.randint(10, 99) for j in range(8)] for i in range(6)]
  print("破坏度矩阵为：") 
  print("\n".join([str(item) for item in d]))
  mini_cost, res = seam_carving(d)
  print("最小破环度为： ", mini_cost)
  print("裁剪位置为：", res)
  res_sum = sum(d[item[0]-1][item[1]-1] for item in res)
  assert res_sum == mini_cost

Overwriting ch15/seam_carving.py

!python ch15/seam_carving.py

破坏度矩阵为：
[70, 67, 87, 57, 68, 74, 97, 81]
[41, 12, 74, 31, 21, 33, 44, 35]
[39, 26, 33, 13, 10, 33, 88, 44]
[17, 24, 40, 94, 38, 61, 33, 74]
[77, 99, 38, 75, 54, 44, 70, 24]
[59, 47, 68, 76, 86, 87, 62, 74]
最小破环度为：  214
裁剪位置为： [(1, 2), (2, 2), (3, 2), (4, 2), (5, 3), (6, 2)]
复杂度分析
  • 有内外两个循环，时间复杂度为

15-9 字符串拆分

算法分析
  • 此问题与矩阵链乘法基本相同，可以先从 中随机选择一个拆分点，此操作下的最小代价等于其左边子字符串操作的最小代价加上其右边子字符串操作的最小代价，符合最优子结构的相关特征
  • 为了便于分析问题，扩充数组 ，在其左右分别加入 ，如此数组 变为 ，且
  • 定义 表示将 中的元素按数组 划分的最小拆分代价，则原问题相当于求解
  • 可按以下公式计算得到：
    • c[i, j] =\left \{ \begin{aligned} &1 && \ if \ i = j - 1 \\ &L[j] - L[i] + 1 && \ if \ i = j - 2 \\ &\min\limits_{i\lt k \lt j}{(c[i, k] + c[k, j] - 1 + (L[j] - L[i] + 1))} && \ if \ i < j - 2 \\ \end{aligned}\right.
      • 设置为 的目的是方便 时的计算
  • 定义 为 取得最小值时的 ，以此可重构出最优拆分序列
    • 当 时，有
代码实现
%%writefile ch15/string_break.py
def string_break(n, L):
  """思考题 15-9 字符串拆分"""
  m = len(L)
  L = [1] + list(L) + [n]
  c = [[L[j]-L[i] + 1 if j == i+2 else 1
      for j in range(m+2)] 
      for i in range(m+2)]
  d = [[i+1 if j == i+2 else None
      for j in range(m+2)] 
      for i in range(m+2)]
  for l in range(4, m+3):
    for i in range(0, m+3-l):
      j = i + l - 1
      c[i][j] = float('inf')
      for k in range(i+1, j):
        t = c[i][k] + c[k][j] + L[j] - L[i]
        if t < c[i][j]:
          c[i][j] = t
          d[i][j] = k

  mini_cost = c[0][m+1]  # 最小代价
  res = []
  construct_break_sequence(L, d, m, res, 0, m+1)
  return mini_cost, res 


def construct_break_sequence(L, d, m, res, i, j):
  """构造最优拆分序列"""
  k = d[i][j]
  res.append(L[k])
  if k > i + 1:
    construct_break_sequence(L, d, m, res, i, k)
  if k < j - 1:
    construct_break_sequence(L, d, m, res, k, j)


if __name__ == "__main__":
  n = 20
  L = [2, 8, 10]
  mini_cost, res = string_break(n, L)
  print("最小拆分代价为：", mini_cost)
  print("对应的拆分序列为：", res)

Overwriting ch15/string_break.py

!python ch15/string_break.py

最小拆分代价为： 38
对应的拆分序列为： [10, 8, 2]

15-10

a

  • 10 年的最优投资策略，可看做由几个分开的不转移资产的连续年份组成
  • 假设第 至 年不转移资产， 则应选择 最高的产品进行投资才能获得最高的收益
  • 因此，存在最优投资策略，每年都将所有钱放入到单一投资中
b
  • 设 表示第 年选择第 种投资的最大收益
  1. 如果第 年没有切换投资项目，则
  1. 如果第 年切换了投资项目
  • 取为 中结果的最大值
  • 第 年投资 的收益只与第 年的收益相关，因此具有最优子结构的特征
c
  • 末来 年的最大化投资收益等于
  • 需要另外一个序列 来储存获得 时的前一年投资的项目，以便重构最优解
代码实现
%%writefile ch15/invest_strategy.py
"""练习题 15-10: 投资策略规划"""


def invest_strategy(R, money, f1, f2):
  """R 储存了 n 种投资 m 年的收益"""
  n, m = len(R), len(R[0])
  c = [[money * R[i][0] if j == 0 else float('-inf')
      for j in range(m)]
      for i in range(n)]
  d = [[None]* (m) for i in range(n)]

  for j in range(1, m):
    for i in range(n):
      for k in range(n):
        if i == k:
          t = (c[k][j-1] - f1) * R[i][j]
        else:
          t = (c[k][j-1] - f2) * R[i][j]
        if t > c[i][j]:
          c[i][j] = t
          d[i][j] = k
  
  max_profit, k = float('-inf'), None
  for i in range(n):
    if c[i][m-1] > max_profit:
      max_profit, k = c[i][m-1], i
  res = [None] * m
  res[-1] = k + 1
  for i in reversed(range(m-1)):
    res[i] = d[res[i+1] - 1][i+1] + 1
  return max_profit, res  


if __name__ == "__main__":
  import numpy as np

  n, m = 5, 10
  R = np.random.random((n, m)) / 8 + 1
  money = 10 ** 4
  f1 = 50
  f2 = 500
  max_profit, res = invest_strategy(R, money, f1, f2)

  print("共有 {} 种投资， 投资年限为 {} 年".format(n, m))
  np.set_printoptions(precision=3, suppress=True, linewidth=100)
  print("每种投资的回报率为： \n", str(R))
  print("本金为： ", money)
  print("f1 = {}, f2 = {}".format(f1, f2))
  print("*"*50)
  print("最大收益为： ", max_profit)
  print("投资顺序为：", res)

Overwriting ch15/invest_strategy.py

!python ch15/invest_strategy.py

共有 5 种投资， 投资年限为 10 年
每种投资的回报率为： 
 [[1.018 1.079 1.061 1.066 1.045 1.015 1.026 1.044 1.081 1.008]
 [1.04  1.087 1.068 1.041 1.053 1.09  1.105 1.089 1.102 1.014]
 [1.115 1.024 1.072 1.024 1.027 1.049 1.024 1.119 1.04  1.06 ]
 [1.052 1.072 1.025 1.093 1.032 1.11  1.032 1.067 1.045 1.042]
 [1.108 1.024 1.002 1.083 1.049 1.111 1.091 1.109 1.077 1.121]]
本金为：  10000
f1 = 50, f2 = 500
**************************************************
最大收益为：  21343.92608956265
投资顺序为： [3, 2, 2, 5, 5, 5, 5, 5, 5, 5]
时间复杂度
  • 算法中共有 个循环，时间复杂度为

d

  • 经过 年的投资，总金额可能大于 15000 美元，此时会影响到后续的投资策略，不能再全部投入一类产品。此时问题不能再通过其子问题求出，因此不再具有最优子结构。

15-11 库存规划

算法分析
  • 此问题有以下隐藏条件
    1. 个月的总生产数量不能超过 台
    2. 为了满足第 个月销售， 第 个月的生产数量应大于等于
  • 第 月的成本以及生产计划需要视上个月的库存而定，而本月的库存又会影响到下一个月的库存和生产计划
    • 因此选用 表示第 个月的库存为 的成本， 　的序列为 ，
    • 选定序列 表示前 个月的总销售量，即 ，设
      • 则第 个月的库存量至多为 ，则 需要满足
    • 为了使得第 个月后库存为 ，则第 个月的库存不能超过
  • 可得 时 的计算公式如下：
      • 为生产成本，即
      • 为储存成本，设
    • 令 ， 即用来储存 取得最小值时上一个月的仓库储量
      • 已知 后借助 即可算出当前月的生产量，以此便可重构最优的生产序列
  • 原问题相当于求解
代码实现
%%writefile ch15/invest_strategy.py
"""思考题 15-11 库存规划"""
def invertory_plan(d):
  """库存规划
  """
  n, D = len(d), sum(d)
  c = [[ 0 if i == 0 else float('inf')
      for j in range(D+1)]
      for i in range(n+1)]
  b = [[0]*(D+1) for i in range(n+1)]
  w = [0]*(n+1)
  for i in range(1, n+1):
    w[i] = w[i-1] + d[i-1]
    for j in range(D-w[i]+1):
      c[i][j] = c[i-1][0] + product_cost(j+d[i-1]) + invertory_cost(j)
      if i == 1:
        continue
      for k in range(min(D-w[i-1], j+d[i-1])):
        t = c[i-1][k] + product_cost(j-k+d[i-1]) + invertory_cost(j)
        if t < c[i][j]:
          c[i][j] = t
          b[i][j] = k
  # 重构最优生产序列
  res, k = [0] * n, b[n][0]
  res[n-1] = -k+d[n-1]
  for i in reversed(range(i-1)):
    t = b[i+1][k]
    res[i] = k-t+d[i]
    k = t

  return c[n][0], res


def product_cost(x, m=10, c=1000):
  """生产成本`"""
  return 0 if x <=m else (x-m) * c


def invertory_cost(x):
  """存储成本"""
  return 250 * x 


if __name__ == "__main__":
  import random
  d = [random.randint(0, 20) for i in range(11)] + [0]
  m, c = 10, 1000
  cost, res= invertory_plan(d)
  print("m = {}, c = {}".format(m, c))
  print("每件的储存成本为： 250")
  print("每个月销售量为：", d)
  print("*"*60)
  print("每个月的最优生产序列为： ", res)
  print("最低成本为： ", cost)

Overwriting ch15/invest_strategy.py

!python ch15/invest_strategy.py

m = 10, c = 1000
每件的储存成本为： 250
每个月销售量为： [10, 13, 3, 13, 10, 16, 14, 0, 19, 9, 3, 0]
************************************************************
每个月的最优生产序列为：  [10, 13, 10, 10, 10, 12, 14, 9, 10, 9, 3, 0]
最低成本为：  15000
复杂度分析
  • 算法共有三层循环，运行的时间复杂度为

15-12 签约棒球自由球员

算法分析
  • 此问题有两个变量，一是球员的位置，还有一个是签约的总费用，目的是为了使得总的 值最大
  • 设 表示签约费用为 时，签约 个不同位置的球员的的最大 值，则原问题相当于求解 ， 可由其子问题的最优解构成
  • 时， 的求解可分为两种情况
    1. 在位置 　处不签入球员
    1. 在位置 处签入球员
    • 设位置 处的球员集合为
      • 如果对于某个 ，有 ，则该 不计入考虑
  • 为了重构最优解，需要用 来记录 取得最优值时所签入的球员编号 如果没有签入球员，则
  • 假设每位球员的签约费用为 10 万美元的整数倍，则 的最大值可取为
  • 为了简化算法，设 对应的序列为 ， 其中
代码实现
%%writefile ch15/signing_players.py
"""思考题 15-2： 签约棒球自由球员"""


from collections import namedtuple

Player = namedtuple('Player', 'index, cost, VORP')  # 球员属性, cost 的单位为十万


def signing_players(M, X):
  """M 应有 n 行 p 列，分别对应 N 个位置，以及每个位置上有 P 个可选球员"""
  N, P = len(M), len(M[0])
  x = X // 10 ** 5
  c = [[0]*(x+1) for i in range(N+1)]
  d = [[0]*(x+1) for i in range(N+1)]
  
  for i in range(1, N+1):
    for j in range(1, x+1):
      c[i][j] = float('-inf')
      if c[i-1][j] > c[i][j]:
        c[i][j], d[i][j] = c[i-1][j], 0
      for k in range(P):
        remain_money = j - M[i-1][k].cost
        if remain_money < 0:
          continue
        t = c[i-1][remain_money] + M[i-1][k].VORP
        if t > c[i][j]:
          c[i][j], d[i][j] = t, k+1
  
  # 重构最优解
  i, j, res = N, x, []
  while i > 0 and j > 0:
    k = d[i][j]
    if k != 0:
      res.append(M[i-1][k-1])
      i ,j = i-1, j - res[-1].cost
    else:
      i -= 1

  return c[N][x], res[::-1]


if __name__ == "__main__":
  import random
  N, P = 9, 6
  M = [[Player("{}{}".format(i+1, j+1), random.randint(1, 9), random.randint(60, 99)) 
      for j in range(P)]
      for i in range(N)]
  X = 12 * 10 ** 5
  print("球员信息为： \n")
  print("\n".join(str(item) for item in M))
  print("总的招聘费用为：{:.2f} 十万".format(X/10**5))
  print("*"*50)
  cost, res = signing_players(M, 12 * 10 ** 5)
  print("招入的球员为： ")
  print("\n".join(str(item) for item in res))
  print("最大 VORP 值为：", cost)

Overwriting ch15/signing_players.py

!python ch15/signing_players.py

球员信息为： 

[Player(index='11', cost=5, VORP=62), Player(index='12', cost=9, VORP=75), Player(index='13', cost=8, VORP=83), Player(index='14', cost=3, VORP=91), Player(index='15', cost=2, VORP=86), Player(index='16', cost=6, VORP=74)]
[Player(index='21', cost=7, VORP=77), Player(index='22', cost=1, VORP=72), Player(index='23', cost=3, VORP=60), Player(index='24', cost=4, VORP=69), Player(index='25', cost=5, VORP=62), Player(index='26', cost=8, VORP=95)]
[Player(index='31', cost=6, VORP=78), Player(index='32', cost=8, VORP=83), Player(index='33', cost=8, VORP=93), Player(index='34', cost=7, VORP=62), Player(index='35', cost=7, VORP=97), Player(index='36', cost=2, VORP=80)]
[Player(index='41', cost=6, VORP=66), Player(index='42', cost=2, VORP=87), Player(index='43', cost=3, VORP=75), Player(index='44', cost=9, VORP=66), Player(index='45', cost=4, VORP=81), Player(index='46', cost=3, VORP=72)]
[Player(index='51', cost=9, VORP=75), Player(index='52', cost=3, VORP=60), Player(index='53', cost=1, VORP=66), Player(index='54', cost=3, VORP=73), Player(index='55', cost=2, VORP=82), Player(index='56', cost=3, VORP=95)]
[Player(index='61', cost=3, VORP=67), Player(index='62', cost=3, VORP=83), Player(index='63', cost=8, VORP=73), Player(index='64', cost=2, VORP=93), Player(index='65', cost=6, VORP=88), Player(index='66', cost=8, VORP=96)]
[Player(index='71', cost=6, VORP=70), Player(index='72', cost=2, VORP=88), Player(index='73', cost=7, VORP=70), Player(index='74', cost=4, VORP=85), Player(index='75', cost=4, VORP=97), Player(index='76', cost=3, VORP=66)]
[Player(index='81', cost=2, VORP=87), Player(index='82', cost=6, VORP=81), Player(index='83', cost=5, VORP=67), Player(index='84', cost=8, VORP=86), Player(index='85', cost=2, VORP=74), Player(index='86', cost=4, VORP=96)]
[Player(index='91', cost=5, VORP=95), Player(index='92', cost=3, VORP=68), Player(index='93', cost=9, VORP=79), Player(index='94', cost=4, VORP=86), Player(index='95', cost=4, VORP=74), Player(index='96', cost=6, VORP=96)]
总的招聘费用为：12.00 十万
**************************************************
招入的球员为： 
Player(index='15', cost=2, VORP=86)
Player(index='22', cost=1, VORP=72)
Player(index='42', cost=2, VORP=87)
Player(index='53', cost=1, VORP=66)
Player(index='64', cost=2, VORP=93)
Player(index='72', cost=2, VORP=88)
Player(index='81', cost=2, VORP=87)
最大 VORP 值为： 579
复杂度分析
  • 令
  • 算法的时间复杂度为
  • 空间复杂度为

你可能感兴趣的:(算法导论 第 15 章：动态规划 (更新中))

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 水泥质量纠纷案代理词 徐宝峰律师
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • 直抒《紫罗兰永恒花园外传》 雷姆的黑色童话
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
  • 相信相信的力量 孙丽_cdb3
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • java责任链模式 3213213333332132 java责任链模式村民告县长
    责任链模式，通常就是一个请求从最低级开始往上层层的请求，当在某一层满足条件时，请求将被处理，当请求到最高层仍未满足时，则请求不会被处理。 就是一个请求在这个链条的责任范围内，会被相应的处理，如果超出链条的责任范围外，请求不会被相应的处理。 下面代码模拟这样的效果： 创建一个政府抽象类,方便所有的具体政府部门继承它。 package 责任链模式; /** *
  • linux、mysql、nginx、tomcat 性能参数优化 ronin47
    一、linux 系统内核参数 /etc/sysctl.conf文件常用参数 net.core.netdev_max_backlog = 32768 #允许送到队列的数据包的最大数目 net.core.rmem_max = 8388608 #SOCKET读缓存区大小 net.core.wmem_max = 8388608 #SOCKET写缓存区大
  • php命令行界面 dcj3sjt126com PHPcli
    常用选项 php -v php -i PHP安装的有关信息 php -h 访问帮助文件 php -m 列出编译到当前PHP安装的所有模块 执行一段代码 php -r 'echo "hello, world!";' php -r 'echo "Hello, World!\n";' php -r '$ts = filemtime("
  • Filter&Session 171815164 session
    Filter HttpServletRequest requ = (HttpServletRequest) req; HttpSession session = requ.getSession(); if (session.getAttribute("admin") == null) { PrintWriter out = res.ge
  • 连接池与Spring,Hibernate结合 g21121 Hibernate
            前几篇关于Java连接池的介绍都是基于Java应用的，而我们常用的场景是与Spring和ORM框架结合，下面就利用实例学习一下这方面的配置。         1.下载相关内容：     &nb
  • [简单]mybatis判断数字类型 53873039oycg mybatis
           昨天同事反馈mybatis保存不了int类型的属性,一直报错，错误信息如下:       Caused by: java.lang.NumberFormatException: For input string: "null" at sun.mis
  • 项目启动时或者启动后ava.lang.OutOfMemoryError: PermGen space 程序员是怎么炼成的 eclipsejvmtomcatcatalina.sheclipse.ini
       在启动比较大的项目时，因为存在大量的jsp页面，所以在编译的时候会生成很多的.class文件，.class文件是都会被加载到jvm的方法区中，如果要加载的class文件很多，就会出现方法区溢出异常 java.lang.OutOfMemoryError: PermGen space.     解决办法是点击eclipse里的tomcat，在
  • 我的crm小结 aijuans crm
    各种原因吧，crm今天才完了。主要是接触了几个新技术： Struts2、poi、ibatis这几个都是以前的项目中用过的。 Jsf、tapestry是这次新接触的，都是界面层的框架，用起来也不难。思路和struts不太一样，传说比较简单方便。不过个人感觉还是struts用着顺手啊，当然springmvc也很顺手，不知道是因为习惯还是什么。jsf和tapestry应用的时候需要知道他们的标签、主
  • spring里配置使用hibernate的二级缓存几步 antonyup_2006 javaspringHibernatexmlcache
    ．在spring的配置文件中 applicationContent.xml，hibernate部分加入 xml 代码 <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop> <prop key="hi
  • JAVA基础面试题 百合不是茶 抽象实现接口String类接口继承抽象类继承实体类自定义异常
    /*   * 栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、   *int、long、 float、double、boolean）和对象的引用，数据可以共享，速度仅次于   * 寄存器（register），快于堆。堆（heap）：用于存储对象。   */  &
  • 让sqlmap文件 "继承" 起来 bijian1013 javaibatissqlmap
            多个项目中使用ibatis , 和数据库表对应的 sqlmap文件（增删改查等基本语句)，dao, pojo 都是由工具自动生成的, 现在将这些自动生成的文件放在一个单独的工程中，其它项目工程中通过jar包来引用 ，并通过"继承"为基础的sqlmap文件，dao,pojo 添加新的方法来满足项
  • 精通Oracle10编程SQL(13)开发触发器 bijian1013 oracle数据库plsql
    /* *开发触发器 */ --得到日期是周几 select to_char(sysdate+4,'DY','nls_date_language=AMERICAN') from dual; select to_char(sysdate,'DY','nls_date_language=AMERICAN') from dual; --建立BEFORE语句触发器 CREATE O
  • 【EhCache三】EhCache查询 bit1129 ehcache
    本文介绍EhCache查询缓存中数据，EhCache提供了类似Hibernate的查询API，可以按照给定的条件进行查询。   要对EhCache进行查询，需要在ehcache.xml中设定要查询的属性   数据准备 @Before public void setUp() { //加载EhCache配置文件 Inpu
  • CXF框架入门实例 白糖_ springWeb框架webserviceservlet
    CXF是apache旗下的开源框架，由Celtix + XFire这两门经典的框架合成，是一套非常流行的web service框架。 它提供了JAX-WS的全面支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者 WSDL 优先（WSDL First）来轻松地实现 Web Services 的发布和使用，同时它能与spring进行完美结合。 在apache cxf官网提供
  • angular.equals boyitech AngularJSAngularJS APIAnguarJS 中文APIangular.equals
    angular.equals   描述: 比较两个值或者两个对象是不是 相等。还支持值的类型，正则表达式和数组的比较。   两个值或对象被认为是 相等的前提条件是以下的情况至少能满足一项： 两个值或者对象能通过=== （恒等） 的比较 两个值或者对象是同样类型，并且他们的属性都能通过angular
  • java-腾讯暑期实习生-输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A[0]*A[1]*...*A[i-1]*A[i+1] bylijinnan java
    这道题的具体思路请参看 何海涛的微博：http://weibo.com/zhedahht import java.math.BigInteger; import java.util.Arrays; public class CreateBFromATencent { /** * 题目：输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A
  • FastDFS 的安装和配置 修订版 Chen.H linuxfastDFS分布式文件系统
    FastDFS Home:http://code.google.com/p/fastdfs/ 1. 安装 http://code.google.com/p/fastdfs/wiki/Setup http://hi.baidu.com/leolance/blog/item/3c273327978ae55f93580703.html 安装libevent (对libevent的版本要求为1.4.
  • [强人工智能]拓扑扫描与自适应构造器 comsci 人工智能
          当我们面对一个有限拓扑网络的时候,在对已知的拓扑结构进行分析之后,发现在连通点之后,还存在若干个子网络,且这些网络的结构是未知的,数据库中并未存在这些网络的拓扑结构数据....这个时候,我们该怎么办呢?       那么,现在我们必须设计新的模块和代码包来处理上面的问题
  • oracle merge into的用法 daizj oraclesqlmerget into
    Oracle中merge into的使用 http://blog.csdn.net/yuzhic/article/details/1896878 http://blog.csdn.net/macle2010/article/details/5980965 该命令使用一条语句从一个或者多个数据源中完成对表的更新和插入数据. ORACLE 9i 中，使用此命令必须同时指定UPDATE 和INSE
  • 不适合使用Hadoop的场景 datamachine hadoop
    转自：http://dev.yesky.com/296/35381296.shtml。 　　Hadoop通常被认定是能够帮助你解决所有问题的唯一方案。 当人们提到“大数据”或是“数据分析”等相关问题的时候，会听到脱口而出的回答：Hadoop!  实际上Hadoop被设计和建造出来，是用来解决一系列特定问题的。对某些问题来说，Hadoop至多算是一个不好的选择，对另一些问题来说，选择Ha
  • YII findAll的用法 dcj3sjt126com yii
    看文档比较糊涂，其实挺简单的： $predictions=Prediction::model()->findAll("uid=:uid",array(":uid"=>10));   第一个参数是选择条件：”uid=10″。其中:uid是一个占位符，在后面的array(“:uid”=>10)对齐进行了赋值； 更完善的查询需要
  • vim 常用 NERDTree 快捷键 dcj3sjt126com vim
    下面给大家整理了一些vim NERDTree的常用快捷键了，这里几乎包括了所有的快捷键了，希望文章对各位会带来帮助。 切换工作台和目录 ctrl + w + h 光标 focus 左侧树形目录ctrl + w + l 光标 focus 右侧文件显示窗口ctrl + w + w 光标自动在左右侧窗口切换ctrl + w + r 移动当前窗口的布局位置 o 在已有窗口中打开文件、目录或书签，并跳
  • Java把目录下的文件打印出来 蕃薯耀 列出目录下的文件文件夹下面的文件目录下的文件
    Java把目录下的文件打印出来 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月11日 11:02:
  • linux远程桌面----VNCServer与rdesktop hanqunfeng Desktop
    windows远程桌面到linux，需要在linux上安装vncserver，并开启vnc服务，同时需要在windows下使用vnc-viewer访问Linux。vncserver同时支持linux远程桌面到linux。   linux远程桌面到windows，需要在linux上安装rdesktop，同时开启windows的远程桌面访问。   下面分别介绍，以windo
  • guava中的join和split功能 jackyrong java
    guava库中，包含了很好的join和split的功能，例子如下： 1） 将LIST转换为使用字符串连接的字符串    List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");
  • Web开发技术十年发展历程 lampcy androidWeb浏览器html5
    回顾web开发技术这十年发展历程： Ajax 03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
  • 架构师之mima-----------------mina的非NIO控制IOBuffer(说得比较好) nannan408 buffer
    1.前言。   如题。 2.代码。   IoService IoService是一个接口，有两种实现：IoAcceptor和IoConnector；其中IoAcceptor是针对Server端的实现，IoConnector是针对Client端的实现；IoService的职责包括： 1、监听器管理 2、IoHandler 3、IoSession
  • ORA-00054:resource busy and acquire with NOWAIT specified Everyday都不同 oraclesessionLock
    [Oracle] 今天对一个数据量很大的表进行操作时，出现如题所示的异常。此时表明数据库的事务处于“忙”的状态，而且被lock了，所以必须先关闭占用的session。   step1，查看被lock的session：   select t2.username, t2.sid, t2.serial#, t2.logon_time from v$locked_obj
  • javascript学习笔记 tntxia JavaScript
      javascript里面有6种基本类型的值:number、string、boolean、object、function和undefined。number：就是数字值，包括整数、小数、NaN、正负无穷。string:字符串类型、单双引号引起来的内容。boolean:true、false object:表示所有的javascript对象，不用多说function:我们熟悉的方法，也就是
  • Java enum的用法详解 xieke90 enum枚举
    Java中枚举实现的分析：     示例：  public static enum SEVERITY{ INFO,WARN,ERROR }     enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类      (java.l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他