第3章_蛮力法详解

第三章 蛮力法1.选择排序SelectionSort(A[0..n-1])for i=0 to n-2 domin=ifor j=i+1 to n-1 doif A[j]<A[min]min=jswap A[i] and A[min]2.冒泡排序BubbleSort(A[0..n-1])// 输入：数组A，数组中的元素属于某偏序集// 输出：按升序排列的数组Afor i=0 to n-2 dofor j=0 to n-2-i doif A[j+1]<A[j] swap A[j] and A[j+1]3.改进的冒泡算法ALGORITHM BubbleSortImproved( A[0,…,n –1] )// 冒泡排序算法的改进// 输入：数组A，数组中的元素属于某偏序集// 输出：按升序排列的数组Afor i ← 0 to n – 2 doflag ← Truefor j ← 0 to n – 2 – i doif A[j+1] < A[j]swap(A[j], A[j+1])flag ← False// 如果在某一轮的比较中没有交换，则flag为True，算法结束returnif flag = True4. 顺序查找算法算法 SwquentialSearch2(A[0...n],k)//顺序查找算法的实现，它用了查找键来作限位器//输入：一个n个元素的数组A和一个查找键K//输出：第一个值等于K的元素的位置，如果找不到这样的元素就返回 -1A[n]<--ki<--0while A[i]!=K doi<--i+1if i<n return iElse return -15. 蛮力字符串匹配算法 BruteForceStringMatch(T[0...n-1],P[0...m-1])//该算法实现了蛮力字符串匹配代表一段文本//输入：一个n个字符的数组T[0...n-1]// 一个m个字符的数组P[0..m-1]代表一个模式//输出：如果查找成功的话，返回文本的第一个匹配字串中第一个字符的位置， // 否则返回-1For i<--0 to n-m doj<--0While j<m and P[j]=T[i+j]doj<--i+1If j=m return ireturn -1合并排序最差Θ(nlog2n)快速排序最优Θ(nlog2n)最差Θ(n2)平均Θ(1.38nlog2n)选择排序 Θ(n2)冒泡排序 Θ(n2)插入排序最差Θ(n2)最优 Θ(n)平均 Θ(n2)第四章 分治法合并排序算法 MergeSort(A[0..n-1] )排序 // 递归调用mergesort来对数组 A[0...n-1]// 输入：一个可排序数组A[0..n-1]// 输出：非降序排列的数组A[0..n-1]if n > 1n/2 -1]copy A[0.. n/2 -1] to B[0..n/2 -1]copy A[ n/2 ..n-1] to C[0..MergeSort( B )MergeSort( C )Merge( B,C,A )两个数组合并的算法算法 Merge(B[0..p-1],C[0..q-1],A[0..p+q-1])//将两个有序数组合并成一个有序的数组和C[0...q-1]//输入：两个有序数组B[0...p-1]//输出：A[0..p+q-1]中已经有序存放了B和C中的元素 i=0,j=0,k=0;while i<p and j<q do≤C[j]if B[i]A[k]=B[i], i=i+1elseA[k]=C[j], j=j+1k=k+1if i=pcopy C[j..q-1] to A[k..p+q-1]elsecopy B[i..p-1] to A[0..p+q-1]快速排序算法QuickSort(A[l..r])// 使用快速排序法对序列或者子序列排序或者序列本身A[0..n-1]// 输入：子序列A[l..r]// 输出：非递减序列Aif l < rs ← Partition( A[l..r] )QuickSort( A[l..s-1] )QuickSort( A[s+1..r] )//s是中轴元素/基准点，是数组分区位置的标志实现分区的算法Partition( A[l..r] )// 输入：子数组A[l..r]// 输出：分裂点/基准点pivot的位置p ← A[l]i ← l; j ← r+1repeat≥ prepeat i ←i + 1until A[i]≤ prepeat j ← j – 1 until A[j]swap( A[i], A[j] )≥ juntil iswap( A[i], A[j] )swap( A[l], A[j] )return j折半查找BinarySearch( A[0..n-1], k )// 输入：已排序大小为n的序列A，待搜索对象k// 输出：如果搜索成功，则返回k的位置，否则返回-1 l=0,r=n-1;While l≤rmid= (l+r)/2if k = A[mid] return midelse if k < A[mid] r=m-1else l=m+1return -1Strassen矩阵Strassen方法M1=A11(B12-B22)M2=(A11+A12)B22M3=(A21+A22)B11M4=A22(B21-B11)M5=(A11+A22)(B11+B22)M6=(A12-A22)(B21+B22)M7=(A11-A21)(B11+B12)第五章 减治法插入排序ALGORITHM InsertionSort( A[0..n-1] )// 对给定序列进行直接插入排序// 输入：大小为n的无序序列A// 输出：按非递减排列的序列Afor i ← 1 to n-1 dotemp ← A[i]j ← i-1while j ≥ 0 and A[j] > temp doA[j+1] ← A[j]j ← j –1A[j+1] ←temp深度优先查找算法 BFS（G）//实现给定图的深度优先查找遍历//输入：图G=<V,E>//输出：图G的顶点，按照被DFS遍历第一次访问到的先后次序，用连续的整数标记，将V中的每个顶点标记为0，表示还“未访问”count =0//记录这是第几个访问的节点标记为 unvisitedmark each vertex with 0//∈ V dofor each vertex vif v is marked with 0dfs(v)dfs(v)//递归访问所有和v相连接的未访问顶点，然后按照全局变量count的值//根据遇到它们的先后顺序，给它们附上相应的数字count = count + 1mark v with countv dofor each vertexw adjacent toif w is marked with 0dfs(w)广度优先BFS(G)/实现给定图的深度优先查找遍历//输入：图G=<V,E>//输出：图G的顶点，按照被BFS遍历第一次访问到的先后次序，用连续的整数标记，将V中的每个顶点标记为0，表示还“未访问”count =0mark each vertex with 0for each vertex v∈ V dobfs(v)bfs(v)//递归访问所有和v相连接的未访问顶点，然后按照全局变量count的值//根据遇到它们的先后顺序，给它们附上相应的数字count = count + 1mark v with countinitialize queue with vwhile queue is not empty doa = front of queuefor each vertex w adjacent to a doif w is marked with 0count = count + 1mark w with countadd w to the end of the queueremove a from the front of the queue拓扑排序第六章 变治法Gauss消去法GaussElimination(A[1..n], b[1..n])// 输入：系数矩阵A及常数项 b// 输出：方程组的增广矩阵等价的上三角矩阵for i=1 to n doA[i][n+1] =b[i]for j= i+1 to n dofor k = i to n+1 do– A[i][k]*A[j][i]/A[i][i]A[j][k] = A[j][k]堆排序堆排序主要包括两个步骤：对于给定的数组构造相应的堆。

