北京工业大学算法设计分析一纸开卷

时间复杂性分析：以语句为单位；统计基本语句的执行次数；每执行一次，认为是一个时间单位。

O的定义：如果存在正常数c和自然数n0，使得当n≥n0时有f(n) ≤cg(n)，则称函数f(n)当n充分大时上有界，且g(n)是它的一个上界，记f(n)= O(g(n))。

Ω的定义当n ≥n0时有f(n) ≥cg(n)，记为f(n)=Ω(g(n))θ的定义：当n ≥n0时，c1g(n) ≤f(n) ≤c2g(n)则记f(n)= θ(g(n))。

即f(n)与g(n)同阶。

1.根据符号O的定义，存在正常数Ci和自然数Ni，使得对所有的n>=N有i=1.2，f（n）<=C1s(n)，g(n) <=C2r(n)所以f（n）+ g(n) <= C1s(n)+ C2r(n)，f（n）*g(n)<= C1C2s(n)r(n)；令C3=max（C1,C2），C4=C1C2；则：f（n）+ g(n) <= C3[s(n)+ r(n)]=O(s(n)+ r(n))f（n）*g(n) <= C4*s(n)*r(n)=O(s(n)* r(n))分治算法的基本思想：是将一个规模为n的问题分解为a个规模较小的子问题，递归地解这些子问题，然后将各个子问题的解合并得到原问题的解。

贪心算法的设计思路是：总是做出在当前看来最好的选择，即贪心算法并不是从整体最优考虑，它所做的选择只是在某种意义上的局部最优选择。

贪心法的基本要素：1. 贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。

2.最优子结构性质：当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。

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

贪心算法与动态规划算法的差异：共同点：求解的问题都具有最优子结构性质。

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

动态规划算法:保存已解决的子问题的答案，在需要时找出已求得的答案，以避免大量的重复计算，从而得到多项式时间算法。

基本步骤：找出最优解的性质，并描述其结构特征。

递归地定义最优值。

以自底向上的方式计算出最优值。

根据计算最优值时得到的信息，构造最优解。

2.假设某算法在输入规模为n时的计算时间为：T（n）=3*2n ，在A 型计算机上实现并完成该算法的时间为t秒，现有更先进的B型计算机，其运算速度为A型计算机的64倍。

试求出若在先进的B型机上运行同一算法在则T秒内能求解输入规模为多大的问题？64*3*2^n=2^6*3*2^n=3*2^(n+6)；T=T(n)=3*2^n n=log2(T/3)设新机器输入规模为n1,则：n1=log2(3*2^(n+6)/3)=n+6 3. 试说明为什么“在现代计算机上运行指数（如2n）时间算法是不可能的，要想在顺序处理机上扩大所处理问题的规模，有效的途径是降低算法计算复杂度的数量级，而不是提高计算机的速度”。

一个计算时间为Ο(1)的算法，它的基本运算执行的次数是固定的，因此，总的时间由一个常数(即，零次多项式)来限界，而一个时间为Ο(n2)的算法则由一个二次多项式来限界。

多项式时间关系为Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n n)指数时间关系为Ο(2n)＜Ο(n!)＜Ο(n n)。

当n取得很大时，指数时间算法和多项式时间算法在所需时间上非常悬殊，对于任意的m≥0，总可以找到n0，当n≥n0时，有2n＞nm。

因此，只要有人能将现有指数时间算法中的任何一个算法简化为多项式时间算法，那就取得了一个伟大的成就。

由这些结果可看出，当数据集的规模(即n的取值)很大时，要在现代计算机上运行具有比Ο(nlog2n)复杂度还高的算法往往是很困难的。

尤其是指数时间算法，它只有在n值取得非常小时才实用。

要想在顺序处理机上扩大所处理问题的规模，有效的途径是降低算法的计算复杂度的数量级，而不是提高计算机的速度。

