算法设计与分析-第3章-蛮力法
合集下载
算法设计与分析基础第2版清华出版社算法分析第3章
任务1
人员1 9 人员2 6 人员3 5 人员4 7
任务2
2 4 8 6
任务3
7 3 1 9
任务4
8 7 8 4
<1,2,3,4> <1,2,4,3> <1,3,2,4> <1,3,4,2> <1,4,2,3> <1,4,3,2>
9 2 7 8
C
6
4
3
7
5 8 1 8
7
n1 n
n1
C(n)22(ni)
i1ji1
i1
2[n (1)(n2).. .1](n1)n(n2)
3.3.2 凸包问题
定义 对于平面一的一个点集合（有限的或无限的），如 果以集合中任意两点P和Q为端点的线段都属于该集合， 我们说这个集合是凸的。
定义 一个点集合S的凸包是包含S的最小凸集合（“最小” 意指，S的凸包一定是所有包含S的凸集合的子集）。
物品2
(a)
物品3 物品4
子集
ø {1} {2} {3} {4} {1,2} {1,3} {1,4} {2,3} {2,4}
{3,4}
{1,2,3} {1,2,4} {1,3,4} {2,3,4} {1,2,3,4}
总重量
0 7 3 4 5 10 11 12 7 8
9
14 15 16 12 19
总价值
3.1 选择排序和冒泡排序
3.1.1选择排序
A0≤A1≤…Ai-1|Ai ,…,Amin ,…, An-1
已经位于最终的位 置上了
最后的n-1个元素
算法 SelectionSort(A[0..n-1]) //该算法用选择排序对给定的数组排序 //输入：一个可排序数组A[0..n-1] //输出：非降序排序的数组A[0..n-1] for i←0 to n-2 do
蛮力法
C( n )
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)!)的算法
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)!)的算法
机算法设计与分析基础(第三章蛮力法)2ppt课件
S e q u e n t i a l S e a r c h ( A [ 0 . . . n ] , K ) 最佳效率：Tbest (n) = 1
{ A[n ] K // 限 位 器 i 0 w h ile ( A[i] K ) i i 1 if (i n ) retu rn (i) // 成 功 else retu rn ( 1) // 失 败
}
最差效率：Tworst(n) = n + 1
问：为何定义 A 数组为 n+1 维？ 答：有一个位置放限位器 问：若输入有序，算法可改进？ 答：遇到 ≤ 或 ≥ 查找键元素，
立即停止查找。
编辑版pppt
18
蛮力字符串匹配
蛮力字符串匹配 —— 也称 串模式匹配 文本（Text）： n 个字符的串 模式（Pattern）：m 个字符的串（n > m , 模式小于文本）
{ 串匹配之蛮力法
j 0 // 每 次 从 P[0]开 始 while j m and P[ j] T [i j] do
j j1 if j m return i } return 1 // 没 找 到 匹 配
思考： while 结束时 j=？ ① j<m ② j=m j < m : 提前退 出循环，模式 不匹配。 j = m : 找到了 匹配模式。
—— 直接干吧！（ 最容易想到 ）
一个简例
已知：数字 蛮力算法：
aa 和n非负a整数an ，要a求：..设.计计a算
an
值的算法
n个 策略：直接基于问题定义来设计算法 —— 把 a 和 a 相乘 n 次 其他蛮力策略应用
——选择排序、冒泡排序、插入排序、顺序查找、朴素的字符 串匹配
——比较常用还有枚举法、盲目搜索算法等。
算法设计与分析-蛮力思想
在后面的讨论中，前后文意思清楚的情况下，约定：
把“记录的关键字的大小”和“记录的关键字的比较”简称 为“记录的大小”和“记录的比较”。
将“元素的关键字的大小”和“结点的关键字大小”简称为 “元素的大小”和“结点的大小”。
3.1.2 排序的分类
根据在排序过程中涉及的存储器不同，可将排序方法分为 两大类：内部排序和外部排序。 内部排序是指待排序列完全存放在内存中所进行的排序过 程，适合不太大的元素序列。 外部排序指的是大文件的排序，待排序的文件无法一次装 入内存，将待排序的记录存储在外存储器上，需要在内存 和外部存储器之间进行多次数据交换，以达到排序整个文 件的目的。
移动记录空出插入位置
将有序区中从位置i到j-1的记录向后移动，空出插入位置j，代码为：
L.rcd[0] = L.rcd[i+1]; // 先将记录L.rcd[i+1]保存在空闲的0号单元 k = i; while(k>j) { L.rcd[k+1] = L.rcd[k]; k--; } // 从后到前移动记录
数据结构
广东工业大学 计算机学院
第3章 排序基础
第3章 排序基础
3.1 排序的概念与分类
3.1.1 排序的概念
3.1.2 排序的分类
3.2 直接插入排序
3.3 希尔排序
3.4 基数排序
3.4.1 多关键字排序 3.4.2 基数排序
3.1 排序的概念与分类
含有多个域的数据元素称为记录。 用于对记录进行唯一标识的域称为关键字。 为了与元素类型ElemType区别，记录类型定义为 RecordType。 typedef int KeyType; // 关键字类型为整数类型 typedef struct {
3-蛮力法
最佳效率：Tbest (n) = 1 最差效率：Tworst(n) = n + 1 问：为何定义 A 数组为 n+1 维？ 答：有一个位置放限位器 问：若输入有序，算法可改进？ 答：遇到 ≤ 或 ≥ 查找键元素， 立即停止查找。
14
字符串匹配
问题：给定一个n个字符组成的串，称为文本，一个 m（m≤n）个字符组成的串称为模式，从文本中寻找 匹配模式的子串。
16
字符串匹配
流程图或伪代码
算法 bruteForceStringMatch(T[0..n-1],P[0..m-1]) //蛮力字符串匹配算法实现 //输入1：一个n个字符的数组T[0..n-1]代表一段文本 //输入2：一个m个字符的数组P[0..m-1]代表一个模式 //输出：若查找成功，返回文本第一个匹配子串中的第一 个字符的位置，否则返回-1 for i←0 to n-m do j←0 while j<m and P[j]=T[i+j] j←j+1 if j=m return i return -1 17
8
排序问题
正确性证明 算法分析
输入规模：序列元素个数n 基本操作：比较次数A[j] < A[min] 影响基本操作执行次数的因素：n 建立基本操作求和表达式 利用求和公式分析算法时间复杂性
T ( n)
n 2 n 1 i Байду номын сангаас0 j i 1
1 [n (i 1)] [n i 1]
7
排序问题
小规模实例分析
1 89 17 17 17 17 17 17
2 45 45 29 29 29 29 29
3 68 68 68 34 34 34 34
14
字符串匹配
问题：给定一个n个字符组成的串，称为文本，一个 m（m≤n）个字符组成的串称为模式，从文本中寻找 匹配模式的子串。
16
字符串匹配
流程图或伪代码
算法 bruteForceStringMatch(T[0..n-1],P[0..m-1]) //蛮力字符串匹配算法实现 //输入1：一个n个字符的数组T[0..n-1]代表一段文本 //输入2：一个m个字符的数组P[0..m-1]代表一个模式 //输出：若查找成功，返回文本第一个匹配子串中的第一 个字符的位置，否则返回-1 for i←0 to n-m do j←0 while j<m and P[j]=T[i+j] j←j+1 if j=m return i return -1 17
8
排序问题
正确性证明 算法分析
输入规模：序列元素个数n 基本操作：比较次数A[j] < A[min] 影响基本操作执行次数的因素：n 建立基本操作求和表达式 利用求和公式分析算法时间复杂性
T ( n)
n 2 n 1 i Байду номын сангаас0 j i 1
1 [n (i 1)] [n i 1]
7
排序问题
小规模实例分析
1 89 17 17 17 17 17 17
2 45 45 29 29 29 29 29
3 68 68 68 34 34 34 34
最新算法分析与设计复习大纲（全）
精品文档精品文档算法分析与设计复习大纲第1章 绪论 考点：1、 算法的5个重要特性。
个重要特性。
答：输入、输出、有穷性、确定性、可行性2、 掌握扩展递归技术和通用分治递推式的使用。
掌握扩展递归技术和通用分治递推式的使用。
扩展递归技术：扩展递归技术：通用分支递归式：通用分支递归式：5、使用扩展递归技术求解下列递推关系式 （1）（2）第3章 蛮力法1、掌握蛮力法的设计思想：掌握蛮力法的设计思想：蛮力法依赖的基本技术——扫描技术，即采用一定的策略将待求解问题的所有元素依次处理一次，从而找出问题的解;关键——依次处理所有元素。
依次处理所有元素。
2、蛮力法的代表算法及其时间复杂度：蛮力法的代表算法及其时间复杂度：顺序查找，O(n)串匹配（BF O(n*m) ，KMP O(n+m)选择排序，O(n2)冒泡排序，O(n 2)生成排列对象（排列问题），O(n!)生成子集（组合问题），O(2n)0/1背包背包 属于组合问题。
属于组合问题。
任务分配，哈密顿回路，TSP问题问题属于排列问题。
属于排列问题。
3、 掌握BF 和KMP 算法的原理，能够画出比较过程。
要求给出一串字符串，能够求出对应的next 数组，并能使用KMP 算法进行比较匹配。
算法进行比较匹配。
4、 掌握选择排序和冒泡排序算法描述和时间复杂性，要求能够写出伪代码。
选择排序选择排序算法描述：选择排序开始的时候，扫描整个序列，找到整个序列的最小记录和序列中的第一记录交换，从而将最小记录放到它在有序区的最终位置上，然后再从第二个记录开始扫描序列，找到n-1个序列中的最小记录，再和第二个记录交换位置。
一般地，第i 趟排序从第i 个记录开始扫描序列，在n-i+1个记录中找到关键码最小的记录，并和第i 个记录交换作为有序序列的第i 个记录。
个记录。
时间复杂性：O(n 2) 伪代码：伪代码：冒泡排序冒泡排序算法描述：冒泡排序开始的时候扫描整个序列，冒泡排序开始的时候扫描整个序列，在扫描过程中两两比较相邻记录，在扫描过程中两两比较相邻记录，在扫描过程中两两比较相邻记录，如果反序则交换，如果反序则交换，最终，最大记录就能被“沉到”了序列的最后一个位置，第二趟扫描将第二大记录“沉到”了倒数第二个位置，重复上述操作，直到n-1趟扫描后，整个序列就排好序了。
第 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
第3章 蛮力法——串的模式匹配
模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i
第 5 趟
a b a b c a b c a c b a b a b c a c
j
i=5，j=1失败 i回溯到6，j回溯到1
模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i i i i i
第 3 趟
a b a b c a b c a c b a b a b c a c
j j j j j
i=7，j=5失败 i回溯到4，j回溯到1
模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i
第 3 趟
a b a b c a b c a c b a b a b c a c
k
算法3.4——KMP算法中求next数组
void GetNext(char T[ ], int next[ ]) { 位置j 1 2 3 4 5 next[1]=0; j=1; k=0; 模式串 a b c a c while (j<T[0]) if ((k= =0)| |(T[j]= =T[k])) j next[j] { j++; 1 0 k++; 2 1 next[j]=k; 3 1 } 4 1 else k=next[k]; } 5 2
next数组的求解方法是： 1、第一位的next值为0，第二位的next值为1，
2、第三位开始首先将当前位的前一位字符与其next值 对应的字符进行比较， 相等:则该位的next值就是前一位的next值加上1；
《算法设计与分析基础》课件-3.蛮力法
if A[j] < A[min] min j
swap A[i] and A[min]
7
2017/12/31
例题：对序列 {89,45,68,90,29,34,17}用选择排序 算法进行排序
• 第1遍： {89，45，68，90，29，34，17} //求最小元素 {17，45，68，90，29，34，89} //交换
• 第5遍： {17，29，34，45，90，68，89} {17，29，34，45，68，90，89}
• 第6遍： {17，29，34，45，68，90，89} {17，29，34，45，68，89，90} //排序结束
8
CHD
（本动画中，参与排序的是R[1]到R[n]，R[0]作为交换中转的空 间；变量j对应前面算法中的变量min）
2017/12/31
ALGORITHM BubbleSort(A[0,…,n – 1]) // 冒泡排序算法在数组上的应用 // 输入：数组A，数组中的元素属于某偏序集 // 输出：按升序排列的数组A for i 0 to n – 2 do
for j 0 to n – 2 – i do if A[j+1] < A[j] swap(A[j], A[j+1])
CHD
(4)对解决一些小规模的问题实例仍然有效
(5)可作为衡量其他算法的参照。
2
2017/12/31
Brute Force Examples:
1. Computing an (a > 0, n a nonnegative integer)
2. Computing n!
3. Multiplying two matrices
算法分析实验3蛮力法排序
实验三蛮力法排序（四号黑体）【一】实验目的（小四黑体）1．采用蛮力法实现序列排序；2．分析各种方法的优缺点。
【二】实验内容（小四黑体）1．采用蛮力排序算法对序列排序；2．编程实现选择排序与冒泡排序；3．分析比较2种算法的时间复杂度；4．试着改进冒泡排序，使算法在序列达到有序状态时停止运行。
【三】实验步骤（代码、结果）（小四黑体）#include <stdio.h>#include <stdlib.h>#include <math.h>void SelectionSort(int a[],int n){int i,j,t,temp;for(i=0; i<=n-2; i++){t=i;for(j=i+1; j<=n-1; j++){if(a[j]<a[t]){t=j;}}temp=a[i];a[i]=a[t];a[t]=temp;}}void BubbleSort(int a[],int n){int i,j,temp;for(i=0; i<=n-2; i++){for(j=0; j<=n-2-i; j++){if(a[j+1]<a[j]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}}void BubbleSort1(int a[],int n){int falg=1;int i,temp;while(falg){falg=0;for(i=0;i<n;i++){if(a[i+1]<a[i]){temp=a[i];a[i]=a[i+1];a[i+1]=temp;falg=1;}}n--;}}void print(int a[],int n){int i;for(i=0; i<n; i++){printf("%d ",a[i]);}}int main(){printf("学号：Z09315221 姓名：谭召\n"); int a[10]= {10,20,15,17,13,9,5,4,2,7}; //int a[10]= {1,2,3,4,5,6,7,8,9,1};SelectionSort(a,10);BubbleSort(a,10);BubbleSort1(a,10);print(a,10);return 0;}【四】实验结果分析（小四黑体）选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。
算法设计与分析蛮力法
4）不做其它的优化，用蛮力法通过循环模拟狱 吏的开关锁过程，最后当第i号牢房对应的数 组元素a[i]为0时，该牢房的囚犯得到大赦。
算法分析与设计
14
算法1如下：
input(n);//输入n
a=new int(n+1);
for (i=1; i<=n;i++)
a[i]=1;
for (i=1; i<=n;i++)
if(100==x+y+z&&100==5*x+3*y+z/3) {print("the cock number is",x)； print("the hen number is", y)；
print("the chick number is "，z);} }
算法分析与设计
8
算法分析与设计
9
Z能被3整除时，才会判断“5*x+3*y+z/3=100
print("the chick number is ",z);} } }
算法分析与设计
10
例2
• 求所有的三位数，它除以11所得的余数等 于它的三个数字的平方和。
解题思路：三位数只有900个，可用枚举 法解决，枚举时可先估计有关量的范围， 以缩小讨论范围，减少计算量。
算法分析与设计
11
• 解：设这个三位数的百位、十位、个位的数字分别为 x，y，z。由于任何数除以11所得余数都不大于10， 所以
蛮力法 Brute Force
• 蛮力法（枚举法、穷举法，暴力法）要求设计 者找出所有可能的方法，然后选择其中的一种 方法，若该方法不可行则试探下一种可能的方 法。
算法分析与设计
14
算法1如下：
input(n);//输入n
a=new int(n+1);
for (i=1; i<=n;i++)
a[i]=1;
for (i=1; i<=n;i++)
if(100==x+y+z&&100==5*x+3*y+z/3) {print("the cock number is",x)； print("the hen number is", y)；
print("the chick number is "，z);} }
算法分析与设计
8
算法分析与设计
9
Z能被3整除时，才会判断“5*x+3*y+z/3=100
print("the chick number is ",z);} } }
算法分析与设计
10
例2
• 求所有的三位数，它除以11所得的余数等 于它的三个数字的平方和。
解题思路：三位数只有900个，可用枚举 法解决，枚举时可先估计有关量的范围， 以缩小讨论范围，减少计算量。
算法分析与设计
11
• 解：设这个三位数的百位、十位、个位的数字分别为 x，y，z。由于任何数除以11所得余数都不大于10， 所以
蛮力法 Brute Force
• 蛮力法（枚举法、穷举法，暴力法）要求设计 者找出所有可能的方法，然后选择其中的一种 方法，若该方法不可行则试探下一种可能的方 法。
算法设计与分析4第三部分第三章
第三部分第三章 蛮力法
分析该算法的效率： 分析该算法的效率： S1：确定输入规模的参数为n S1：确定输入规模的参数为n S2：基本操作是内层循环体中的比较运算 S2： S3：基本操作次数的计算：外层循环执行次数为N S3：基本操作次数的计算：外层循环执行次数为N-1 内层循环执行次数为N 我们可以用求和公式给出： 次，内层循环执行次数为N-i-1次，我们可以用求和公式给出： =n(nC(n)= n − 2 n −1 =n(n-1)/2∈θ(n2)
第三部分第三章 蛮力法
排序问题是我们经常见到的，当前， 排序问题是我们经常见到的，当前，人们已经开 发出了几十种排序方法。 发出了几十种排序方法。 1、选择排序 排序思想：首先从要排序的数中选择最小的数与 排序思想： 第一个数交换位置， 第一个数交换位置，然后再从乘下的数中再 找出最小的数与第二个数交换位置， 找出最小的数与第二个数交换位置，直到剩 下两个数， 下两个数，我们选择较小的数放到倒数第二 个位置，经过n 轮这样的操作后， 个位置，经过n-1轮这样的操作后，数就按 从小到大的顺序排好了。 从小到大的顺序排好了。
第三部分第三章 蛮力法
第三，如果要解决的问题实例不多， 第三 ， 如果要解决的问题实例不多 ， 而且蛮力法可 以用一种能够接受的速度对实例求解，那么， 以用一种能够接受的速度对实例求解 ， 那么 ， 设 计一个更高效算法所花费的代价很可能是不值得 的。 第四，即使效率通常很低， 第四 ， 即使效率通常很低 ， 仍然可以用蛮力算法解 决一些小规模的问题实例。 决一些小规模的问题实例。 最后，一个蛮力算法可以为研究或教学目的服务， 最后 ， 一个蛮力算法可以为研究或教学目的服务 ， 可以用它来恒量同样问题的更高效的算法。 可以用它来恒量同样问题的更高效的算法。
算法设计与分析 第3章 蛮力法
F
B
60 33 30 10 9
E D
C
• 8、背包问题
问题：给定一组物品，每种物品都有自己的重量和价值，在
限定的总重量内，将物品装入背包，且每个物品要么放入背包，要
么完全不放入背包，最终使背包内物品的总价格最高。
作业：
凸包问题求解。
要求：
（1）计算出凸多边形的边长。 （2）要求文字描述求解算法 （3）绘出程序流程 （4）编写完整程序。
4、冒泡排序 5、最近点对问题。 6、凸包问题
通过判断其它的点是否都在某两个点连线所组成的边的某一边
来判断该条边是否是凸多边形上的边。请参见具体的程序。
Graham法求解。
7、旅行商问题
问题：求解旅行者由起点出发，通过所有给定的点之后，最
后再回到起点的最小路径成本，采用穷举的方法。
A
23 20 40 50 18 12 25 30 20 15
第3章 蛮力法
定义：
通过穷举罗列出所有问题的可能情形，然后得到问题的解，也
称为枚举法或者穷举法。 优点：逻辑清晰。 缺点：效率低下。
常用步骤：
（1） 确定枚举变量。 （2） 确定枚举变量的范围。 （3） 确定约束条件，以找到百鸡问题。
一只公鸡值钱5元，一只母鸡值钱3元，三只小鸡值钱1元。如 果希望花100元钱买100只鸡，问如何买？
2、顺序查找算法 3、选择排序
void SelectionSort(float a,int n) { float temp; for(int i=0;i<=n-2;i++) { min=i; for(int j=i+1;j<=n-1;j++) if(a[j]<a[min]) min=j; temp=a[i]; a[i]=a[min]; a[min]=temp; } }
蛮力法详解
算法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）蛮力法可以作为某类问题时间性能（不是复杂性， 两者恰好相反）的下界，来衡量同样问题的更高效算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
哨兵
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
背包
序号
1 2 3 4 5 6 7 8
子集
φ {1} {2} {3} {4} {1,2} {1,3} {1,4}
清华大学出版社
算法设计与分析
3.4 组合问题中的蛮力法
3.4.1 生成排列对象 3.4.2 生成子集 3.4.3 0/1背包问题 3.4.4 任务分配问题
清华大学出版社
算法设计与分析
3.4.1 生成排列对象
假设已经生成了所有(n-1)!个排列，可以把n插入到n-1个元 素的每一种排列中的n个位置中去，来得到问题规模为n的 所有排列。按照这种方式生成的所有排列都是独一无二的， 并且他们的总数应该是n(n-1)!=n!。
开始 插入2 插入3
1 12 21 123 132 312 213 231 321
生成排列的过程
清华大学出版社
算法设计与分析
算法3.9——生成排列对象 1．生成初始排列{1}； 2．for (i=2; i<=n; i++)
for (j=1; j<=(i-1)!; j++) for (k=i; k>=1; k--) 将i插入到第j个排列中的第k个位置；
清华大学出版社
算法设计与分析
本趟匹配开始位置
回溯 i
主串S
si
模式T
…
tj
j
回溯
……
清华大学出版社
算法设计与分析
设主串s=“ababcabcacbab”，模式t=“abcac
i ii i
第a b a bc a bc a cb a b
趟 a bc
jj j j
i=3，j=3失败； i回溯到2，j回溯到1
2.1 如果S[i]=T[j]，则继续比较S和T的下一个字符；否则 2.2 将j向右滑动到next[j]位置，即j=next[j]； 2.3 如果j=0，则将i和j分别加1，准备下一趟比较； 3. 如果T中所有字符均比较完毕，则返回匹配的起始下标；否则返回0；
KMP算法的时间复杂性是O(n+m)，当m<<n时，KMP 算法的时间复杂性是O(n)。
（1）理论上，蛮力法可以解决可计算领域的各种问题。 （2）蛮力法经常用来解决一些较小规模的问题。 （3）对于一些重要的问题蛮力法可以产生一些合理的算 法，他们具备一些实用价值，而且不受问题规模的限制。 （4）蛮力法可以作为某类问题时间性能的底限，来衡量 同样问题的更高效算法。
清华大学出版社
算法设计与分析
j
清华大学出版社
算法设计与分析
3
i i ii i
第 a b a b c a b c a c ba b 趟
a b c a c i=7，j=5失败
j j jj j
4
第
i
趟 a b a b c a b c a c ba b
a
s4=t2;t1≠t2
j
∴t1≠s4
清华大学出版社
算法设计与分析
i
第 a b a b c a b c a c ba b 趟
an=a×a×…×a n次
清华大学出版社
算法设计与分析
蛮力法所赖的基本技术——扫描技 术
关键——依次处理所有元素 基本的扫描技术——遍历
（1）集合的遍历 （2）线性表的遍历 （3）树的遍历 （4）图的遍历
清华大学出版社
算法设计与分析
虽然巧妙和高效的算法很少来自于蛮力法，基于 以下原因，蛮力法也是一种重要的算法设计技术：
（2）算法改进所取得的积累效益不容忽视：串匹配操作 经常被调用，执行频率高。
清华大学出版社
蛮力法解决串匹配问题——BF算法
算法设计与分析
基本思想：从主串S的第一个字符开始和模式T的第一个
字符进行比较，若相等，则继续比较两者的后续字符；若不 相等，则从主串S的第二个字符开始和模式T的第一个字符 进行比较，重复上述过程，若T中的字符全部比较完毕，则 说明本趟匹配成功；若最后一轮匹配的起始位置是n-m，则 主串S中剩下的字符不足够匹配整个模式T，匹配失败。这 个算法称为朴素的模式匹配算法，简称BF算法。
w1=7 v1=42
物品1
w2=3 v2=12
物品2
w3=4 v3=40
物品3
w4=5 v4=25
物品4
总重量
0 7 3 4 5 10 11 12
总价值
0 42 12 40 25 54 不可行 不可行
序号
9 10 11 12 13 14 15 16
子集 总重量 总价值
{2,3} 7 {2,4} 8 {3,4} 9 {1,2,3} 14 {1,2,4} 15 {1,3,4} 16 {2,3,4} 12 {1,2,3,4} 19
算法设计与分析
4
第
ii
趟 a b a b c a b c a c ba b
i=4，j=1失败
a
i回溯到5，j回溯到1
jj
5
ii
第 a b a b c a b c a c ba b 趟
a
i=5，j=1失败
jj
i回溯到6，j回溯到1
清华大学出版社
算法设计与分析
6
第
i i i ii i
趟 a b ab c a b c a cb a b
else {i=i-j+2; j=1; }
}
if (j>m)return (i-j+1);
else return 0;
}
清华大学出版社
算法设计与分析
设串S长度为n，串T长度为m，在匹配成功的情况下， 考虑最坏情况，即每趟不成功的匹配都发生在串T的最后一 个字符。
例如：S="aaaaaaaaaaab"
显然，算法3.9的时间复杂性为O(n!)，也就是说和 排列对象的数量成正比。
清华大学出版社
算法设计与分析
3.4.2 生成子集
n个元素的集合A={a1, a2,……, an}的所有2n个子集和长度为n 的所有2n个比特串之间的一一对应关系。
建立对应关系：为每一个子集指定一个比特串b1b2…bn，如 果ai属于该子集，则bi＝1；如果ai不属于该子集，则bi＝0 （1≤i≤n）。
3.2 查找问题中的蛮力法
3.2.1 顺序查找 3.2.2 串匹配问题
清华大学出版社
算法设计与分析
3.2.1 顺序查找
顺序查找从表的一端向另一端逐个将元素与给定值进行 比较，若相等，则查找成功，给出该元素在表中的位置；若 整个表检测完仍未找到与给定值相等的元素，则查找失败， 给出失败信息。
0 1 23 456 7 8 9 10 15 24 6 12 35 40 98 55
查找方向
i
清华大学出版社
算法设计与分析
算法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，其执行次数为:
5
a
s5=t3;t1≠t3
j
∴t1≠s5
6
第
i iii i
趟 a b a b c a b c a cb a b
abcac
i=11 ， j=6 ， t 中 全 部 字 符 都比较完毕，匹配成功。
j jjj j
清华大学出版社
算法设计与分析
结论： i可以不回溯，模式向右滑动到的新 比较起点k ，并且k 仅与模式串T有关！
i --; return i; }
算法3.2的基本语句是r[i]!=k，其执行次数为:
n
i 1
pici
1 n
n
(n
i 1
i
1)