《算法设计与分析》实验报告一学号：姓名：日期：20161230 得分：一、实验内容：TSP问题二、所用算法的基本思想及复杂度分析：1、蛮力法1）基本思想借助矩阵把问题转换为矩阵中点的求解。

首先构造距离矩阵，任意节点到自身节点的距离为无穷大。

在第一行找到最小项a[1][j]，从而跳转到第j行，再找到最小值a[j][k]，再到第k行进行查找。

然后构造各行允许数组row[n]={1,1…1}，各列允许数组colable[n]={0,1,1….1}，其中1表示允许访问，即该节点未被访问；0表示不允许访问，即该节点已经被访问。

如果改行或该列不允许访问，跳过该点访问下一节点。

程序再发问最后一个节点前，所访问的行中至少有1个允许访问的节点，依次访问这些节点找到最小的即可；在访问最后一个节点后，再次访问，会返回k=0，即实现访问源节点，得出一条简单回路。

2）复杂度分析基本语句是访问下一个行列中最小的点，主要操作是求平方，假设有n个点，则计算的次页脚内容1数为n^2-n。

T(n)=n*(n-1)=O(n^2)。

2、动态规划法1）基本思想假设从顶点s出发，令d(i, V’)表示从顶点i出发经过V’(是一个点的集合)中各个顶点一次且仅一次，最后回到出发点s的最短路径长度。

推导：(分情况来讨论)①当V’为空集，那么d(i, V’)，表示从i不经过任何点就回到s了，如上图的城市3->城市0(0为起点城市)。

此时d(i, V’)=Cis(就是城市i 到城市s 的距离)、②如果V’不为空，那么就是对子问题的最优求解。

你必须在V’这个城市集合中，尝试每一个，并求出最优解。

d(i, V’)=min{Cik +d(k, V’-{k})}注：Cik表示你选择的城市和城市i的距离，d(k, V’-{k})是一个子问题。

综上所述，TSP问题的动态规划方程就出来了：2）复杂度分析和蛮力法相比，动态规划求解tsp问题，把原来时间复杂性O（n！）的排列转化为组合问题，从而降低了时间复杂度，但仍需要指数时间。

