蛮力算法的特点范文

第1篇一、实验目的1. 理解蛮力法的基本概念和原理。

2. 掌握蛮力法的实现方法。

3. 分析蛮力法的优缺点及其适用场景。

4. 通过实际案例，加深对蛮力法的理解。

二、实验内容本次实验主要围绕蛮力法展开，通过以下步骤进行：1. 蛮力法的基本概念和原理- 了解蛮力法的定义：蛮力法是一种简单直接的算法设计策略，也称为暴力法、枚举法或穷举法。

- 掌握蛮力法的原理：蛮力法通过对问题涉及的所有可能情况进行逐一尝试，以找到问题的解。

2. 蛮力法的实现方法- 学习蛮力法的实现方法，包括循环结构、条件判断等。

- 通过实例，掌握蛮力法的编程实现。

3. 蛮力法的优缺点及其适用场景- 分析蛮力法的优点：简单易懂，易于实现。

- 分析蛮力法的缺点：效率低下，不适合处理大规模问题。

- 探讨蛮力法的适用场景：适用于问题规模较小、解空间有限的情况。

4. 实际案例- 以背包问题为例，演示蛮力法的应用。

- 分析背包问题中蛮力法的实现过程，以及时间复杂度。

三、实验步骤1. 设计实验环境- 选择合适的编程语言，如Python、Java等。

- 安装必要的开发工具和库。

2. 实现蛮力法- 编写蛮力法解决背包问题的代码。

- 分析代码的执行过程，确保逻辑正确。

3. 测试和验证- 使用不同规模的背包问题实例进行测试。

- 比较蛮力法与其他算法（如动态规划）的效率。

4. 分析和总结- 分析蛮力法的优缺点，以及适用场景。

- 总结实验过程中的心得体会。

四、实验结果与分析1. 蛮力法解决背包问题的代码实现```pythondef knapsack(weights, values, capacity):n = len(weights)results = []for i in range(1 << n):total_weight = 0total_value = 0for j in range(n):if i & (1 << j):total_weight += weights[j]total_value += values[j]if total_weight <= capacity:results.append((total_weight, total_value))return max(results, key=lambda x: x[1])```2. 背包问题实例测试- 实例1：`weights = [1, 2, 3], values = [1, 5, 4], capacity = 4`- 实例2：`weights = [1, 2, 3], values = [1, 5, 4], capacity = 5`3. 效率比较- 蛮力法的时间复杂度为O(2^n)，其中n为物品数量。

蛮力算法的基本条件
我觉得这蛮力算法啊，它得有几个基本条件。

首先呢，得是直来直去的那种思维，就像我老家村里头的二柱子，那家伙，脑子一根筋。

看他那模样，脸黑黝黝的，眼睛瞪起来像铜铃，头发乱得跟鸡窝似的，每次决定做啥事儿，就直接冲着目标去，啥弯儿都不拐，这就有点蛮力算法那味儿。

这算法得有个明确的目标，就好比我去集上找老王头买他那只芦花鸡。

我心里就想着那只芦花鸡，其他鸡啊鸭啊的，我看都不看。

我到了集上，人挤人，那气味儿啊，混杂着鸡屎味、汗臭味，还有各种小吃的香味儿。

可我不管这些，我就一门心思找老王头和他的芦花鸡。

这目标明确了，才好施展这蛮力算法。

还有啊，这算法不能怕麻烦。

我记得有次我想找个旧书，那书可稀罕了，在一堆旧书堆里找。

那些书啊，堆得像小山似的，灰扑扑的，有的还破破烂烂。

我就一本一本地翻，旁边有人就笑我，说我傻，这么多书咋找得到。

我就跟他说，“你懂啥，我这就是要找，哪怕把这堆书全翻遍喽。

”这就像蛮力算法，不管多麻烦，就是一个劲儿地干。

再有呢，这蛮力算法在做的时候，还不能想太多旁的东西。

我有一回跟人打赌，看谁先把一块地的杂草拔完。

我就蹲下来，开始拔草。

旁边那人呢，一会儿看看天，一会儿看看地，还跟路过的人聊天。

我就不管，我就看着我眼前的草，一根一根地拔。

那草的叶子刺得我手痒痒的，我也不管，就这么干。

