算法分析-动态规划（矩阵链相乘，最长公共子序列，最长递增子序列）

1、矩阵乘法

　

　　

 

 

 

　　

　　从定义可以看出：只有当矩阵A的列数与矩阵B的行数相等时A×B才有意义。一个m×r的矩阵A左乘一个r×n的矩阵B，会得到一个m×n的矩阵C。在计算机中，一个矩阵说穿了就是一个二维数组。一个m行r列的矩阵可以乘以一个r行n列的矩阵，得到的结果是一个m行n列的矩阵，其中的第i行第j列位置上的数等于前一个矩阵第i行上的r个数与后一个矩阵第j列上的r个数对应相乘后所有r个乘积的和。采用C++语言实现完整的两个矩阵乘法，程序如下所示：

#include <iostream>
using namespace std;
#define A_ROWS        3
#define A_COLUMNS     2
#define B_ROWS        2
#define B_COLUMNS     3
void matrix_multiply(int A[A_ROWS][A_COLUMNS],int B[B_ROWS][B_COLUMNS],int C[A_ROWS][B_COLUMNS]);
int main()
{
    int A[A_ROWS][A_COLUMNS] = {1,0,
                                1,2,
                                1,1};
    int B[B_ROWS][B_COLUMNS] = {1,1,2,
                                2,1,2};
    int C[A_ROWS][B_COLUMNS] = {0};
    matrix_multiply(A,B,C);
    for(int i=0;i<A_ROWS;i++)
    {
        for(int j=0;j<B_COLUMNS;j++)
            cout<<C[i][j]<<" ";
        cout<<endl;
    }
    return 0;
}
void matrix_multiply(int A[A_ROWS][A_COLUMNS],int B[B_ROWS][B_COLUMNS],int C[A_ROWS][B_COLUMNS])
{
    if(A_COLUMNS != B_ROWS)
        cout<<"error: incompatible dimensions."<<endl;
    else
    {
        int i,j,k;
        for(i=0;i<A_ROWS;i++)
            for(j=0;j<B_COLUMNS;j++)
            {
                C[i][j] = 0;
                for(k=0;k<A_COLUMNS;k++)
                    C[i][j] += A[i][k] * B[k][j]; //将A的每一行的每一列与B的每一列的每一行的乘积求和
            }
    }
}

程序测试结果如下所示：

2、矩阵链乘问题描述

　　给定n个矩阵构成的一个链<A₁,A₂,A₃,.......A_n>，其中i=1,2,...n，矩阵A的维数为p_i-1p_i，对乘积 A₁A₂...A_n 以一种最小化标量乘法次数的方式进行加全部括号。

　　注意：在矩阵链乘问题中，实际上并没有把矩阵相乘，目的是确定一个具有最小代价的矩阵相乘顺序。找出这样一个结合顺序使得相乘的代价最低。

3、动态规划分析过程

1）最优加全部括号的结构

　　动态规划第一步是寻找一个最优的子结构。假设现在要计算A_iA_i+1....A_j的值，计算A_i...j过程当中肯定会存在某个k值（i<=k<j）将A_i...j分成两部分，使得A_i...j的计算量最小。分成两个子问题A_i...k和A_k+1...j，需要继续递归寻找这两个子问题的最优解。

　　有分析可以到最优子结构为：假设A_iA_i+1....A_j的一个最优加全括号把乘积在A_k和A_k+1之间分开，则A_i..k和A_k+1..j也都是最优加全括号的。

2）一个递归解

　　设m[i,j]为计算机矩阵A_i...j所需的标量乘法运算次数的最小值，对此计算A_1..n的最小代价就是m[1,n]。现在需要来递归定义m[i,j]，分两种情况进行讨论如下：

当i==j时：m[i,j] = 0，（此时只包含一个矩阵）

当i<j 时：从步骤1中需要寻找一个k（i≤k＜j）值，使得m[i,j] ＝min{m[i,k]+m[k+1,j]+p_i-1p_kp_j} （i≤k＜j）。

3）计算最优代价

　　虽然给出了递归解的过程，但是在实现的时候不采用递归实现，而是借助辅助空间，使用自底向上的表格进行实现。设矩阵Ai的维数为pi-1pi，i=1,2.....n。输入序列为：p=<p0，p1,...pn>，length[p] = n+1。使用m[n][n]保存m[i,j]的代价，s[n][n]保存计算m[i,j]时取得最优代价处k的值，最后可以用s中的记录构造一个最优解。书中给出了计算过程的伪代码，摘录如下：

// p是数组，表示维度
Matrix_Chain_Order = function (p) {

    var n = p.length - 1; //表示几个矩阵
    var m = []; //存最大值
    var s = []; //存路径


    //m[0][1] 表示一个矩阵
    for (var i = 0; i <= n; i++) {
        m[i] = [];
        s[i] = [];
        for (var j = 0; j <= n; j++) {

            m[i][j] = 0;
            s[i][j] = 0;
        }

    }


    //表示几个矩阵相乘
    for (var l = 2; l <= n; l++) {

        for (var i = 1; i + l - 1 <= n; i++) {

            var j = i + l - 1;

            m[i][j] = Number.MAX_VALUE;

            for (var k = i; k < j; k++) {

                var temp = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];

                if (m[i][j] > temp) {

                    m[i][j] = temp;
                    s[i][j] = k;
                }

            }
        }
    }

    return {
        m: m,
        s: s
    };
};