蛮力法、分治法、减治法三种方法的理解和处理问题的类型的归纳一、蛮力法蛮力法是一种基础且直接的问题解决策略，通常用于寻找问题的答案或解决方案。

其核心理念在于，通过逐一检查所有可能的解决方案，从而找到问题的答案或找到最佳的解决方案。

在蛮力法中，我们通常需要投入较多的时间和计算资源，尤其是在面对大规模或复杂的问题时。

蛮力法的应用范围广泛，包括但不限于以下几种类型的问题：1. 排序问题：例如，对一个数组进行排序，我们可以使用蛮力法，通过比较每对元素并交换它们的位置，使得整个数组有序。

2. 查找问题：例如，在排序数组中查找一个特定的元素，我们可以使用蛮力法，逐一检查数组中的每个元素直到找到目标元素。

3. 组合与排列问题：例如，计算给定集合的所有可能排列或组合，我们可以使用蛮力法，通过逐一排列或组合所有可能的元素组合得到答案。

二、分治法分治法是一种将复杂问题分解为更小、更易于处理的子问题的方法。

通过将问题分解为独立的子问题，我们可以分别解决每个子问题，然后将这些解决方案组合起来，形成原始问题的解决方案。

这种方法在处理复杂问题时非常有效，因为它可以降低问题的复杂性，使我们可以更有效地解决问题。

分治法的应用范围广泛，包括但不限于以下几种类型的问题：1. 排序问题：例如，归并排序就是一种使用分治法的排序算法，它将一个大列表分解为两个小列表，对这两个小列表分别进行排序，然后合并它们以得到有序列表。

2. 搜索问题：例如，二分搜索是一种使用分治法的搜索算法，它将搜索空间一分为二，每次迭代都排除一半的元素，直到找到目标元素或确定元素不存在。

3. 图问题：例如，Dijkstra的算法就是一种使用分治法的图搜索算法，它将图分解为最短路径树，然后通过搜索每个子图的最短路径来解决整个图的最短路径问题。

三、减治法减治法是一种通过减少问题的规模或复杂性来解决问题的方法。

其核心理念在于，通过消除或减少问题的某些部分或特性，从而降低问题的复杂性或规模，使得问题更容易解决。

算法——蛮⼒法之最近对问题和凸包问题 上次的博客写到⼀半宿舍停电了。

然⽽今天想起来补充完的时候发现博客园并没有⾃动保存哦，微笑。

最近对问题 ⾸先来看最近对问题，最近对问题描述的就是在包含n个端的集合中找到距离最近的两个点，当然问题也可以定义在多维空间中，但是这⾥只是跟随书上的思路实现了⼆维情况下的最近对问题。

假设所有讨论的点是以标准的笛卡尔坐标形式（x，y）给出的，那么在两个点P i=(X i，Y i)和P j=（X j，Y j）之间的距离是标准的欧⼏⾥得距离： d(P i,P j)=sqrt( (X1-X2)2+(Y1-Y2)2 )蛮⼒法的思路就是计算出所有的点之间的距离，然后找出距离最⼩的那⼀对，在这⾥增加效率的⼀种⽅式是只计算点下标 i<j 的那些对点之间的距离，这样就避免了重复计算同⼀对点间距离。

下⾯是蛮⼒法解决最近对问题的算法：使⽤蛮⼒法求平⾯中距离最近的两点BruteForceClosetPoints（P）//输⼊：⼀个n（n≥2）的点的列表P，P i=(X i，Y i)//输出：距离最近的两个点的下标index1和index2dmin <— ∞for i <— 1 to n-1 do for j <— i+1 to n do d <— sqrt( (X i-X i)2+(Y j-Y j)2 ) if d<dmin dmin=d; index1=i; index2=j;return index1,index2 该算法的关键步骤是基本操作虽然是计算两个点之间的欧⼏⾥得距离，但是求平⽅根并不是像加法乘法那么简单。

上⾯算法中，开平⽅函数导数恒⼤于0，它是严格递增的，因此我们可以直接只计算(X i-X i)2+(Y j-Y j)2，⽐较d2的⼤⼩关系，这样基本操作就变成了求平⽅。

平⽅操作的执⾏次数是： n（n-1）∈Θ（n2）因此，蛮⼒法解决最近对问题的平均时间复杂度是Θ（n2） 下⾯是该算法的c++代码实现部分，在实现这个算法时，我碰到了三个问题： ⼀是：怎么表⽰⼀个点集，因为最终返回的下标是集合中点的下标，要⽤的数据结构就是⼀维数组，但是点的xy坐标⼜要怎么表⽰呢，这⾥我在头⽂件中创建了struct类型的点结构，该结构拥有的成员变量就是x代表的横坐标和y代表的纵坐标，这样就可以直接创建该结构的⼀位数组进⾏计算了。