这就像蛮力算法，专注于自己要做的事儿，其他的都先放一边。

这蛮力算法啊，说起来简单，但真要做起来，也得有点像我这样的憨劲儿才行。

蛮力算法：选择排序冒泡排序（详解）2015/10/26 1 蛮力法：蛮力法(brute force)是一种简单直接地解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。

虽然巧妙而高效的算法很少来自于蛮力法，但它还是具有重要地位。

因为它能解决几乎任何问题，如果要解决的问题的规模不大，或者对性能没有很高的要求，那么花大工夫涉及复杂的算法显然是不值得的。

下面就来介绍一下2大蛮力排序算法，然后是它们的分析。

 框架介绍：在介绍算法之前，有必要介绍一些以后会用到的方法。

使用前2个方法，我们就可以生成随机数组，然后方便地判断数列是否被正确排序了，以此验证排序算法的正确性。

第3个方法从标准输入中读取数据（通过重定向），进行大规模排序，以此比较不同算法的性能。

 /** * 生成一个长度为0~600的数组，每个元素的值为0~99999的整数。

* * @return */ public static Integer[] randomArray() { Integer[] r = new Integer[(int) (600 * Math.random())]; for (int i = 0; i r.length; i++) r[i] = (int) (99999 * Math.random()); return r; } /** * 返回一个数组是否是有序的。

* @param r * @return */ public static boolean isSorted(Integer[] r) { for (int i = 1; i r.length; i++) if (r[i]pareTo(r[i - 1]) 0) return false; return true; } /** * 从标准输入中读取1000000个整数的数组。

* @return */ public static Integer[] arrayIn(){ Scanner in = new Scanner(System.in); Integer[] r = new Integer[1000000]; for(int i=0;i 1000000;i++) r[i] = in.nextInt(); return r; }选择排序：选择排序开始的时候，我们扫描整个列表，找到它的最小元素，然后和第一个元素交换（如果第一个元素就是最小元素，那么它就和自己交换。

算法设计--蛮力法&&分治法求最近对问题（C++实现）最近对问题？设p1=(x1,y1), p2(x2,y2), ....,pn=(xn,yn)是平面上n个点构成的集合S，最近对问题就是找出集合S中距离最近的点对。

两种算法思想：1. 蛮力法：顾名思义，利用正常的思维，使用强硬的方式求解出结果。

2. 分治法：分治，分而治之，把大问题分解为小问题，主要有三个过程：划分、求解子问题、合并。