1.试用简短的语言说明“建立一个问题复杂性的下界要比确定它的上界困难得多！”其复杂性上界是已知求解该问题的最快算法的费用，而复杂性下界只能通过理论证明来建立。

寻求某个问题的计算复杂性上界，只要研究一个算法的复杂性即可。

但是要寻求同一问题的计算复杂性下界，则必须考察所有的解决该问题的算法，证明一个问题的复杂性下界就需要证明不存在任何复杂性低于下界的算法。

2.满足何种性质的问题被称为称为NP完全问题？请简述研究NP完全问题的意义；（1）NP即是多项式复杂程度的非确定性问题。

而如果任何一个NP问题都能通过一个多项式时间算法转换为某个NP问题，那么这个NP问题就称为NP完全问题。

如果一个NP完全问题能在多项式时间内得到解决，那么NP中的每一个问题都可以在多项式时间内解决。

NP完全性理论的重要性:知道一个问题是NP完全的就给我们提供了有价值的信息，告诉我们采用什么样的途径可以是最富有成效的。

一定不要去优先寻找有效的、精确的算法。

现在比较适当的途径是集中精力致力于其他较低目标的方法。

寻找在大多数情况下看来能快速运算的算法，虽然不能保证它在任何情况下都能快速地运算。

或者你甚至可以放松问题的某些方面，寻找一个只能给出满足大部分要求的快速算法。

简言之，NP完全性理论的初步应用是帮助算法设计人员找到最有可能得到有用的算法的努力方向 3.简要阐述“论证某一问题的最优子结构性质”时的一般方法；最优解包含着其子问题的最优解。

这种性质称为最优子结构性质。

在分析问题的最优子结构性质时，首先假设由问题的最优解导出的子问题的解不是最优的，然后再设法说明在这个假设下可构造出比原问题最优解更好的解，从而导致矛盾。

利用问题的最优子结构性质，以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解。

最优子结构是问题能用动态规划算法求解的前提。

证明0/1背包问题满足最优子结构性质。

证明：假设(x1,x2,...,xn-1)不是最优解，而(y1,y2,...,yn-1)是最优解。

由此可知（写公式）: 上述结果说明：(y1,y2,...,yn-1,xn)是所给0-1背包问题的更优解。

与前提矛盾。

4.对于一个具体问题，要确定它是否具有贪心选择性质，我们必须证明每一步所作的贪心选择最终导致问题的一个整体最优解。

首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。

而且作了贪心选择后，原问题简化为一个规模更小的类似子问题。

然后，用数学归纳法证明，通过每一步作贪心选择，最终可得到问题的一个整体最优解。

社会名流问题：给定一个n×n邻接矩阵，确定是否存在一个i，其满足在第i列所有项（除了第ii项）都为1，并且第i行所有项（除了第ii项）都为0。

大致的算法思路：随便取一个非对角线元素，比如Array[i][j]，如果Array[i][j]=0成立，则j不是社会名流，于是删去第j行和第j列。

同样，如果Array[i][j]=1成立，则删去第i行和第i列；总之，无论对应项取何值，都可以删去一行和一列，因此整个操作只耗费O(n)的时间。

重复此操作直至剩下最后一个元素。

最后，检验该元素是否为社会名流即可。

如果该元素不是，则该群人中不存在社会名流。