实验项目三 用蛮力法、动态规划法和贪心法求解0/1背包问题实验目的1、学会背包的数据结构的设计，针对不同的问题涉及到的对象的数据结构的设计也不同；2、对0-1背包问题的算法设计策略对比与分析。

实验内容：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;//物品的重量int v;//物品的价值}wup;wup wp[N];//物品的数组，N 为物品的个数int c;//背包的总重量1、蛮力法蛮力法是一种简单直接的解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。

蛮力法的关键是依次处理所有的元素。

用蛮力法解决0/1背包问题，需要考虑给定n 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包容量的子集），计算每个子集的总价值，然后在他们中找到价值最大的子集。

所以蛮力法解0/1背包问题的关键是如何求n 个物品集合的所有子集，n 个物品的子集有2的n 次方个，用一个2的n 次方行n 列的数组保存生成的子集，以下是生成子集的算法：⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1）∑=ni i i x v 1max （式2）void force(int a[16][4])//蛮力法产生4个物品的子集{int i,j;int n=16;int m,t;for(i=0;i<16;i++){ t=i;for(j=3;j>=0;j--){m=t%2;a[i][j]=m;t=t/2;}}for(i=0;i<16;i++)//输出保存子集的二维数组{for(j=0;j<4;j++){printf("%d ",a[i][j]);}printf("\n");}｝以下要依次判断每个子集的可行性，找出可行解:void panduan(int a[][4],int cw[])////判断每个子集的可行性，如果可行则计算其价值存入数组cw,不可行则存入0{int i,j;int n=16;int sw,sv;for(i=0;i<16;i++){sw=0;sv=0;for(j=0;j<4;j++){sw=sw+wp[j].w*a[i][j];sv=sv+wp[j].v*a[i][j];}if(sw<=c)cw[i]=sv;elsecw[i]=0;}在可行解中找出最优解，即找出可行解中满足目标函数的最优解。

关于算法--蛮⼒法--字符与字符串匹配⼀、顺序查找1、步骤：简单的将给定列表中的连续元素与给定的查找键作⽐较，直到遇到⼀个匹配的元素或遇到匹配元素前就遍历了整个列表2、JavaScript代码实现1 <!DOCTYPE html>2 <html lang="en">3 <head>4 <meta charset="UTF-8">5 <title>SelectionFind</title>6 </head>7 <body>89 </body>10 <script type="text/javascript">11var search = function(arr, k) {12var n = arr.length;13 arr[n] = k;14var i = 0;15while(arr[i] != k){16 i ++;17 }18if( i < n){19return i;20 }else{21return -1;22 }2324 };25var num = search(['a','b','c','d','e','f','g'], 'b');26 console.log(num);27 </script>28 </html>3、算法分析：顺序查找算法具有蛮⼒法的优点（简单）和缺点（效率低），是⼀个线型算法⼀、蛮⼒字符串匹配1、步骤（需要从m个“⽂本”中取出n个“模式”字符串） a、将模式对准⽂本的前m个字符，从左向右匹配每⼀对响应的字符，直到m对字符全部匹配（此时算法停⽌）或者遇不到⼀对匹配的字符串 b、在后⼀种情况下，模式向右移⼀位，然后从模式的第⼀个字符开始，继续把模式和⽂本中的对应字符作⽐较2、JavaScript代码实现1 <!DOCTYPE html>2 <html lang="en">3 <head>4 <meta charset="UTF-8">5 <title>蛮⼒法字符串匹配</title>6 </head>7 <body>89 </body>10 <script type="text/javascript">11var search = function(arrT, arrP) {12var m = arrT.length;13var n = arrP.length;14for(var i = 0; i < m - n ; i++){15var j = 0;16while(( j < m ) && (arrP[j] == arrT[j + i])){17 j++;18 }19if(j == n){20return i;21 }22 }23return -1;24 };25 console.log(search(['a','b','c','d','e','f','g'],['c','d','e']));26 </script>27 </html>3、算法分析移动“模式”之前，可能做⾜m次⽐较，⽽n-m+1次尝试都有可能出现，最坏的情况下，算法属于Θ(mn)，平均效率下，算法属于Θ(m+n)=Θ(m)。