直接上代码：蛮力法求解最近对问题：[cpp]view plaincopy1.#include "iostream"2.#include "math.h"3.#include "time.h"4.#include "stdlib.h"ing namespace std;6.struct P7.{8.int x;9.int y;10.};11.double ClosePoints(int n,P a[],int &index1,int &index2)12.{13.double d;14.double Dist=10000;15.for (int i=0;i<n-1;i++)16. {17.for (int j=i+1;j<=n-1;j++)18. {19. d=(a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y);20.if(d<=Dist)21. {22. Dist=d;23. index1=i;24. index2=j;25. }26. }27. } return Dist;28.}29.void main (void)30.{31.clock_t start,end;32.int g;33.int s,e;34. P a[10000];35.for (int i=1;i<4;i++)36. {37. cout<<"输入坐标的个数（10000以内）";38. cin>>g;39. srand(time(NULL));40.for (int r=0;r<g;r++)41. {42. a[r].x=rand()%(g-123);43. a[r].y=rand()%(g-1234);44. }45. start=clock();46.double w=ClosePoints(g,a,s,e);47. end=clock();48. cout<<"最近的两个点是：P1("<<a[s].x<<","<<a[s].y<<") P2("<<a[e].x<<","<<a[e].y<<")"<<endl; cout<<"距离是："<<sqrt(w)<<endl;49. cout<<"蛮力法求最近对用时："<<(double)(end-start)/CLOCKS_PER_SEC<<"ms"<<endl;50. cout<<"============================================================="<<endl;51. }52.}分治法求解最近对问题：[cpp]view plaincopy1.#include<iostream>2.#include "cstdio"3.#include "cstring"4.#include "math.h"5.#include "time.h"6.#include "stdlib.h"7.#include "algorithm"ing namespace std;9.#define eps 1e-810.#define N 1000011.//定义一个保存坐标的结构体12.struct point13.{14.double x,y;15.};16.17.point node[N * 2];18.point d[N];19.point c[N];20.point b[N];21.int cmp(point a, point b) //比较两点之间的y值22.{23.return a.y < b.y;24.}25.int cmp1(point a, point b)26.{27.if(a.x != b.x)28.return a.x < b.x;29.return a.y < b.y;30.}31.double min(double a, double b) //求a和b两者较小值32.{33.return a > b? b:a;34.}35.36.double dx(double x1, double x2)37.{38.if((x1 - x2) > eps && (x1 - x2) < eps)39. {40.return 0;41. }42.else if(x1 > x2)43. {44.return x1 - x2;45. }46.else if(x1 < x2)47. {48.return x2 - x1;49. }50.}51.52.double ds(point a, point b) //求两点之间的距离53.{54.return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));55.}56./**57.* 最近对问题58.* 三种情况：59.* 1.在子集S1中60.* 2.在自己S2中61.* 3.最近的两个点分别在子集S1和S2中62.*/63.double closestPoints(point node[], int n)64.{65.int i, j;66.int Dist = 99999; //无穷大数67.if(n < 2) //只有一个点，不存在最近对68.return 0;69.int m = (n - 1) / 2; //m是各个坐标的中位数70.for(i = m + 1; i < n; i++)71. {72. b[i].x = node[i].x;73. b[i].y = node[i].y;74. }75.//划分为两个子问题，递归求解子问题76.double d1 = closestPoints(node, m + 1); //得到S1中的最近距离d177.double d2 = closestPoints(b, n - m - 1); //得到S2中的最近距离d278.double dm = min(d1, d2); //求得d1与d2两者之间较小值79.int f,p; //记录点的个数80. p = 0;81.for(i = 0; i <= m; i++) //找出S1中与x=m的距离小于dm的所有点，保存在结构体c当中82. {83.if(dx(node[i].x,node[m].x) < dm)84. {85. c[p].x = node[i].x;86. c[p].y = node[i].y;87. p++;88. }89. }90. f=0;91.for(i = m + 1; i < n; i++) //找出S2中与x=m的距离小于dm的所有点，保存在结构题d当中92. {93.if(dx(node[i].x, node[m].x) < dm)94. {95. d[f].x = node[i].x;96. d[f].y = node[i].y;97. f++;98. }99. }100.101. sort(c, c+p,cmp); //按照y轴的坐标值升序排列102. sort(d, d+f,cmp);103.double ret = Dist;104.for(i = 0; i < p; i++) //遍历比较分别在S1和S2中两点之间的距离105. {106.for(j = 0; j < f; j++)107. {108.double ans = ds(c[i], d[j]);109. ret = min(ret, ans); //得出最近对距离110. }111. }112.return min(ret, dm); //返回第三种情形与前两种情形较小值113.}114.int main(void)115.{116.int n,i;117.for(int w=0;w<6;w++)118. {119. cout<<"输入坐标的数目："<<endl;120. cin>>n;121. srand((unsigned)time(NULL));122.for(i=0;i<n;i++)123. {124. node[i].x=rand()/(double)(RAND_MAX/10000);125. node[i].y=rand()/(double)(RAND_MAX/10000);126. }127. sort(node,node+n,cmp);128.clock_t start,end;129. start=clock();130. closestPoints(node,n); //系统调用十次分治法函数。

实验三蛮力法排序（四号黑体）【一】实验目的（小四黑体）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]交换位置。

用蛮力学思想,用选择排序对一个数组进行排序实验总结一、什么是蛮力法蛮力法，又称枚举法，是基础的算法之一。

这是一种算法思想，顾名思义，就是将问题的可能结果全部都列举出来，再根据列举的结果根据问题的约束条件选择出问题的解。

所依赖的技术最主要的是遍历，重复步骤。

往往用这种算法去求解问题，时间复杂度会很大。

但是确是最简单，直白容易想到的解法。

思想还是得用实例来体现的，不然会感觉这个思想的东西只是思想，我们不会用的话，感觉这些思想没什么用，所以要用起来。

选择排序是蛮力法的一个例子，我们应该抓住的是如何将这种思想应用起来，这才是关键。