在最坏情况下用3n/2-2次的比较找出A中的最大值和最小值使用一个快速排序的迭代模型可以使原递归算法所需的栈空间总量减至O（logn）struct node{int low,high;}st[10000];void quicksort2(int data[],int s,int t){int top=-1,low,high; top++; st[top].low=s; st[top].high=t;while(top>-1){ low=st[top].low; high=st[top].high;top--; intw;if(low<high){w=split(data,low,high);//或者split2st[++top].low=low;st[top].high=w-1; st[++top].low=w+1;st[top].high=high; }}4.试说明如何修改快速排序算法，使它在最坏情况下的计算时间为O(nlgn)。

可以通过减少递归栈的使用进行优化，快速排序的实现需要消耗递归栈的空间，而大多数情况下都会通过使用系统递归栈来完成递归求解。

对系统栈的频繁存取会影响到排序的效率。

在数据量较大时，快速排序的复杂度为O(nlgn)。

当数据集较小时，快排的复杂度有向O(n^2)发展的趋势，此时不必继续递归调用快速排序算法，使用插入排序代替快速排序。

STL中sort就是用的快排+插入排序的，使得最坏情况下的时间复杂度也是O(nlgn)．这一改进被证明比持续使用快速排序算法要有效的多。

struct node {int low,high;}st[10000]; void quicksort2(int data[],int s,int t){ int top=-1,low,high; top++; st[top].low=s; st[top].high=t; while(top>-1){ low=st[top].low; high=st[top].high;top--; int w; if(low<high){w=split(data,low,high);#include<stdio.h>#include<stdlib.h>#include "stdafx.h"#include <iostream>using namespace std;int V[200][200];//前i个物品装入容量为j的背包中获得的最大价值int max(int a,int b){if(a>=b)return a;else return b;}int KnapSack(int n,int w[],int v[],int x[],int C){int i,j,t,k,lager,a,b;int K[200][200]={0};for(i=0;i<=n;i++) //边界值 v(i,0)=v(0,j)=0;V[i][0]=0;for(j=0;j<=C;j++)V[0][j]=0;for(j=1;j<=C;j++) //矩阵V[n+1][C+1]for(i=1;i<=n;i++){if(j<w[i]) //物品i的质量大于背包容量{V[i][j]=V[i-1][j];K[i][j]=-1; //物品i放不下}else{t=j/w[i];lager=V[i-1][j]; //暂且认为V(i-1,j)为最优解,便于之后比较for(k=1;k<=t;k++){b=V[i-1][j-k*w[i]]+k*v[i];lager=max(lager,b); //最大价值}V[i][j]=lager;if(V[i][j] == V[i-1][j]){K[i][j]=0; //物品i能放下,但非最优解}else{for(k=1;k<=t;k++){if(V[i][j] == V[i-1][j-k*w[i]]+k*v[i]) break;}K[i][j]=k; //物品i放入k次为最优解}}}printf("matrix V[n][C] is:\n");for(i=0;i<=n;i++){for(j=0;j<=C;j++){printf("%3d ",V[i][j]);}printf("\n");}printf("matrix K[n][C] is:\n");for(i=0;i<=n;i++){for(j=0;j<=C;j++){printf("%3d ",K[i][j]);}printf("\n");}j=C;for(i=n;i>=1;i--){if(V[i][j]==V[i-1][j]){x[i]=0;}else{x[i]=K[i][j];j=j-K[i][j]*w[i];}}printf("最优装法为:\n");for(i=1;i<=n;i++)printf("%d ",x[i]);printf("\n");return V[n][C];}int main(int argc, char* argv[]){int s; //获得的最大价值int w[15]; //物品的重量int v[15]; //物品的价值int x[15]; //物品的选取状态int n,i;int C; //背包最大容量n=5;printf("背包的最大容量、可选物品种类:\n"); //scanf("%d%d",&C,&n);cin>>C>>n;printf("各物品的重量:\n");for(i=1;i<=n;i++)cin>>w[i];//scanf("%d",&w[i]);printf("各物品的价值:\n");for(i=1;i<=n;i++)cin>>v[i];//scanf("%d",&v[i]);s=KnapSack(n,w,v,x,C);printf("背包能装入的最大价值为:\n");printf("%d\n",s);system("PAUSE");return 0;}TSP问题：数学语言描述：设需要经过的城市为k=0,1,2,3,4;d(i, V’)=min{Cik +d(k, V’-{k})}Cik表示你选择的城市和城市i的距离，d(k, V’-{k})是一个子问题。