算法导论（八）——动态规划&贪婪算法

                                    算法导论（八）——动态规划&贪婪算法

【主要参考资料：MIT算法导论视频，《数据结构，算法与应用，c++语言描述》】

动态规划方法通常用来求解最优化问题，从可行解中寻找具有最优值的解，得到的是问题的一个最优解(an optimal solution)。

求解的问题需具备要素：最优子结构和子问题重叠。算法对每个子问题只求解一次，将其解保存在一个表格，从而无需每次求解一个子问题时都重新计算，避免了这种不必要的计算工作。是付出额外的内存空间来节省计算空间。

 

动态规划是基于递推公式或初始状态，当前子问题的解由上一次子问题的解推出，只需要多项式时间复杂度。它的本质，是对问题状态的定义和状态转移方程的定义。

 

我们通常按如下4个步骤来设计一个动态规划算法：

•1.刻画一个最优解的结构特征。

•2.递归地定义最优解的值。

•3.计算最优解的值，通常采用自底向上的方法。

•4.利用计算出的信息构造一个最优解。

 

1.    最长公共子序列（LCS）。

背景;x序列有m个元素，y序列有n个元素，最坏情况下，找到一个lcs需要指数时间

理论：动态规划的特征

①（最优子结构的性质）一个问题的最优解包含了其子问题的最优解

——令z为LCS(x,y)，则z的前缀为x的前缀和y的前缀的LCS。

②重叠子问题：递归法解决时有少量的子问题重复出现

——画出递归树，树高m+n，指数时间，有很多重复，LCS有m*n个独立子空间。

解决方案：

①备忘法（自顶而下，对已经计算过的内容，及时记录）

2.    数塔问题：

http://blog.csdn.net/baidu_28312631/article/details/47418773

数字三角形中寻找一条从顶部到底边的路径（每一步都只能往左下或右下走），使得路径上所经过的数字之和最大。

 

3.    钢条切割

http://blog.csdn.net/nxiangbo/article/details/51111391

给一段钢条，对其进行切割，每一段钢条都有不同的价值。要找到最优的切割方案，使切割成的钢条价值最大。

①带备忘录的自顶而下法：记录每个计算过的值 【记录中间解】

②自底而上法：将子问题按照规模排序，按照有小到大的顺序进行求解。当求解某个子问题时，它所依赖的那些更小的子问题都已经求解完毕，结果已经保存。【通过对问题求解顺序的合理安排，达到避免重复】

两种方法具有相同的复杂度，自顶而下的方法并没有解决所有可能的子问题，由于没有频繁的递归函数的调用开销，自底而上的方法复杂度通常会比自顶而下的方法复杂度小

 

4.    矩阵连乘(钢条问题的升级版)

http://blog.sina.com.cn/s/blog_5d1f04810100x4qe.html

给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1,2,…,n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。

m[i][j]=m[i][k]+m[k+1][j]+pipk+1pj+1

 

5.    最优二叉搜索树

http://blog.csdn.net/xiajun07061225/article/details/8088784

给定一个由n个互异的关键字组成的有序序列K={k1<k2<k3<,……,<kn}和它们被查询的概率P={p1,p2,p3,……,pn}，要求构造一棵二叉查找树T，使得查询所有元素的总的代价最小。

代价可以定义为：比如从根节点到目标节点的路径上节点数目，即所发现的节点的深度加1。

n+1个“虚拟键”d0,d1,...,dn，他们代表不在K内的值。

定义e[i,j]为包含关键字ki,...,kj的最优二叉查找树的期望代价，最终要计算的是e[1,n]。

可以说贪心问题是DP问题的特例。

动态规划：全局最优解中一定包含某个局部最优解，但不一定包含前一个局部最优解，因此需要记录之前的所有最优解。贪婪算法：每一步的最优解一定包含上一步的最优解。（硬币问题可用DP,但不一定能用贪婪算法）

 

贪婪算法：作出在当前看来最好的选择

逐步构造最优解。每一步都在一定的标准下，做出一个最优决策。

不能保证得到最优解，但所得的结果通常非常接近最优解，这种算法称为启发式方法。

适用的前提：局部最优策略能导致产生全局最优解。

应用：

背包问题（价值密度，k阶优化）；

拓扑排序：【从剩余顶点中选择一个点j，它没有入边（i,j），其中i不在序列中】

用栈保存候选顶点，用一维数组表示各顶点的入度（入度为0即是候选点，否则要及时更新）

//生成拓扑序列