var p = [30, 35, 15, 5, 10, 20, 25];

var str = "";

//构造最优势解
function Print_Optimal_Parens(s, i, j) {

    if (i === j) {

        str += "A" + i;

    } else {
        str += "(";
        Print_Optimal_Parens(s, i, s[i][j]);
        Print_Optimal_Parens(s, s[i][j] + 1, j);

        str += ")";


    }


}


 var obj = Matrix_Chain_Order(p);
 var s = obj.s;
 console.log(obj.m)
 console.log(obj.s)
 Print_Optimal_Parens(s, 1, s.length - 1);
 console.log(str)

一、动态规划算法

 

   事实上，最长公共子序列问题也有最优子结构性质。

   记：

   Xi = <x1,x2,x3,....xi>即X序列的前i个字符（1<= i <= m）(前缀)

   Yj = <y1,y2,y3,....yi>即Y序列的前j个字符（1<= j <= m）(前缀)

   

   假定Z = <z1,z2,z3,...zk>是LCS（X,Y)中的一个。

   ·若xm = yn（最后一个字符相同），则不难用反正法证明：该字符必是X与Y的任一最长公共子序列Z（设长度为k）的最后一个字符，即有zk = xm = yn，且显然有Zk-1∈LCS(Xm-1,Yn-1)，即Z的前缀Zk-1是Xm-1与Yn-1的最长公共子序列。此时，问题化归成求Xm-1与Yn-1的LCS（LCS(X,Y)）的长度等于LCS(Xm-1,Yn-1)的长度加1）。

   ·若xm≠yn，则亦不难用反证法证明：要么Z∈LCS(Xm-1, Y)，要么Z∈LCS(X , Yn-1)。由于zk≠xm与zk≠yn其中至少有一个必成立，若zk≠xm则有Z∈LCS(Xm-1 , Y)；类似的，若zk≠yn 则有Z∈LCS(X , Yn-1)。此时，问题化归成求Xm-1与Y的LCS及X与Yn-1的LCS。LCS(X , Y)的长度为：max{LCS(Xm-1 , Y)的长度, LCS(X , Yn-1)的长度}。

 

   由于上述当xm≠yn的情况中，求LCS(Xm-1 , Y)的长度与LCS(X , Yn-1)的长度，这两个问题不是相互独立的：两者都需要求LCS(Xm-1，Yn-1)的长度。另外两个序列的LCS中包含了两个序列的前缀的LCS，故问题具有最优子结构性质考虑用动态规划法。

 

   也就是说，解决这个LCS问题，你要求三个方面的东西：

   1> LCS（Xm-1，Yn-1）+1；

   2> LCS（Xm-1，Y），LCS（X，Yn-1）；

   3> max{LCS（Xm-1，Y），LCS（X，Yn-1）}；

 

二、动态规划算法解LCS问题

 

2.1 最长公共子序列的结构

 

   最长公共子序列的结构有如下表示：

   

   设序列X=<x1, x2,="" …,="" xm="">和Y=<y1, y2,="" …,="" yn="">的一个最长公共子序列Z=<z1, z2,="" …,="" zk="">，则：

   1> 若 xm=yn，则 zk=xm=yn，且Zk-1是Xm-1和Yn-1的最长公共子序列； 

   2> 若 xm≠yn且 zk≠xm ，则 Z是 Xm-1和 Y的最长公共子序列；

   3> 若 xm≠yn且 zk≠yn ，则 Z是 X和 Yn-1的最长公共子序列；

   其中Xm-1=<x1, x2,="" …,="" xm-1="">，Yn-1=<y1, y2,="" …,="" yn-1="">，Zk-1=<z1, z2,="" …,="" zk-1="">。

 

2.2 子问题的递归结构

 

   由最长公共子序列问题的最优子结构性质可知，要找出Xm=<x1, x2,="" …,="" xm="">和Yn=<y1, y2,="" …,="" yn="">的最长公共子序列，可按如下方式递归的进行：

   ·当xm = yn时，找出Xm-1和Yn-1的最长公共子序列，然后在其尾部加上xm或yn，即可得到X和Y的一个最长公共子序列；

   ·当xm≠yn时，必须解两个子问题，即找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

 

   由此递归结构容易看到最长公共子序列问题具有子问题重叠性质。例如，在计算X和Y的最长公共子序列时，可能要计算出X和Yn-1以及Xm-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题，即计算Xm-1和Yn-1的最长公共子序列。

 

   与矩阵乘积最优计算次序问题类似，我们来建立子问题的最优值的递归关系。用c[i,j]记录序列Xi和Yj的最长公共子序列的长度，其中Xi=<x1, x2,="" …,="" xi="">，Yj=<y1, y2,="" …,="" yj="">。当i = 0或j = 0时，空序列是Xi和Yj的最长公共子序列，故c[i,j] = 0。其他情况下，可得递归关系如下所示：

 

   

