算法分析复习

完全只为应付考试

1、分治法的基本思想（分-治-合）

2、动态规划法的基本思想

3、贪心算法的基本思想

4、分治法与动态规划法的主要区别

5、动态规划算法的两个基本要素

6、设计动态规划算法的四个基本步骤。

7、备忘录方法与动态规划法的区别

8、贪心算法的概念。

9、贪心算法的两个基本要素

10、贪心算法与动态规划算法的差异

 

 

大概答案：

1、分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之

2、动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，但是经分解得到的子问题往往不是互相独立的。

3、贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择

4、① 分治法将分解后的子问题看成相互独立的.② 动态规划将分解后的子问题理解为相互间有联系,有重叠部分.

5、1  最优子结构性质 2 子问题重叠性质

6、①找出最优解的性质，并刻划其结构特征。②递归地定义最优值。3、以自底向上的方式计算出最优值。4、根据计算最优值时得到的信息，构造最优解

7、动态规划是自低向上 ，备忘录方法是自顶向下，递归是自顶向下，动态规划每个子问题都要解一次，但不会求解重复子问题；备忘录方法只解哪些确实需要解的子问题；递归方法每个子问题都要解一次，包括重复子问题•

8、

9、1、贪心选择性质2、最优子结构性质

10、动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每做一次贪心选择就将所求问题简化为规模更小的子问题。

 

 

分治法：二分搜索、循环赛日程表

动态规划法：矩阵连乘、最长公共子序列、0-1背包问题、最大字段和

贪心算法：活动安排问题、单源最短路径

 

 

 

 

1、求下列函数的渐近表达式

(1)3n+10n=O(n)

(2)n/10+2=O(2)

(3)21+1/n=O(1)

(4)10log3=O(n)

 

 

*算法分析中，记号O表示渐进上界，记号表示渐进下界， 记号表示紧渐进界。

 

 

二分搜索技术

template<class Type>

int BinarySearch(Type a[], const Type&x, int l, int r)

{

    while (r >= l){

       int m = (l+r)/2;

       if (x == a[m]) return m;

       if (x < a[m]) r = m-1; else l = m+1;

       }

   return -1;

}

 

循环赛日程表

//求出矩阵A[i:j]的最少数乘次数m[i][j]，和记录矩阵A[i:j]此时的断开位置s[i][j]

voidMatrixChain(int *p, int n, int m[100][100], int s[100][100] )

{

        for (int i = 1; i <= n; i++) m[i][i]= 0; //初始化，使用矩阵的下标从1，1开始

       

              for (int r = 2; r <= n; r++)

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

              int j=i+r-1;

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

              s[i][j] = i;

              for (int k = i+1; k < j; k++){

                 int t = m[i][k] + m[k+1][j] +p[i-1]*p[k]*p[j];

                 if (t < m[i][j]) { m[i][j]= t; s[i][j] = k;}

              }

          }

}

//构造最优解

//利用断开位置s[i][j]输出矩阵A[i:j]的最优加括号方式

voidprint_optimal(int s[100][100], int i ,int j, int a[])

{

       if(i==j)   cout<<"A["<<a[i-1]<<","<<a[i]<<"]";

       else{

              cout<<" ( ";

              print_optimal(s,i,s[i][j],a);

              print_optimal(s,s[i][j]+1,j,a);

              cout<<" ) ";

       }

}

 

最长公共子序列

//求X={x1,x2,…,xm}和Y={y1,y2,…,yn}的最长公共子序列长度c[i][j]，并用b[i][j]记录相应的三种情况。

void LCSLength(int m，int n，char *x，char*y，int **c，int **b)

{ 

      int i，j;

      for (i = 1; i <= m; i++) c[i][0] = 0;

      for (i = 1; i <= n; i++) c[0][i] = 0;

      for (i = 1; i <= m; i++)

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

             if (x[i]==y[j]) {

                  c[i][j]=c[i-1][j-1]+1;b[i][j]=1;}

             else if (c[i-1][j]>=c[i][j-1]){

                  c[i][j]=c[i-1][j];b[i][j]=2;}

             else { c[i][j]=c[i][j-1];b[i][j]=3; }

             }

}

构造最长公共子序列

//打印出X={x1,x2,…,xm}和Y={y1,y2,…,yn}的最长公共子序列

void LCS(int i，intj，char *x，int **b)

{

     if (i ==0 || j==0) return;

     if (b[i][j]== 1){ LCS(i-1，j-1，x，b); cout<<x[i]; }

     else if (b[i][j]== 2) LCS(i-1，j，x，b);

     else LCS(i，j-1，x，b);

}

最大子段和问题的动态规划算法

intmaxsum(int n,int *a)

{

       int sum=0,b=0;

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

       {

              if(b>0)b+=a[i];

              else b=a[i];

              if(b>sum)sum=b;

       }

       return sum;

       }

}

 

活动安排问题

