算法导论-12.动态规划-下

这一篇主要关于最优二叉查找树的分析与实现,以及算法导论动态规划一章的几道思考题。

最优二叉查找树

最优二叉查找树,是经过优化的二叉查找树。在知晓每个键被查询到的概率的情况下,生成一棵二叉查找树,使得查找的期望深度最小。最优二叉查找树仍然保持二叉查找树的性质,所以查找概率最大的键不一定是树的跟。

形式地,给定由 $n$ 个互异关键字组成的有序序列 $K=\{k_{1},k_{2},...k_{n}\}$,对每个关键字 $k_{i}$,被查找的概率是 $p_{i}$,对每两个关键字 $k_{i}$ 和 $k_{i+1}$,查找落在区间 $(k_{i}, k_{i+1})$ (而查找失败的)的概率为 $q_{i+1}$,构造一棵二叉查找树使一次查找的期望深度 $E$ 最低。令序列 $d_{i}$ 为虚拟键,表示区间 $(k_{i-1}, k_{i})$ 。

查找期望深度为:

$$E_{tree}=\sum_{i=1}^{n}(depth(k_{i})+1)\cdot p_{i}+\sum_{i=0}^{n}(depth(d_{i})+1)\cdot q_{i}$$

递归的,查找期望深度也可以写成:

$$E_{tree}=(E_{left}+1)\cdot p_{left}+(E_{right}+1)\cdot p_{right}+1\cdot p_{root}$$

解决该问题的思路是:

序列 $k_{1}...k_{n}$ 的最优二叉查找树,就是以下这些查找树中,深度最小的一棵:

  • $k_{1}$ 为根,左子树为空树,右子树为序列 $k_{2}...k_{n}$ 的最优二叉查找树 的 二叉查找树。
  • ...
  • $k_{i}$ 为根,左子树为序列 $k_{1}...k_{i-1}$ 的最优二叉查找树,右子树为序列 $k_{i+1}...k_{n}$ 的最优二叉查找树 的 二叉查找树。
  • ...
  • $k_{n}$ 为根,左子树为序列 $k_{1}...k_{n-1}$ 的最优二叉查找树,右子树为空树 的 二叉查找树。

根据递归的查找期望深度,对 $k_{i}$ 为根的二叉查找树,如果它是最优二叉查找树,则两个子树也一定是最优二叉查找树。需要记录的子问题就是,序列 $k_{i}...k_{j}$ 的最优二叉查找树深度,以及最优二叉查找树。在一张二维表中维护该深度,最后查询 $k_{1}...k_{n}$ 的最有二叉查找树就可以。

我的实现如下:为了简便,仅仅是求出了最优二叉查找树的深度,没有真正去维护树本身。

double getDepth(const std::vector<std::vector<double>>& depthTable,
                const int i,
                const int j){
    if (i>j){
        return 1;
    }
    else{
        return depthTable[i][j];
    }
}

double getProb(const std::vector<double>& p,
               const std::vector<double>& q,
               const int i,
               const int j){
    if (i>j){
        return q[i];
    }
    double rslt = 0;
    for (int s=i; s<=j; s++){
        rslt += p[s]+q[s];
    }
    rslt += q[j+1];
    return rslt;
}

void makeOBST(const std::vector<std::string>& k,
              const std::vector<double>& p,
              const std::vector<double>& q,
              std::vector<std::vector<double>>& depthTable,
              std::vector<std::vector<BryTree>>& treeTable,
              int i, int j){
    if (i>j){return;}
    double minDepth = INT_MAX;
    for (int s=i; s<=j; s++){
        const int i1 = i;
        const int j1 = s-1;
        const int i2 = s+1;
        const int j2 = j;

        makeOBST(k, p, q, depthTable, treeTable, i1, j1);
        makeOBST(k, p, q, depthTable, treeTable, i2, j2);

        double depth1 = getDepth(depthTable, i1, j1);
        double depth2 = getDepth(depthTable, i2, j2);
        double prob1 = getProb(p, q, i1, j1);
        double prob2 = getProb(p, q, i2, j2);

        double depth = (prob1*(depth1+1) + p[s]*1 + prob2*(depth2+1))/(prob1+prob2+p[s]);
        if(minDepth > depth){
            minDepth = depth;
        }
    }
    depthTable[i][j] = minDepth;
}

void OBST(const std::vector<std::string>& k,
          const std::vector<double>& p,
          const std::vector<double>& q){
    if (k.size()!=p.size() || p.size()!=q.size()-1){
        throw std::runtime_error("OBST input vectors' sizes do not match.");
    }    
    const int n = k.size();
    std::vector<std::vector<BryTree>> treeTable(n, std::vector<BryTree>(n));
    std::vector<std::vector<double>> depthTable(n, std::vector<double>(n, -1));
    makeOBST(k, p, q, depthTable, treeTable, 0, n-1);
    std::cout<<depthTable[0][n-1];
}

传入数据 $p=\{0.15,0.10,0.05,0.10,0.20\}$ 和 $q=\{0.05,0.10,0.05,0.05,0.05,0.10\}$,输出结果为 $2.75$,与算法导论上相符。

思考题15-1 双调欧几里得问题 欧几里得旅行商问题是指平面上给定的 $n$ 个点,确定一条连接各点的最短闭合折线。这是一个NP完全问题。双调欧几里得问题对其进行了简化,给出从 最左侧的 点出发,严格从左至右经过各点,到达最右侧的点,再从最右侧的点严格从右至左回到最左侧的点。下图显示了7点欧几里得旅行商问题的解(左图)以及双调版本问题的解(右图)。