booltopologicalOeder(int *theOrder){

    //若能生成拓扑序列，则结果保存在theOrder

    //否则返回false,说明有向图中含有环

    //点的下标从1开始，1~n

    int n=numberofVertices();

    //计算每个顶点的入度

    int *inDegree=new int[n+1];

    fill(inDegree,inDegree+n+1,0);

    for(int i=1;i<=n;i++){

      vertexIterator<T> *ii=iterator(i);

      int u;//其邻接点

      while((u=ii->next())!=0)

      inDegree[u]++;

    }

     //入度为0的点入栈

     arrayStack<int> stack;

     for(int i=1;i<=n;i++){

     if(inDegree[i]==0)

     stack.push(i);

     }

     //生成拓扑序列

     int j=0;

     while(!stack.empty()){

       int nextVertex=stack.top();

       stack.pop();

       theOrder[j++]=nextVertex;

       vertexIterator<T> *inextVertex=iterator(nextVertex);

       int u;

       while((u=inextVertex->next())!=0){

         inDegree[u]--;

         if(inDegree[u]==0)

           stack.push(u);

       }

 

     }

     return (j==n);

}

 

二分覆盖（寻找最小覆盖）；【从一个集合中选择一个顶点，它最大数量地覆盖了另一个集合中还未被覆盖的元素】

 

单源最短路径；【从还没到达的定点中，选择可以产生最短路径的顶点】——Dijkstra

voidshortestPaths(int sourceVertex,T* distanceFromSource,int* predecessor){

    //distanceFromSource保存从sourceVertex开始的最短路径

    //predecessor表示某点从源开始的路径中的前驱节点

    //节点1~n

    if(sourceVertex<1||sourceVertex>n)

      return;

    graphChain<int> newRechableVertices;

    //初始化

    for(int i=1;i<=n;i++){

    distanceFromSource[i]=a[sourceVertex][i];//邻接矩形

    if(distanceFromSource[i]==noEdge)

      predecessor[i]=-1;

    else{

      predecessor[i]=sourceVertex;

      newRechableVertices.insert(0,i);

    }

    }

     distanceFromSource[sourceVertex]=0;

     predecessor[sourceVertex]=0;

     //更新

     while(!newRechableVertices.empty()){

     //从还没到达的定点中，选择可以产生最短路径的顶点

     chain<int>::iteratorinewRechableVertices=newRechableVertices.begin();

     int v=*inewRechableVertices;

    while(inewRechableVertices!=newRechableVertices.end()){

        int w=*inewRechableVertices;

        inewRechableVertices++;

       if(distanceFromSource[v]>distanceFromSource[w])

           v=w;

     }//找到了最小值v

     //接着找到达v的最短路径

     newRechableVertices.eraseElement(v);

     for(int j=1;j<=n;j++){

        if(a[v][j]!=noEdge&&(predecessor[j]==-1||distanceFromSource[j]>distanceFromSource[v]+a[v][j])){

         distanceFromSource[j]=distanceFromSource[v]+a[v][j];

          if(predecessor[j]==-1)

            newRechableVertices.insert(0,j);

           predecessor[j]=v;

        }

     }

     }

}

最小成本生成树:选择n-1条边，使成本最小

代码参考：https://github.com/lymcool/Introduction-to-Algorithms-Data-Structures/blob/master/MiniSpanTree.cpp

①Kruskal算法:【“加边”，选择成本最小且不会产生环路的边加入】

boolkruskal(weightEdge<T> *spanningTreeEdges){

// 加权无向图不联通时，返回false

//否则，最小成本生成树的边存储在spanningTreeEdges0~n-2中

  int n=numberifVertices();

  int e=numberofEdges();

  weightEdge<T> *edges=newweightEdge<T> [e+1];//存储边

  int k=0;

  for(int i=1;i<=n;i++){

    vertexIterator<T> *ii=iterator(i);

    int j;

    T w;

    while((j=ii->next(w))!=0){

       if(i<j)

         edge[++k]=weightEdge<int>(i,j,w);

    }

  }

  //把边插入小根堆

  minHeap<weightEdge<T>> heap(1);

  heap.initialize(edge,e);

  //union/find结构

  fastUnionFind uf(n);

  //按照权重递增顺序提取边，然后决定舍弃或选入

  k=0;

  while(e>0&&k<n-1){

    weightEdge<T> x=heap.top();

    heap.pop();

    e--;

    int a=uf.find(x.vertex1());

    int b=uf.find(x.vertex2());

    if(a!=b){

       spanningTreeEdges[k++]=x;

       uf.unite(a,b);

    }

  }

  return (k==n-1)

}

② Prim算法:【“加点”，选择成本最小且加入后能形成树的边——有一个顶点相连】

③Sollin算法：【对所有顶点选择最小成本边(有重复)，再对各个子树选择最小成本边，将其连接】