//贪心算法实现活动安排

voidGreedySelector(int n, int *s, int *f, int *A)

{

       //用集合A来存储所选择的活动

       A[1] = true;  //默认从第一次活动开始执行

       int j = 1;  //j记录最近一次加入到A中的活动

       for (int i = 2; i <= n; i++)

       {

              //f[j]为当前集合A中所有活动的最大结束时间

              //活动i的开始时间不早于最近加入到集合A中的j的时间f[j]

              if (s[i] >= f[j])

              {

                     A[i] = true; //当A[i]=true时，活动i在集合A中

                     j = i;

              }

              else A[i] = false;

       }

}

 

背包问题

背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解

/*

*intn：n个集装箱

*floatM:背包所能容纳的重量

*floatv[]：各个箱子的体积

*floatw[],：各个箱子的重量

*floatx[]：

*/

voidKnapsack(int n,float M,float v[],float w[],float x[])

{

       Sort(n,v,w);

       int i;

       for (i=1;i<=n;i++) x[i]=0;

       float c=M;

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

          if (w[i]>c) break;

          x[i]=1;

          c-=w[i];

          }

       if (i<=n) x[i]=c/w[i];

}

 

 

 

单源最短路径

 

 

网上的一些题目：

http://3y.uu456.com/bp_6mk7n29dkt7u3cm9al89_1.html

http://www.doc88.com/p-7304371972650.html

 

 

填空题

动态规划算法的基本要素为：最优子结构性质与重叠子问题性质

1)      算法分析中，记号O表示渐进上界，记号表示渐进下界， 记号表示紧渐进界。

2)      回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。

3)      分支限界法在问题的解空间树中，按广度优先策略，从根结点出发搜索解空间树。

所谓贪心选择性质是指（所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到）。

所谓最优子结构性质是指（问题的最优解包含了其子问题的最优解）。

回溯法是回溯法是指（具有限界函数的深度优先生成法）。

回溯法的算法框架按照问题的解空间一般分为（子集树）算法框架与（排列树）算法框架。

4)      二分搜索算法是利用分治策略实现的算法。

5)      衡量一个算法好坏的标准是时间复杂度低

6)      最长公共子序列算法利用的算法是动态规划法

7)      Strassen矩阵乘法是利用分治策略实现的算法

8)      回溯法搜索状态空间树是按照深度优先遍历的顺序。

9)      算法中通常以自底向下的方式求解最优解的是动态规划法

10)   背包问题的贪心算法所需的计算时间为O（nlogn）

11)   0-1背包问题的回溯算法所需的计算时间为O（n2n）

12)   用动态规划算法解决最大字段和问题，其时间复杂性为n

13)   一个算法就是一个有穷规则的集合，其中之规则规定了解决某一特殊类型问题的一系列运算，此外，算法还应具有以下五个重要特性:_有穷性，确定性，可行性，输入，输出。

1.算法的复杂性有         时间          复杂性和    空间         复杂性之分。

2、程序是    算法     用某种程序设计语言的具体实现。

3、算法的“确定性”指的是组成算法的每条  指令  是清晰的，无歧义的。

4.矩阵连乘问题的算法可由  动态规划  设计实现。

6、算法是指解决问题的   一种方法  或  一个过程 。

7、从分治法的一般设计模式可以看出，用它设计出的程序一般是  递归算法  。

8、问题的    最优子结构性质  是该问题可用动态规划算法或贪心算法求解的关键特征。

9、以深度优先方式系统搜索问题解的算法称为   回溯法  。

10、数值概率算法常用于  数值问题   的求解。

15、使用回溯法进行状态空间树裁剪分支时一般有两个标准：约束条件和目标函数的界，N皇后问题和0/1背包问题正好是两种不同的类型，其中同时使用约束条件和目标函数的界进行裁剪的是    0/1背包问题   ，只使用约束条件进行裁剪的是    N皇后问题     。

16、  贪心选择性质  是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。

17、矩阵连乘问题的算法可由   动态规划   设计实现。

19.贪心算法的基本要素是     贪心选择   质和   最优子结构              性质。

21. 动态规划算法的基本思想是将待求解问题分解成若干    子问题        ，先求解 子问题          ，然后从这些  子问题        的解得到原问题的解。

23、大整数乘积算法是用   分治法   来设计的。

26、  贪心选择性质  是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。

27.快速排序算法是基于      分治策略        的一种排序算法。

30.回溯法是一种既带有   系统性             又带有       跳跃性    的搜索算法。

33．回溯法搜索解空间树时，常用的两种剪枝函数为   约束函数  和    限界函数          。

34.任何可用计算机求解的问题所需的时间都与其   规模   有关。

35.快速排序算法的性能取决于  划分的对称性 。

37. 图的m着色问题可用 回溯   法求解，其解空间树中叶子结点个数是   mⁿ  ，解空间树中每个内结点的孩子数是   m     。