2020-wfx-第4章 蛮力法-3-递归在蛮力法中的应用
算法设计与分析-第3章-蛮力法
哨兵
0123456789 k 10 15 24 6 12 35 40 98 55
查找方向
i
清华大学出版社
算法设计与分析
算法3.2——改进的顺序查找
int SeqSearch2(int r[ ], int n, int k) //数组r[1] ~ r[n]存放查找集合 { r[0]=k; i=n; while (r[i]!=k)
清华大学出版社
算法设计与分析
第3章 蛮力法
3.1 蛮力法的设计思想 3.2 查找问题中的蛮力法 3.3 排序问题中的蛮力法 3.4 组合问题中的蛮力法 3.5 图问题中的蛮力法 3.6 几何问题中的蛮力法 3.7 实验项目——串匹配问题
清华大学出版社
算法设计与分析
3.1 蛮力法的设计思想
蛮力法的设计思想：直接基于问题的描述。 例：计算an
52 37 65 不可行 不可行 不可行 不可行 不可行
清华大学出版社
算法设计与分析
对于一个具有n个元素的集合，其子集 数量是2n，所以，不论生成子集的算法 效率有多高，蛮力法都会导致一个Ω(2n) 的算法。
清华大学出版社
算法设计与分析
3.4.4 任务分配问题
假设有n个任务需要分配给n个人执行， 每个任务只分配给一个人，每个人只分配一 个任务，且第j个任务分配给第i个人的成本 是C[i, j]（1≤i , j≤n），任务分配问题要求 找出总成本最小的分配方案。
用蛮力法解决0/1背包问题，需要考虑给定n个 物品集合的所有子集，找出所有可能的子集（总重 量不超过背包容量的子集），计算每个子集的总价 值，然后在他们中找到价值最大的子集。
清华大学出版社
算法设计与分析
10
蛮力法
i 0 nm
1 [(m 1) 1] (n m 1)m
j 0 i 0
m 1
nm
第三章 蛮力法
3.2 最近对问题 算法：BruteForceClosetPoints(P)
//该算法实现了蛮力法球平面中距离最近的两个点 //输入：一个n个(n>1)个点的列表，P1=（X1，Y1）…… ，Pn=（Xn，Yn） //输出：最近的两个点得下标，index1和index2
C( n )
n 1 i 1
1
i 1 j i 1k 1 n n) n( n i )
j i 1
n[(n 1)(n 2) 1] n 2 ( n 1) / 2
第三章 蛮力法
3.4 旅行商问题 算法：TSP(P[1..n],V[1..n][1..n])
C( n )
i 1 n 1
j i 1
2 [2(n i)] 2[(n 1 1)(n 1)] / 2 n(n 1)
i 1
n
n 1
第三章 蛮力法
3.3 凸包问题 算法：BruteForceConvexHull(P)
//该算法实现了蛮力法求平面中距离最近的两个点 //输入：一个n个(n>1)个点的列表，P1=（X1，Y1）…… ，Pn=（Xn，Yn） //输出：最小凸集合集合S
2 3 n C( n) c11 cn cn cn 2n 1 n
第三章 蛮力法
3.4 旅行商问题 效率分析： TSP(P[1..n],V[1..n][1..n]) //对于具有n个节点的哈密顿回路而言，必须生成一个由n+1 个节点构成的序列，其入口和出口假设为节点1，那么蛮 力法必须生成所有其他的n-1个节点构成一条完整的路径 //显然，对于这样一个算法而言，蛮力法求旅行商问题总是 一个效率为θ((n-1)!)的算法
第4章 蛮力法
//t的字符比较完毕
return i-j;
//t是s的子串,返回位置
else
//t不是s的子串
return -1;
//返回-1
}
【例4.5】有两个字符串s和t，设计一个算法求t在s中出 现的次数。例如，s="abababa"，t="aba"，则t在s中出现2 次。
解：采用BF算法思路。用num×1000+b×100+c×10+d n=a×1000+b×100+e×10+d s=e×10000+d×1000+c×100+a×10+d
则有：m+n==s
void fun()
{ int a,b,c,d,e,m,n,s;
continue是结束本次循环
for (a=1;a<=9;a++)
for (m=2;m<=1000;m++) { 求出m的所有因子之和s;
if (m==s) 输出s; }
对应的程序如下：
void main() { int m,i,s;
for (m=2;m<=1000;m++) { s=0;
for (i=1;i<=m/2;i++) if (m%i==0) s+=i; //i是m的一个因子
} return maxSum; }
maxSubSum1(a,n)算法中用了三重循环，所以有：
n1 n1
T(n)=
j
n1
1
n1 ( j i 1) 1 n1 (n i)(n i 1)
2. 搜索所有的路径：这类问题中不同的路径对应不同的解。 3. 直接计算：按照基于问题的描述和所涉及的概念定义，
蛮力法、动态规划法、回溯法和分支限界法求解01背包问题【精选】
一、实验内容：分别用蛮力法、动态规划法、回溯法和分支限界法求解0/1背包问题。
注：0/1背包问题：给定种物品和一个容量为的背包，物品的重n C i 量是，其价值为，背包问题是如何使选择装入背包内的物品，使得装i w i v 入背包中的物品的总价值最大。
其中，每种物品只有全部装入背包或不装入背包两种选择。
二、所用算法的基本思想及复杂度分析：1.蛮力法求解0/1背包问题：1）基本思想：对于有n 种可选物品的0/1背包问题，其解空间由长度为n 的0-1向量组成,可用子集数表示。
在搜索解空间树时，深度优先遍历，搜索每一个结点，无论是否可能产生最优解，都遍历至叶子结点，记录每次得到的装入总价值，然后记录遍历过的最大价值。
2）代码:#include<iostream>#include<algorithm>using namespace std;#define N 100//最多可能物体数struct goods //物品结构体{int sign;//物品序号int w;//物品重量int p;//物品价值}a[N];bool m(goods a,goods b){return (a.p/a.w)>(b.p/b.w);}int max(int a,int b){return a<b?b:a;}int n,C,bestP=0,cp=0,cw=0;int X[N],cx[N];/*蛮力法求解0/1背包问题*/int Force(int i){if(i>n-1){if(bestP<cp&&cw+a[i].w<=C){for (int k=0;k<n;k++)X[k]=cx[k];//存储最优路径bestP=cp;}return bestP;}cw=cw+a[i].w;cp=cp+a[i].p;cx[i]=1;//装入背包Force(i+1);cw=cw-a[i].w;cp=cp-a[i].p;cx[i]=0;//不装入背包Force(i+1);return bestP;}int KnapSack1(int n,goods a[],int C,int x[]){Force(0);return bestP;}int main(){goods b[N];printf("物品种数n: ");scanf("%d",&n);//输入物品种数printf("背包容量C: ");scanf("%d",&C);//输入背包容量for (int i=0;i<n;i++)//输入物品i 的重量w 及其价值v {printf("物品%d 的重量w[%d]及其价值v[%d]:",i+1,i+1,i+1);scanf("%d%d",&a[i].w,&a[i].p);b[i]=a[i];}int sum1=KnapSack1(n,a,C,X);//调用蛮力法求0/1背包问题printf("蛮力法求解0/1背包问题:\nX=[ ");for(i=0;i<n;i++)cout<<X[i]<<" ";//输出所求X[n]矩阵printf("]装入总价值%d\n",sum1);bestP=0,cp=0,cw=0;//恢复初始化}3）复杂度分析：蛮力法求解0/1背包问题的时间复杂度为：。
蛮力算法
17
main1( ) { int *a,i,j,n; input(n); a=calloc(n+1,sizeof(int)); //申请存储空间 for (i=1; i<=n;i++) a[i]=1; for (i=1; i<=n;i++) for (j=i; j<=n;j=j+i) a[i]=1-a[i]; for (i=1; i<=n;i++) if (a[i]=0) print(i,”is free.”); } 算法分析1：以一次开关锁计算，算法的时间复杂度为 n(1+1/2+1/3+……+1/n)=O(nlogn)。
3
【例3.1】百钱百鸡问题。中国古代数学家张丘建在《算经》 中提出了著名的“百钱百鸡问题”：鸡翁一，值钱五；鸡母一， 值钱三；鸡雏三，值钱一；百钱买百鸡，翁、母、雏各几何? 算法设计1： 通过对问题的理解，可能会想到列出两个三元一次方程， 去解这个不定解方程，就能找出问题的解。这确实是一种办法， 但这里我们要用“懒惰”的枚举策略进行算法设计： 设x，y，z分别为公鸡、母鸡、小鸡的数量。 尝试范围：由题意给定共100钱要买百鸡，若全买公鸡最多 买100/5=20只，显然x的取值范围1~20之间；同理，y的取值范 围在1~33之间，z的取值范围在1~100之间。 约束条件： x+y+z=100 且 5*x+3*y+z/3=100
实验项目1：蛮力法与分治法应用
实验项目1：蛮力法与分治法应用1、目的与要求：实验目的：了解蛮力法和分治法的基本思想，学会运用蛮力法和分治法解决实际系统设计应用中碰到的问题。
实验要求：用蛮力法实现选择、冒泡排序，或旅行商问题、背包问题等问题（任选其中之一）。
用分治法实现合并排序或快速排序。
要求写出算法的伪代码描述，并编写程序实现之，相关算法放在函数内实现，主程序给出测试用例，要设计足够多的相关测试用例，验证程序的正确性。
注意观察程序执行结果和运行的时间。
实验报告要求给出问题定义及算法的伪代码描述，程序设计的代码，算法的测试用例及结果，并分析算法的时间效率，回答指导书中的思考题。
2、实验内容：（2）用分治法实现快速排序、合并排序算法。
本实验主要是用分治法实现合并排序，快速排序程序等。
合并排序算法描述：MergeSort ( A[0...p-1] )// input 待排序数组A[0..n-1]// output 非降序排列的数组A[0..n-1]if ( n>1 ) {//至少有2个元素Copy A[0.. n/2-1 ] to B[0.. n/2-1 ];Copy A[n/2..n-1 ] to C[0.. n/2-1 ];MergeSort ( B[0.. n/2-1 ] );MergeSort (C[0.. n/2-1 ]t);Merge (B, C, A); //复制回数组a快速排序算法描述：QuickSort ( A[1.. r ] ){if (l<r) s=Partition( A[l,r] ); // s 是分裂位置QuickSort ( A[l..s-1] ); //对左半段排序QuickSort ( A[s+1,r); //对右半段排序}Partition ( A[l..r] ){p=A[[l] ;i = l; j = r + 1;repeatedrepeated i=i+1; until A[i]> p // 将>= x的元素交换到左边区域repeated i=i+1; until A[i]> p // <= x的元素交换到右边区域Swap( A[i], A[j] )Until i>jSwap( A[i] = a[j] );Swap( A[l], A[j] )return j;要求先给出算法的伪代码，然后用C++或其他程序设计语言编写程序实现之，并设计相关的测试用例，验证程序的正确性。
第3章 蛮力法
结果： 结果： 1. 冒泡排序算法效率属于 Θ( n 2 ) 类型；(与选择排序一样 类型； 与选择排序一样 与选择排序一样) 2. 键值交换次数在最坏情况下（输入降序列表，每次比较后均要交换） 键值交换次数在最坏情况下（输入降序列表，每次比较后均要交换） 这比选择排序差。因此， 和键值比较次数一样即均为 Θ( n2 ) ，这比选择排序差。因此，该算法 在简单排序问题上不是一个好的选择。 在简单排序问题上不是一个好的选择。“如果不是因为它有一个好记 的名字，我们很可能对它不会有任何的了解” 的名字，我们很可能对它不会有任何的了解”。
蛮力算法策略： 滑动匹配 滑动匹配) 蛮力算法策略：(滑动匹配 模式在文本上从左向右滑动一个字符，比较对应字符（从左到右）， 模式在文本上从左向右滑动一个字符，比较对应字符（从左到右）， 个字符都已匹配，算法停止。否则，继续滑动、比较。 若全部 m 个字符都已匹配，算法停止。否则，继续滑动、比较。 注意： (n注意：最后一轮比较的起始位置在 (n-m) 处：(n-1)-(n-m)+1=m
p0 ... p j ... pm −1 ⇒
b
b
b
t n− m ... t n−1 1 24 4 3
m个
11
字符串匹配 (String Matching) 的蛮力算法 BruteForceStringMatch(T [0...n − 1], P[0...m − 1]) { for ( i ← 0) to ( n − m ) do // 模式P滑动循环 { // while结束时j < m : 进入下一轮 i 循环 j ← 0; // 每次比较从P[0]开始 while ( j < m ) and ( P[ j ] = T [i + j ]) do { j ← j + 1; } // 比较下一个字符 if ( j = m ) return ( i ); // 考虑while结束时 j 值 return } return ( −1); // 滑动到文本尾,没找到匹配 } // 可用限位:模式添加到文本最后。去掉j < m
蛮力法,动态规划法,贪心法求解背包问题
算法设计与分析实验名称：用蛮力法、动态规划法和贪心法求0/1背包问题作者姓名：xxxxxxxxx完成日期：2013年9月22日星期日组的编号：28目录第一章：简介 (1)第二章：算法规范 (2)数据结构 (2)伪代码 (3)第三章：算法测试 (4)蛮力法 (4)动态规划 (5)贪心法 (5)第四章：分析讨论 (6)算法分析 (6)时间复杂度分析 (16)附录 (17)声明 (17)第一章：简介问题的描述：0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中。
在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi 表示物品i 装入背包的情况，则当xi =0时，表示物品i 没有被装入背包，xi =1时，表示物品i 被装入背包。
根据问题的要求，有如下约束条件和目标函数：于是，问题归结为寻找一个满足约束条件式1，并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。
背包的数据结构的设计： typedef struct object {int n;//物品的编号 int w;//物品的重量∑=ni ii x v 1max （式2）⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1）int v;//物品的价值}wup;wup wp[N];//物品的数组，N为物品的个数int c;//背包的总重量第二章:算法规范数据结构：0/1背包问题是给定n个重量为{w1, w2, … ,wn}、价值为{v1, v2, … ,vn}的物品和一个容量为C的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中，在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi表示物品i装入背包的情况，则当xi=0时，表示物品i没有被装入背包，xi=1时，表示物品i被装入背包。
算法设计与分析-第四章1-常用算法策略迭代蛮力分治PPT课件
.
4
数学建模：y1=y2=1，yn=yn-1+yn-2，n=3，4，5，……。
算法1：
main( ) { int i,a=1,b=1;
print(a,b); for(i=1;i＜=10;i++)
{ c=a+b; print (c); a=b; b=c；
} }
.
5
算法2：
表4-1 递推迭代表达式
12 3
.
21
【例2】牛顿迭代法 牛顿迭代法又称为切线法，它比一般的迭代法有更高的收敛速度，如图 4-5所示。首先, 选择一个接近函数f(x)零点的x0, 计算相应的f(x0)和 切线斜率f‘(x0)（这里f ’表示函数f的导数）。然后我们计算穿过点 (x0,f (x0))且斜率为f ‘(x0)的直线方程为：
{a[1]=a[i]=1; for (j=i-1，j>1，j=j-1) a[j]=a[j]+a[j-1];
for (j=1;j<=i;j=j+1) print(a[j]); print(“换行符”);
} }
.
13
【例3】穿越沙漠问题 用一辆吉普车穿越1000公里的沙漠。吉普车的总装油量为500加仑， 耗油率为1加仑/公里。由于沙漠中没有油库，必须先用这辆车在 沙漠中建立临时油库。该吉普车以最少的耗油量穿越沙漠，应在 什么地方建油库，以及各处的贮油量。
问题分析：题目中要求用一个一维数组即完成。 1 4 6 4 1
数组空间一定是由下标从小到大利用的，这 ……………
样其实杨辉三角形是按下图4-2形式存储的。 图4-1 杨辉三角形
若求n层，则数组最多存储n个数据。
算法设计：
A[1] = A[i]=1 A[j] = A[j] + A[j-1] i行 i-1行 i-1行
蛮力法
2 其它范例
蛮力法的表现形式非常多。本节将通过蛮力策略， 蛮力法的表现形式非常多。本节将通过蛮力策略，用 算法模拟问题中所描述的全部过程和全部状态， 算法模拟问题中所描述的全部过程和全部状态，来找出问 题的解，并与经过数学建模后的算法进行效率上的比较。 题的解，并与经过数学建模后的算法进行效率上的比较。
8
1 枚举法
枚举法（ 穷举法） 是蛮力策略的一种表现形式， 枚举法 （ 穷举法 ） 是蛮力策略的一种表现形式 ， 根据问题 中条件将可能情况一一列举出来， 逐一尝试从中找出满足 中条件将可能情况一一列举出来 ， 问题条件的解。 但有时一一列举出的情况数目很大， 问题条件的解 。 但有时一一列举出的情况数目很大 ， 则需 要进一步考虑， 排除一些明显不合理的情况， 要进一步考虑 ， 排除一些明显不合理的情况 ， 尽可能减少 问题可能解的列举数目。 问题可能解的列举数目。 通常从两个方面进行算法设计： 通常从两个方面进行算法设计： 1）找出枚举范围：分析问题所涉及的各种情况。 找出枚举范围：分析问题所涉及的各种情况。 找出约束条件：分析问题的解需要满足的条件， 2）找出约束条件：分析问题的解需要满足的条件，并 用逻辑表达式表示。 用逻辑表达式表示。
16
main（） （） {int A,B,C,D,E,F; for(A=3;A<=9;A++) for(D=1;D<=9;D++) { E = D*100000+D*10000+D*1000+D*100+D*10+D; if(E mod A=0) F=E\A; if(F\10000=A and (F mod 100)\10=A) and (F\1000=F mod 10) print( F，”*”，A，”=”，E); ， ” ， ， } }
第 3 章 蛮力法
算 分 析 与 设 计
西南科技大学
顺序查找和蛮力字符串匹配
SequentialSearch（A[0…n],K）和 BruteForceStringMatch（T[0..n-1],P[0..m-1]） 的效率都可以近似属于线形级别。
算 分 析 与 设 计
西南科技大学
最接近点对问题和凸包问题
最接近点对问题的提法是:给定平面上n个 点，找其中的一对点，使得在n个点的所 有点对中，该点对的距离最小。严格地说， 最接近点对可能多于1对。为了简单起见， 这里只限于找其中的一对。 凸包问题是为一个n个点的集合构造凸包 的问题；一个点集合S的凸包是包含S的最 小凸集合。 用蛮力法求解的效率为N的立 方级别。
算 分 析 与 设 计
西南科技大学
冒泡排序
冒泡排序的基本概念是：依次比较相邻的两个 数，将大数放在前面，小数放在后面。 对1至n个记录，将第n个和第n-1个记录的键值 进行比较，如r[n].key<r[n-1].key,则将两个记录 交换。然后比较第n-1个和第n-2个记录的关键 字；依次类推，直到第2个记录和第1个记录进 行比较交换，这称为一趟冒泡。这趟最明显的 效果是：将键值最小的记录传到了第1位。 然后，对2至n个记录重复以上操作。直至操作 的记录长度为1或该趟没有记录交换为止。
算 分 析 与 设 计
西南科技大学
选择排序示例
初始关键字［ 49Ⅰ 38 65 76 49Ⅱ 13 27] 第一趟排序后 13［38 65 76 49Ⅱ 49Ⅰ 27] 第二趟排序后 13 27［65 76 49Ⅱ 49Ⅰ 38] 第三趟排序后 13 27 38［76 49Ⅱ 49Ⅰ 65] 第四趟排序后 13 27 38 49Ⅱ [76 49Ⅰ 65] 第五趟排序后 13 27 38 49Ⅱ 49Ⅰ [76 65] 最后排序结果 13 27 38 49Ⅱ 49Ⅰ 65 76
蛮力法
2 查找问题中的蛮力法—串的匹配
BF算法
KMP算法
下一次开始位置 下一次开始位置
本趟开始位置
i 回溯
ii
S 模式T
si
…
tj
回溯
j
j
回溯next[j]
……
3 排序问题中的蛮力法—选择排序
选择排序开始的时候，扫描整个序列，找到整个序列的最小记
录和序列中的第一个记录交换，从而将最小记录放到它在有序
区的最终位置上，然后再从第二个记录开始扫描序列，找到n-1
个序列中的最小记录，再和第二个记录交换位置。一般地，第i
趟排序从第i个记录开始扫描序列，在n-i+1（1≤i≤n-1）个记录中
找到关键码最小的记录，并和第i个记录交换作为有序序列的第i
个记录。
4 组合问题中的蛮力法—任务分配问题
可以用一个n元组(j1, j2, …, jn)来描述任务分配问题的一个可能 解，其中第i个分量ji（1≤i≤n）表示在第i行中选择的列号，因此 用蛮力法解决任务分配问题要求生成整数1~n的全排列，然后把 成本矩阵中的相应元素相加来求得每种分配方案的总成本，最 后选出具有最小和 18
是否最短
否 是 否 是 否 否
蛮力法求解TSP问题存在的问题
注意到图中有3对不同的路径，对每对路径来说，不同 的只是路径的方向，因此，可以将这个数量减半，则 可能的解有(n-1)!/2个。随着n的增长，TSP问题的可 能解也在迅速地增长。
一个10城市的TSP问题有大约180,000个可能解。 一个20城市的TSP问题有大约
依次处理所有元素是蛮力法的关键，为 了避免陷入重复试探，应保证处理过的 元素不再被处理。
递归算法解决复杂问题的利器
递归算法解决复杂问题的利器递归算法是计算机科学中一种强大的解决问题的工具，它可以通过将大问题分解成一个或多个相同的子问题，并通过逐步解决这些子问题来得到最终问题的解。
递归算法在解决复杂问题时具有独特的优势，本文将介绍递归算法的基本原理和应用场景，并通过具体案例分析展示递归算法的效果。
一、递归算法的基本原理递归算法的核心思想是将一个大问题分解为一个或多个相同的子问题，直到子问题变得足够简单，可以直接求解。
具体来说，递归算法包含两个要素：1. 基线条件：递归算法中需要定义一个或多个基线条件作为递归的终止条件。
当满足基线条件时，递归将停止，返回最终结果。
基线条件的设定是保证递归算法正确执行的重要因素。
2. 递归调用：在递归算法中，需要通过调用自身来解决规模较小的子问题。
递归调用通常在先解决子问题，然后再利用子问题的解来解决更大规模的问题。
使用递归算法时，需要注意避免进入无限递归的情况。
为了防止无限递归，需要保证每次递归调用能够向基线条件逼近。
二、递归算法的应用场景递归算法广泛应用于需要通过分解问题来求解的场景。
以下是几个递归算法常见的应用场景：1. 阶乘计算：阶乘是一个典型的递归计算问题，可以通过将大问题转化为规模较小的子问题来实现。
阶乘的递归定义为n! = n * (n-1)!，其中基线条件是n=1时，阶乘的结果为1。
2. 斐波那契数列：斐波那契数列是另一个典型的递归计算问题，斐波那契数列的递归定义为F(n) = F(n-1) + F(n-2)，其中基线条件是F(0)和F(1)的值为1。
通过递归调用来计算斐波那契数列可以有效地解决该问题。
3. 树结构处理：树是递归定义的数据结构，因此递归算法在处理树结构时十分常见。
通过递归遍历树的各个节点，并对每个节点进行操作，可以实现对树结构的高效处理。
三、递归算法的案例分析为了更好地理解递归算法的应用，以下将分析两个具体案例。
1. 阶乘计算假设我们需要计算5的阶乘，即求解5!的值。
蛮力法、动归、贪心、分支限界法解01背包问题
算法综合实验报告一、实验内容：分别用蛮力、动态规划、贪心及分支限界法实现对0-1背包问题的求解，并至少用两个测试用例对所完成的代码进行正确性及效率关系上的验证。
二、程序设计的基本思想、原理和算法描述：1、蛮力法1.1数据结构注：结构体obj用来存放单个物品的价值和重量typedef struct obj{int w;//物品的重量int v;//物品的价值};1.2 函数组成void subset(int s[][10],int n)：用来生成子集的函数void judge(int s[][10], obj obj[],int mark[],int n,int c)：判断子集的可行性int getmax(int mark[],int n,int &flag)：求解问题的最优解void outputObj(int flag,int s[][10],int n):输出选择物品的情况 1.3 输入/输出设计本程序通过键盘进行输入、屏幕进行输出。
1.4 符号名说明1.5 算法描述算法的伪代码描述如下：输入：背包的容量c,物品的个数n,n个物品的重量 w[n],价值v[n]输出：装入背包的物品编号以及产生的最大价值1.初始化最大价值 max=0,结果子集 s=φ;2.对集合{1,2,......n}的每一个子集T，执行下述操作：2.1初始化背包的价值 v=0，背包的重量 w=0;2.2对子集t的每一个元素j2.2.1 如果w+wj<c,则 w=w+wj,v=v+vj;2.2.2 否则，转步骤2考察下一个子集；2.3如果max<v,则 max=v;s=t;3.输出子集S中的各元素2、动态规划法2.1 数据结构该程序不涉及任何数据结构2.2 函数组成int max(int i,int j);比较并返回两个数中的较大值int KnapSack (int w[],int v[],int x[],int n,int c);求解背包取得的最大值2.3 输入/输出设计本程序通过键盘进行输入、屏幕进行输出。
蛮力法详解
算法3.1——顺序查找
int SeqSearch1(int r[ ], int n, int k) //数组r[1] ~ r[n]存放查找集合
{ i=n;
基本语句 ？
while (i>0 && r[i]!=k)
i--;
return i;
}
算法3.1的基本语句是i>0和r[i]!=k，其执行次数为:
n
2020/6/14
Chapter 3 Brute force method
教学要求 理解 掌握
√
√ √ √
√ √ √
熟练掌握 √ √
√
4
3.1 概述：蛮力法的设计思想
蛮力法中“力”是指计算机的“计算能 力”，不是人的智“力”。
蛮力法的设计思想：直接基于问题的描述， 从有限集合中，逐一列举集合的所有元素， 对每一个元素逐一判断和处理，从而找出 问题的解。
如已知：公钥为：KU={e, n}，私钥为： KR={d, n}，则 对明文m的加密/解密算法如下：
加密 明文： M<n 密文： C=Me (mod n)
密文： 明文：
解密 C M=Cd (mod n)
注：计算an算法的效率直接影响到RSA算法的性能
2020/6/14
Chapter 3 Brute force method
2020/6/14
Chapter 3 Brute force method
7
蛮力法的设计思想
因要穷举待处理的元素，故蛮力法的时间性能往往最低， 但基于以下原因，蛮力法也是一种重要的算法设计技术：
（1）理论上，蛮力法可以解决可计算领域的各种问题。 （2）蛮力法经常用来解决一些较小规模的问题。 （3）对于一些重要的问题（例如排序、查找等）蛮力法 可以产生一些合理的算法，他们具备一些实用价值，而且 不受问题规模的限制。 （4）蛮力法可以作为某类问题时间性能（不是复杂性， 两者恰好相反）的下界，来衡量同样问题的更高效算法。
第3章 蛮力法
1
清华大学出版社
算法设计与分析
2
ii
第 a b a bc a b c a c ba b
趟
a
i=2，j=1失败 i回溯到3，j回溯到1
jj
i ii i i i
第
a b a b c a b c a c ba b
趟 a b c a c i=7，j=5失败 jj j j j j i回溯到4，j回溯到1
3
清华大学出版社
清华大学出版社
算法设计与分析
再比较tnext[k]和tj，此时仍会出现两种情况，当tnext[k]＝tj时， 与情况（1）类似，next[j]=next[k]+1；当tnext[k]≠tj时，与情况 （2）类似，再找t1 … tj-1的后缀中第3大真前缀，重复（2） 的过程，直到找到t1 … tj-1的后缀中的最大真前缀，或确定 t1 … tj-1的后缀中不存在真前缀，此时，next[j+1]=1。
例如：S="aaaaaaaaaaab"
T="aaab"
设匹配成功发生在si处，则在i-1趟不成功的匹配中共 比较了(i-1)×m次，第i趟成功的匹配共比较了m次，所 以总共比较了i×m次，因此平均比较次数是：
nm1
nm1 1
m(n m 2)
i1
pi (i m)
时，t1＝t3，next[4]=2；j=5时，t2≠t4， 令k=next[2]=1，t1＝t4，next[5]=k+1=2； j=6时，t2＝t5，next[6]=3；j=7时，t3＝t6，next[7]=4； j=8时，t4≠t7，k=next[4]=2，t2＝t7，next[8]=k+1=3。
第3章 蛮力法
计 算
i 1 ji 1
i 1
i 1
机 学
(n 1) (n 2) (n 3) 3 2 1
院
黄
襄 念
结论
n(n 1) (n2 ) 2
1. 选择排序算法效率属于 (n2 ) 型
2. 元素交换次数 (n 1) (n)，该特性使选择排序算法效率超过了
学 增长函数：
数
n1 ni
n1
n1
学 与
T(n) 1 [(n i 1) 1] [n i]
计 算
i 1 j1
i 1
i 1
机 学 院
n(n 1) (n2 ) 2
黄 结果讨论：
襄 念
1. 冒泡排序算法效率属于(n2 ) 类型 —— 与选择排序相同
描述：在一个包含 n 个点的点集中，找到距离最近的两个点
西 简化：二维平面上两点 Pi (xi , yi) 和 Pj (xj , yj) 的欧氏距离
华
大 学
d(Pi , Pj ) ( xi x j )2 ( yi y j )2
数 学
蛮力法：穷举计算 每一对点 的距离，然后找出距离最小的那对点。
大
学 顺序查找的蛮力法
数 学
查找键与表中元素从头至尾逐个比较。结果：找到 或 失败
与 计
限位器：把查找键添加到列表末尾—— 一定成功，避免每次循环时
算
对检查是否越界（边界检查）
机
学 院
SequentialSearch( A[0...n], K ) {
最佳效率：Tbest (n) = 1 最差效率：Tworst(n) = n + 1