思路:将所有点从左向右排序,为 $k_{1}...k_{n}$ ,该序列的两个子集 $p_{1}...p_{s}$ 和 $q_{1}...q_{t}$,两个子集的交集为只有 $\k_{1}$和$k_{n}$两个元素。问题可以这样考虑:最短路径就是以下两条路径较短的一条:

  • $p_{s}$为$k_{n}$,$q_{t}$为$k_{n-1}$时二者的最短路径,加上$q_{t}$与$k_{n}$间的距离。
  • $p_{s}$为$k_{n-1}$,$q_{t}$为$k_{n}$时二者的最短路径,加上$p_{s}$与$k_{n}$间的距离。

可递归的并需要维护的子问题就是:一条路径以 $k_{i}$ 为终点,一条路径以 $k_{j}$ 为终点,路径不交叉,不遗漏 $k_{n}...k_{max(i,j)}$ 间的任意一点,的最短路径之和。那就是以下两条路径中最短的(认为 $j>i$):

  • $P$ 以 $k_{i}$ 为终点,$Q$ 以 $k_{j-1}$ 为终点,再加上 $k_{i}$ 到 $k_{j}$ 的距离($k_{j}$ 加在 $P$ 上)。
  • $P$ 以 $k_{i}$ 为终点,$Q$ 以 $k_{j-1}$ 为终点,再加上 $k_{j-1}$ 到 $k_{j}$ 的距离($k_{j}$ 加在 $Q$ 上)。

思考题15-2 整齐打印 在打印机上整齐地打印一个段落,段落由长度为 $L=\{l_{1}...l_{n}\}$ 的 $n$ 个单词组成,每一行至多输入 $M$ 个字符。如果某一行包括了单词 $l_{i}...l_{j}$,那么行末的空余字符格数为 $M-j+i-\sum_{k=i}^{j}l_{k}$。要求整个段落行末多余空格字符数的立方和最小。

思路:可递归的并需要维护的子问题就是:段落 $l_{i}...l_{n}$ 的整齐打印后的多余空格字符数立方和。假设第一行最多打印 $s$ 个字符,那么该子问题就的最优解就是如下数个问题中的最优的那个解:

  • 第一行只打印 $1$ 个字符,第一行的多余空格字符数立方 加上 $l_{i+1}...l_{n}$。
  • ...
  • 第一行打印 $j$ 个字符,第一行的多余空格字符数立方 加上 $l_{i+j}...l_{n}$。
  • ...
  • 第一行打印 $s$ 个字符,第一行的多余空格字符数立方 加上 $l_{i+s}...l_{n}$。

 整个问题就是求段落 $l_{1}...l_{n}$ 的整齐打印。

思考题15-4 计划公司聚会 一个公司具有层次式结构,所有职员形成了一棵以总裁为根的树。每一个职员都有对聚会的喜爱程度(一个实数),但每个职员都不想在聚会上遇到自己的直接上司。生成一张名单,使所有参与者对聚会喜爱程度的和最大,又避免任意两位参与者是直接的上下级关系。

思路:需要维护的子问题是,以某个职员为根的树,按照如上规则参加聚会的最大喜爱程度之和。为每个职员维护这个域。

  • 当这个职员是叶子时,如果喜爱度是正,那就参加,喜爱度是负,就不参加。
  • 当这个成员不是叶子时,而该成员的喜爱度为正,那么以他为跟的树的最大喜爱程度之和为以下数个情况下的最优解:
    • 他不参加,他的所有直接下属为根的树的喜爱度之和相加。
    • 他参加,他的所有直接下属的直接下属为根的树的喜爱度之和相加。
  • 当这个成员不是叶子是,而该成员喜爱度为负,问题的解同上一条中的第一小条。

最后考察以总裁为根的树,即整个公司,参加聚会的成员。

思考题15-6 在棋盘上移动 一张 $n×n$ 的方格期盼,棋子从顶边移到底边,只能直行,斜行,类似于国际象棋中的小卒(只不过是从底边开始,而且斜行并不一定要吃掉棋子)。没走一次都会获得一笔金钱,选择合适的底边格子,完成上述移动过程(移动到顶边),并尽可能多地收集金钱。

思路:很简单,为每个格子维护一个域,表示从这个格子开始移动到顶边获取的最大金钱数。顶边上都是0,从顶边开始逐行生成,直到底边。在底边选取最大的域就可以了。

思考题15-7 最高效益调度 一台机器,在此机器上可处理 $n$ 个作业 $a_{1},a_{2}...a_{n}$ ,每个左右有一个处理时间 $t_{j}$,以及最后期限 $d_{j}$ 和 效益 $p_{j}$。假设处理时间都是整数,如何安排处理哪些作业,使效益最高。

思路:所有作业的最后期限,和开始作业的最早时间,之间的时间段,分割成整数段 $0~m$(每一段对应于处理时间中整数的单位)。然后为 $0...m$ 中的每个点 $i$ 维护一个域,表示 $0...i$ 时间段的最高效益及其作业分配情况。

总结

总算有点明白了“动态规划”四个字的含义。我想,如果将递归版本的算法全部展开为非递归的,那么大概可以看到,算法在不断产生局部子问题的最优解,并从最优解中寻找较大子问题的最优价,所有的子问题最优解都被妥善地维护起来,而不是立刻抛弃,这样下次遇到该子问题就可以直接使用结果了。

posted @ 2013-03-13 11:11 一叶斋主人 阅读(...) 评论(...) 编辑 收藏