二、例子——选择排序1.问题选择排序方法对一个序列进行升序排y序2.基本思想听到选择排序，顾名思义，这是一种有选择的排序方法。

怎么选择，如何体现蛮力？选择，就是将序列分为有序跟无序，这两部分，刚开始，有序部分的元素肯定为空集。

接下来，就是所谓的蛮力的部分，开始不管三七二十一，就在无序的部分开始找啊，找到在无序中最小的数，将把最小的数与无序序列的第一个元素交换。

到这一步后，又开始划有序与无序部分，这个时候，要把刚才找的最小的数放到有序部分中。

这时，有序部分的元素就加1了，所谓排好一个了，还有剩下的元素在无序序列中。

再开始蛮力部分。

一直这样更新有序无序序列，蛮力；更新有序序列，蛮力。

直至无序序列中没有元素。

这样我们就实现了排序。

大概想法是这样的，现在开始扣细节。

因为这只是我们想法，计算机认识吗？当然不认识。

我们要把我们的思想改得细致点。

好了，我们知道蛮力法最重要的是遍历和重复步骤。

我们要对整个序列进行排序，根据刚才的思想，序列中的每一个元素都会被挑出来重新放到有序序列中，所以，在这里可以用一个遍历去实现。

然而，对于每一个的挑选的过程，是很蛮力的，就是一直在无序序列中找，比较。

直至到无序序列的结尾。

所以这也可以用遍历去实现。

所以整体框架就是重复（次数为原始序列个数，为更新有序与无序序列）开始找最小的值在无序序列中找到最小值交换值在无序序列中的位置3.代码实现void SelectSort(int array[],int n){int i,j,index,temp;for(i=0;i<n-1;i++) //最外层遍历{index=i;//无序区的第一位for(j=i+1;j<n;j++) //开始找无序区的最小元素if(array[j]<array[index] index=j; //记录最小值if(index!=i){temp=array[i];array[i]=array[index];array[index]=temp; //将最小值放到有序区中总结对于蛮力法的应用，首先要明白它的特征，就是遍历，重复步骤的过程。

蛮力算法报告1什么是蛮力算法蛮力算法是一种简单直接地解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。

蛮力策略也常常是最容易应用的方法。

a n=a×a×…×a n个a相乘。

根据指数的定义，a n的值。

它意味着，我们可以简单的把1和a相乘n次，来得到这就是利用蛮力思想解决问题的一个简单例子。

2蛮力算法是一种重要的算法设计策略第一，和其他某些策略不同，我们可以应用蛮力法来解决广阔领域的各种问题（实际上，它可能是唯一一种几乎什么问题都能解决的一般性方法）。

第二，对于一些重要的问题来说（比如，排序、查找、矩阵乘法和字符串匹配），蛮力法可以产生一些合理的算法，它们多少具备一些实用价值，而且并不必限制实例的规模。

第三，如果要解决的问题实例不多，而且蛮力法可以用一种能够接受的速度对实例求解，那么，设计一个更高效算法所花费的代价很可能是不值得的。

第四，即使效率通常很低，仍然可以用蛮力算法解决一些小规模的问题实例。

第五，一个蛮力算法可以为研究或教学目的服务，例如，可以以之为准绳，来衡量同样问题的更高效算法。

3蛮力算法的优点1，蛮力算法具有广泛的适用性和简单性2，蛮力算法的第一个应用就是得出一个算法，此算法可以通过适度的努力来提升它的性能3，理论上，蛮力法可以解决计算领域的各种问题4，对于一些重要的问题蛮力法可以产生一些合理的算法，它们具备一些实用价值，而且不受问题规模的限制5，蛮力法可以作为某类问题时间性能的底线，来衡量同样问题的更高效算法4可以利用蛮力法解决的简单问题1.选择排序选择排序开始的时候，扫描整个列表，找到它的最小元素然后和第一个元素交换，将最小元素放到它在有序表中的最终位置上。

然后从第二个元素开始扫描列表，找到最后n-1个元素中的最小元素，在和第二个元素交换位置，把第二小元素放在它的最终位置上。

以此类推，在n-1遍以后，该列表就被排好序了。

2.冒泡排序比较表中的相邻元素，如果它们是逆序的话就交换它们的位置。