算法设计与分析教案文档格式.docx
《算法设计与分析教案文档格式.docx》由会员分享，可在线阅读，更多相关《算法设计与分析教案文档格式.docx（40页珍藏版）》请在冰豆网上搜索。
⑶程序设计语言
能由计算机执行
抽象性差，对语言要求高
算法需要验证
将算法写成子函数
#include<
>
intCommonFactor（intm,intn）
{
intr=m%n;
while（r!
=0）
m=n;
n=r;
r=m%n;
}
returnn;
voidmain（）
cout<
<
CommonFactor（63,54）<
endl;
⑷伪代码——算法语言
伪代码（Pseudocode）：
介于自然语言和程序设计语言之间的方法，它采用某一程序设计语言的基本语法，操作指令可以结合自然语言来设计。
表达能力强，抽象性强，容易理解
7±
2
=m%n;
2.循环直到r等于0
=n;
=r;
3.输出n;
算法设计的一般过程
1．理解问题
2．预测所有可能的输入
3.在精确解和近似解间做选择
4.确定适当的数据结构
5．算法设计技术
6．描述算法
7．跟踪算法
8．分析算法的效率
9．根据算法编写代码
算法分析
算法分析（AlgorithmAnalysis）：
对算法所需要的两种计算机资源——时间和空间进行估算
时间复杂性（TimeComplexity）
空间复杂性（SpaceComplexity）
算法分析的目的：
设计算法——设计出复杂性尽可能低的算法
选择算法——在多种算法中选择其中复杂性最低者
时间复杂性分析的关键：
问题规模：
输入量的多少；
基本语句：
执行次数与整个算法的执行时间
成正比的语句
for（i=1;
i<
i++）
for（j=1;
j<
j++）
x++;
问题规模：
n
基本语句：
x++
渐进符号
1.大O符号
定义若存在两个正的常数c和n0，对于任意n≥n0，都有T（n）≤c×
f（n），则称T（n）=O（f（n））
2.大Ω符号
定义若存在两个正的常数c和n0，对于任意n≥n0，都有T（n）≥c×
g（n），则称T（n）=Ω（g（n））
3.Θ符号
定义若存在三个正的常数c1、c2和n0，对于任意n≥n0都有c1×
f（n）≥T（n）≥c2×
f（n），则称T（n）=Θ（f（n））
例：
T（n）＝5n2＋8n＋1
当n≥1时，5n2＋8n＋1≤5n2＋8n＋n
＝5n2＋9n≤5n2＋9n2≤14n2＝O（n2）
当n≥1时，5n2＋8n＋1≥5n2＝Ω（n2）
∴当n≥1时，14n2≥5n2＋8n＋1≥5n2
则：
5n2＋8n＋1＝Θ（n2）
定理若T（n）=amnm+am-1nm-1+…+a1n+a0（am>
0），则有T（n）=O（nm）且T（n）=Ω（nm），因此，有T（n）=Θ（nm）。
最好、最坏和平均情况
在一维整型数组A[n]中顺序查找与给定值k相等的元素（假设该数组中有且仅有一个元素值为k）
intFind（intA[],intn）
for（i=0;
n;
if（A[i]==k）break;
returni;
结论：
如果问题规模相同，时间代价与输入数据有关，则需要分析最好情况、最坏情况、平均情况。
最好情况：
出现概率较大时分析
最差情况：
实时系统
平均情况：
已知输入数据是如何分布的，
通常假设等概率分布
非递归算法的分析
算法——非递归算法、递归算法
求数组最小值算法
intArrayMin（inta[],intn）
min=a[0];
if（a[i]<
min）min=a[i];
returnmin;
非递归算法分析的一般步骤：
1.决定用哪个（或哪些）参数作为算法问题规模的度量
2.找出算法中的基本语句
3.检查基本语句的执行次数是否只依赖于问题规模
4.建立基本语句执行次数的求和表达式
5.用渐进符号表示这个求和表达式
关键：
建立一个代表算法运行时间的求和表达式，然后用渐进符号表示这个求和表达式。
递归算法的分析
关键：
根据递归过程建立递推关系式，然后求解这个递推关系式。
1.猜测技术:
对递推关系式估计一个上限，然后（用数学归纳法）证明它正确。
2.扩展递归技术
3.通用分治递推式
大小为n的原问题分成若干个大小为n/b的子问题，其中a个子问题需要求解，而cnk是合并各个子问题的解需要的工作量。
算法的后验分析
算法的后验分析（Posteriori）也称算法的实验分析，它是一种事后计算的方法，通常需要将算法转换为对应的程序并上机运行。
一般步骤：
1.明确实验目的
2.决定度量算法效率的方法，为实验准备算法的程序实现
3.决定输入样本，生成实验数据
4.对输入样本运行算法对应的程序，记录得到的实验数据
5.分析得到的实验数据
表格法记录实验数据
散点图记录实验数据
第4章分治法
概述
分治法的设计思想
将一个难以直接解决的大问题，划分成一些规模较小的子问题，以便各个击破，分而治之。
更一般地说，将要求解的原问题划分成k个较小规模的子问题，对这k个子问题分别求解。
如果子问题的规模仍然不够小，则再将每个子问题划分为k个规模更小的子问题，如此分解下去，直到问题规模足够小，很容易求出其解为止，再将子问题的解合并为一个更大规模的问题的解，自底向上逐步求出原问题的解。
启发式规则：
1.平衡子问题：
最好使子问题的规模大致相同。
也就是将一个问题划分成大小相等的k个子问题（通常k＝2），这种使子问题规模大致相等的做法是出自一种平衡（Balancing）子问题的思想，它几乎总是比子问题规模不等的做法要好。
2.独立子问题：
各子问题之间相互独立，这涉及到分治法的效率，如果各子问题不是独立的，则分治法需要重复地解公共的子问题。
分治法的典型情况
分治法的求解过程
一般来说，分治法的求解过程由以下三个阶段组成：
（1）划分：
既然是分治，当然需要把规模为n的原问题划分为k个规模较小的子问题，并尽量使这k个子问题的规模大致相同。
（2）求解子问题：
各子问题的解法与原问题的解法通常是相同的，可以用递归的方法求解各个子问题，有时递归处理也可以用循环来实现。
（3）合并：
把各个子问题的解合并起来，合并的代价因情况不同有很大差异，分治算法的有效性很大程度上依赖于合并的实现。
分治法的一般过程
DivideConquer（P）
if（P的规模足够小）直接求解P;
分解为k个子问题P1,P2,…Pk;
=k;
yi=DivideConquer（Pi）;
returnMerge（y1,…,yk）;
计算an，应用分治技术得到如下计算方法：
递归
递归的定义
递归就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方法。
递归有两个基本要素：
⑴边界条件：
确定递归到何时终止；
⑵递归模式：
大问题是如何分解为小问题的，确定递归体。
递归函数的运行轨迹
在递归函数中，调用函数和被调用函数是同一个函数，需要注意的是递归函数的调用层次，如果把调用递归函数的主函数称为第0层，进入函数后，首次递归调用自身称为第1层调用；
从第i层递归调用自身称为第i+1层。
反之，退出第i+1层调用应该返回第i层。
采用图示方法描述递归函数的运行轨迹，从中可较直观地了解到各调用层次及其执行情况。
递归函数的内部执行过程
一个递归函数的调用过程类似于多个函数的嵌套调用，只不过调用函数和被调用函数是同一个函数。
为了保证递归函数的正确执行，系统需设立一个工作栈。
具体地说，递归调用的内部执行过程如下：
（1）运行开始时，首先为递归调用建立一个工作栈，其结构包括值参、局部变量和返回地址；
（2）每次执行递归调用之前，把递归函数的值参和局部变量的当前值以及调用后的返回地址压栈；
（3）每次递归调用结束后，将栈顶元素出栈，使相应的值参和局部变量恢复为调用前的值，然后转向返回地址指定的位置继续执行。
汉诺塔算法在执行过程中，工作栈的变化下图所示，其中栈元素的结构为（返回地址，n值，A值，B值，C值），返回地址对应算法中语句的行号。
递归算法结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此，它为设计算法和调试程序带来很大方便，是算法设计中的一种强有力的工具。
但是，因为递归算法是一种自身调用自身的算法，随着递归深度的增加，工作栈所需要的空间增大，递归调用时的辅助操作增多，因此，递归算法的运行效率较低。
排序问题中的分治法
归并排序
二路归并排序的分治策略是：
将待排序序列r1,r2,…,rn划分为两个长度相等的子序列r1,…,rn/2和rn/2＋1,…,rn；
分别对这两个子序列进行排序，得到两个有序子序列；
将这两个有序子序列合并成一个有序序列。
算法——归并排序
voidMergeSort（intr[],intr1[],ints,intt）
if（s==t）r1[s]=r[s];
else{
m=（s+t）/2;
Mergesort（r,r1,s,m）;
出最短路径经过的顶点：
=0
循环直到path[i]=n-1
输出path[i];
算法主要由三部分组成：
第一部分是初始化部分，其时间性能为O（n）；
第二部分是依次计算各个顶点到终点的最短路径，由两层嵌套的循环组成，外层循环执行n-1次，内层循环对所有出边进行计算，并且在所有循环中，每条出边只计算一次。
假定图的边数为m，则这部分的时间性能是O（m）；
第三部分是输出最短路径经过的顶点，其时间性能是O（n）。
所以，算法的时间复杂性为O（n+m）。
组合问题中的动态规划法
背包问题
在0/1背包问题中，物品i或者被装入背包，或者不被装入背包，设xi表示物品i装入背包的情况，则当xi=0时，表示物品i没有被装入背包，xi=1时，表示物品i被装入背包。
根据问题的要求，有如下约束条件和目标函数：
于是，问题归结为寻找一个满足约束条件式，并使目标函数式达到最大的解向量X=（x1,x2,…,xn）。
证明0/1背包问题满足最优性原理。
设（x1,x2,…,xn）是所给0/1背包问题的一个最优解，则（x2,…,xn）是下面一个子问题的最优解：
如若不然，设（y2,…,yn）是上述子问题的一个最优解，则
因此，
这说明（x1,y2,…,yn）是所给0/1背包问题比（x1,x2,…,xn）更优的解，从而导致矛盾。
0/1背包问题可以看作是决策一个序列（x1,x2,…,xn），对任一变量xi的决策是决定xi=1还是xi=0。
在对xi-1决策后，已确定了（x1,…,xi-1），在决策xi时，问题处于下列两种状态之一：
（1）背包容量不足以装入物品i，则xi=0，背包不增加价值；
（2）背包容量可以装入物品i，则xi=1，背包的价值增加了vi。
这两种情况下背包价值的最大者应该是对xi决策后的背包价值。
令V（i,j）表示在前i（1≤i≤n）个物品中能够装入容量为j（1≤j≤C）的背包中的物品的最大值，则可以得到如下动态规划函数：
V（i,0）=V（0,j）=0（式）
式表明：
把前面i个物品装入容量为0的背包和把0个物品装入容量为j的背包，得到的价值均为0。
式的第一个式子表明：
如果第i个物品的重量大于背包的容量，则装入前i个物品得到的最大价值和装入前i-1个物品得到的最大价值是相同的，即物品i不能装入背包；
第二个式子表明：
如果第i个物品的重量小于背包的容量，则会有以下两种情况：
（1）如果把第i个物品装入背包，则背包中物品的价值等于把前i-1个物品装入容量为j-wi的背包中的价值加上第i个物品的价值vi；
（2）如果第i个物品没有装入背包，则背包中物品的价值就等于把前i-1个物品装入容量为j的背包中所取得的价值。
显然，取二者中价值较大者作为把前i个物品装入容量为j的背包中的最优解。
例如，有5个物品，其重量分别是{2,2,6,5,4}，价值分别为{6,3,5,4,6}，背包的容量为10。
根据动态规划函数，用一个（n+1）×
（C+1）的二维表V，V[i][j]表示把前i个物品装入容量为j的背包中获得的最大价值。
按下述方法来划分阶段：
第一阶段，只装入前1个物品，确定在各种情况下的背包能够得到的最大价值；
第二阶段，只装入前2个物品，确定在各种情况下的背包能够得到的最大价值；
依此类推，直到第n个阶段。
最后，V（n,C）便是在容量为C的背包中装入n个物品时取得的最大价值。
为了确定装入背包的具体物品，从V（n,C）的值向前推，如果V（n,C）>
V（n-1,C），表明第n个物品被装入背包，前n-1个物品被装入容量为C-wn的背包中；
否则，第n个物品没有被装入背包，前n-1个物品被装入容量为C的背包中。
依此类推，直到确定第1个物品是否被装入背包中为止。
由此，得到如下函数：
（式）
设n个物品的重量存储在数组w[n]中，价值存储在数组v[n]中，背包容量为C，数组V[n+1][C+1]存放迭代结果，其中V[i][j]表示前i个物品装入容量为j的背包中获得的最大价值，数组x[n]存储装入背包的物品，动态规划法求解0/1背包问题的算法如下：
算法——0/1背包问题
intKnapSack（intn,intw[],intv[]）
i++）始化两个辅助数组lowcost和adjvex；
={u0};
输出顶点u0;
复执行下列操作n-1次
在lowcost中选取最短边，取adjvex中对应的顶点序号k；
输出顶点k和对应的权值；
=U+{k}；
调整数组lowcost和adjvex；
设连通网中有n个顶点，则第一个进行初始化的循环语句需要执行n-1次，第二个循环共执行n-1次，内嵌两个循环，其一是在长度为n的数组中求最小值，需要执行n-1次，其二是调整辅助数组，需要执行n-1次，所以，Prim算法的时间复杂度为O（n2）。
（2）最短边策略：
设G=（V，E）是一个无向连通网，令T=（U，TE）是G的最小生成树。
最短边策略从TE={}开始，每一次贪心选择都是在边集E中选取最短边（u,v），如果边（u,v）加入集合TE中不产生回路，则将边（u,v）加入边集TE中，并将它在集合E中删去。
Kruskal算法就应用了这个贪心策略，它使生成树以一种随意的方式生长，先让森林中的树木随意生长，每生长一次就将两棵树合并，到最后合并成一棵树。
算法——Kruskal算法
1.初始化：
U=V；
TE={}；
2.循环直到T中的连通分量个数为1
在E中寻找最短边（u，v）;
如果顶点u、v位于T的两个不同连通分量，则
将边（u，v）并入TE；
将这两个连通分量合为一个；
=E-{（u，v）}；
Kruskal算法为了提高每次贪心选择时查找最短边的效率，可以先将图G中的边按代价从小到大排序，则这个操作的时间复杂度为O（elog2e），其中e为无向连通网中边的个数。
对于两个顶点是否属于同一个连通分量，可以用并查集的操作将其时间性能提高到O（n），所以，Kruskal算法的时间性能是O（elog2e）。
组合问题中的贪心法
给定n种物品和一个容量为C的背包，物品i的重量是wi，其价值为vi，背包问题是如何选择装入背包的物品，使得装入背包中物品的总价值最大?
设xi表示物品i装入背包的情况，根据问题的要求，有如下约束条件和目标函数：
于是，背包问题归结为寻找一个满足约束条件式，并使目标函数式达到最大的解向量X=（x1,x2,…,xn）。
至少有三种看似合理的贪心策略：
（1）选择价值最大的物品，因为这可以尽可能快地增加背包的总价值。
但是，虽然每一步选择获得了背包价值的极大增长，但背包容量却可能消耗得太快，使得装入背包的物品个数减少，从而不能保证目标函数达到最大。
（2）选择重量最轻的物品，因为这可以装入尽可能多的物品，从而增加背包的总价值。
但是，虽然每一步选择使背包的容量消耗得慢了，但背包的价值却没能保证迅速增长，从而不能保证目标函数达到最大。
（3）选择单位重量价值最大的物品，在背包价值增长和背包容量消耗两者之间寻找平衡。
应用第三种贪心策略，每次从物品集合中选择单位重量价值最大的物品，如果其重量小于背包容量，就可以把它装入，并将背包容量减去该物品的重量，然后我们就面临了一个最优子问题——它同样是背包问题，只不过背包容量减少了，物品集合减少了。
因此背包问题具有最优子结构性质。
例如，有3个物品，其重量分别是{20,30,10}，价值分别为{60,120,50}，背包的容量为50，应用三种贪心策略装入背包的物品和获得的价值如图所示。
设背包容量为C，共有n个物品，物品重量存放在数组w[n]中，价值存放在数组v[n]中，问题的解存放在数组x[n]中。
算法——背包问题
1．改变数组w和v的排列顺序，使其按单位重量价值v[i]/w[i]降序排列；
2．将数组x[n]初始化为0；
//初始化解向量
3．i=1;
4．循环直到（w[i]>
C）
[i]=1;
//将第i个物品放入背包
=C-w[i];
++;
[i]=C/w[i];
算法的时间主要消耗在将各种物品依其单位重量的价值从大到小排序。
因此，其时间复杂性为O（nlog2n）。
活动安排问题
设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源（如演讲会场），而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si<
fi。
如果选择了活动i，则它在半开时间区间[si,fi）内占用资源。
若区间[si,fi）与区间[sj,fj）不相交，则称活动i与活动j是相容的。
也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。
活动安排问题要求在所给的活动集合中选出最大的相容活动子集。
贪心法求解活动安排问题的关键是如何选择贪心策略，使得按照一定的顺序选择相容活动，并能安排尽量多的活动。
至少有两种看似合理的贪心策略：
（1）最早开始时间：
这样可以增大资源的利用率。
（2）最早结束时间：
这样可以使下一个活动尽早开始。
由于活动占用资源的时间没有限制，因此，后一种贪心选择更为合理。
为了在每一次贪心选择时快速查找具有最早结束时间的相容活动，先把n个活动按结束时间非减序排列。
这样，贪心选择时取当前活动集合中结束时间最早的活动就归结为取当前活动集合中排在最前面的活动。
例如，设有11个活动等待安排，这些活动按结束时间的非减序排列如下：
设有n个活动等待安排，这些活动的开始时间和结束时间分别存放在数组s[n]和f[n]中，集合B存放问题的解，即选定的活动集合，算法如下：
算法——活动安排问题
1．对数组f[n]按非减序排序，同时相应地调整s[n]；
2．B={1}；
//最优解中包含活动1
3．j=1;
i=2;
//从活动i开始寻找与活动j相容的活动
4．当（i≤n）时循环执行下列操作
如果（s[i]>
=f[j]）则
算法的时间主要消耗在将各个活动按结束时间从小到大排序。
因此，算法的时间复杂性为O（nlog2n）。
intActiveManage（ints[],intf[],boola[],intn）
{//各活动的起始时间和结束时间存储于数组s和f中且
//按结束时间的非减序排列
a[1]=1;
j=1;
count=1;
for（i=2;
if（s[i]>
=f[j]）{
a[i]=1;
j=i;
count++;
elsea[i]=0;
returncount;
多机调度问题
设有n个独立的作业{1,2,…,n}，由m台相同的机器{M1,M2,…,Mm}进行加工处理，作业i所需的处理时间为ti（1≤i≤n），每个作业均可在任何一台机器上加工处理，但不可间断、拆分。
多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
贪心法求解多机调度问题的贪心策略是最长处理时间作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样可以保证处理时间长的作业优先处理，从而在整体上获得尽可能短的处理时间。
按照最长处理时间作业优先的贪心策略，当m≥n时，只要将机器i的[0,ti）时间区间分配给作业i即可；
当m＜n时，首先将n个作业依其所需的处理时间从大到小排序，然后依此顺序将作业分配给空闲的处理机。
设7个独立作业{1,2,3,4,5,6,7}由3台机器{M1,M2,M3}加工处理，各作业所需的处理时间分别为{2,14,4,16,6,5,3}。
贪心法产生的作业调度如下：
算法——多机调度问题
1．将数组t[n]由大到小排序，对应的作业序号存储在数组p[n]中；
2．将数组d[m]初始化为0；
3．for（i=1;
=m;
[i]={p[i]};
//将m个作业分配给m个机器
[i]=t[i];
（i=m+1;
=数组d[m]中最小值对应的下标；
//j为最先空闲的机器序号
[j]=S[j]+{p[i]};
//将作业i分配给最先空闲的机器j
[j]=d[j]+t[i];
//机器j将在d[j]后空闲
在算法中，操作“数组d[m]中最小值对应的下标”如果采用蛮力法查找，则算法的时间性能为：
通常情况下m<
n，则算法的时间复杂性为O（n×
m）。
第8章回溯法
问题的解空间
复杂问题常常有很多的可能解，这些可能解构成了问题的解空间。
解空间也就是进行穷举的搜索空间，所以，解空间中应该包括所有的可能解。
确定正确的解空间很重要，如果没有确定正确的解空间就开始搜索，可能会增加很多重复解，或者根本就搜索不到正确的解。
例如：
桌子上有6根火柴棒，要求以这6根火柴棒为边搭建4个等边三角形。
对于任何一个问题，可能解的表示方式和它相应的解释隐含了解空间及其大小。
例如，对于有n个物品的0/1背包问题，其可能解的表示方式可以有以下两种：
（1）可能解由一个不等长向量组成，当物品i（1≤i≤n）装入背包时，解向量中包含分量i，否则，解向量中不包含分量i，当n=3时，其解空间是：
{（）,
（1）,
（2）,（3）,（1,2）,（1,3）,（2,3）,（1,2,3）}
（2）可能解由一个等长向量{x1,x2,…,xn}组成，其中xi=1
升级会员 