2.3 计算最优值

 

   直接利用上节节末的递归式，我们将很容易就能写出一个计算c[i,j]的递归算法，但其计算时间是随输入长度指数增长的。由于在所考虑的子问题空间中，总共只有O(m*n)个不同的子问题，因此，用动态规划算法自底向上地计算最优值能提高算法的效率。

 

   计算最长公共子序列长度的动态规划算法LCS_Length(X,Y)，以序列X=<x1, x2,="" …,="" xm="">和Y=<y1, y2,="" …,="" yn="">作为输入。输出两个数组c[0..m ,0..n]和b[1..m ,1..n]。其中c[i,j]存储Xi与Yj的最长公共子序列的长度，b[i,j]记录指示c[i,j]的值是由哪一个子问题的解达到的，这在构造最长公共子序列时要用到。最后，X和Y的最长公共子序列的长度记录于c[m,n]中。

 

function LCS(A, B) {

    var m = A.length;
    var n = B.length;
    var C = [];
    var b = [];

    for (var i = 0; i <= m; i++) {
        C[i] = [];
        b[i] = [];
        for (var j = 0; j <= n; j++) {

            C[i][j] = 0;
            b[i][j] = 0;
        }
    }


    for (var i = 1; i <= m; i++) {
        for (var j = 1; j <= n; j++) {
            if (A[i - 1] == B[j - 1]) {
                C[i][j] = C[i - 1][j - 1] + 1;
                b[i][j] = 'left_up';
            } else {
                if (C[i - 1][j] >= C[i][j - 1]) {
                    C[i][j] = C[i - 1][j];
                    b[i][j] = 'left';
                } else {
                    C[i][j] = C[i][j - 1];
                    b[i][j] = 'up';
                }
            }
        }
    }
    return {
        C: C,
        b: b
    };
}

function zuiyou(A, b, i, j) {
    if (i === 0 || j === 0) {
        return;
    }
    if (b[i][j] == 'left_up') {
        zuiyou(A, b, i - 1, j - 1);
        console.log(A[i-1]);
    } else if (b[i][j] == 'left') {
        zuiyou(A, b, i - 1, j);

    } else {
        zuiyou(A, b, i, j - 1);
    }
}
var A = ['A', 'B', 'C', 'B', 'D', 'A', 'B'];
var B = ['B', 'D', 'C', 'A', 'B', 'A'];
var len_a = A.length;
var len_b = B.length;


var obj = LCS(A, B);
console.log(obj.C);
console.log(obj.b);


zuiyou(A, obj.b, len_a, len_b);

 最长递增子序列：

一，    最长递增子序列问题的描述

设L=<a₁,a₂,…,a_n>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<a_K1,a_k2,…,a_km>，其中k₁<k₂<…<k_m且a_K1<a_k2<…<a_km。求最大的m值。

二，    第一种算法：转化为LCS问题求解

设序列X=<b₁,b₂,…,b_n>是对序列L=<a₁,a₂,…,a_n>按递增排好序的序列。那么显然X与L的最长公共子序列即为L的最长递增子序列。这样就把求最长递增子序列的问题转化为求最长公共子序列问题LCS了。

最长公共子序列问题用动态规划的算法可解。设Li=< a₁,a₂,…,a_i>,Xj=< b₁,b₂,…,b_j>，它们分别为L和X的子序列。令C[i,j]为Li与Xj的最长公共子序列的长度。则有递推方程看上面。

这可以用时间复杂度为O(n²)的算法求解，由于这个算法上课时讲过，所以具体代码在此略去。求最长递增子序列的算法时间复杂度由排序所用的O(nlogn)的时间加上求LCS的O(n²)的时间，算法的最坏时间复杂度为O(nlogn)＋O(n²)＝O(n²)。

三，    第二种算法：动态规划法

设f(i)表示L中以a_i为末元素的最长递增子序列的长度。则有如下的递推方程：

f[i] = max(f[j]) + 1

这个递推方程的意思是，在求以a_i为末元素的最长递增子序列时，找到所有序号在L前面且小于a_i的元素a_j，即j<i且a_j<a_i。如果这样的元素存在，那么对所有a_j,都有一个以a_j为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以a_i为末元素的最长递增子序列，等于以使f(j)最大的那个a_j为末元素的递增子序列最末再加上a_i；如果这样的元素不存在，那么a_i自身构成一个长度为1的以a_i为末元素的递增子序列。

 

var arr = [1, 5, 8, 2, 3, 4];

function  lis(arr) {

    var n = arr.length;
    var c = [];

    for (var i = 0; i <= n; i++) {

        c[0] = 0;

    }


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

        c[j] = 1;

        for (var k = 1; k < j; k++) {
            if (arr[j-1] > arr[k-1] && c[k] >= c[j] - 1) {

                c[j] = c[k] + 1;

            }

        }

    }

    return c;
}

var c =lis(arr);
console.log(c);