算法设计与分析—蛮力法

蛮力法

蛮力法概述

蛮力法也称穷举法(枚举法)或暴力法，是一种简单的直接解决问题的方法，通常根据问题的描述和所涉及的概念定义，对问题所有可能的状态(结果)一一进行测试，直到找到解或将全部可能的状态都测试一遍为止。

蛮力法的“力”指的是计算机的运算能力，蛮力法是基于计算机运算速度快的特性，减少人的思考而把工作都交给计算机的“懒惰”策略(这里的懒惰指的是人懒，不是算法中的懒惰方法)，一般而言是最容易实现的方法。

蛮力法的优点如下：

1.逻辑简单清晰，根据逻辑编写的程序简单清晰。

2.对于一些需要高正确性的重要问题，它产生的算法一般而言是复杂度高但合理的。

3.解决问题的领域广。

4.适用于一些规模较小，时间复杂度要求不高的问题。

5.可以作为其他高校算法的衡量标准，即作为被比较的例子。

主要缺点就是因为缺少人的思考，算法往往设计的简单而缺乏高的效率。

蛮力法依赖的是将每个元素(状态)处理一次的扫描技术，通常在以下几种情况使用蛮力法：

搜索所有的解空间：问题的解存在于规模不大的解空间中。

搜索所有的路径：这类问题中不同的路径对应不同的解。

查找问题中的蛮力法——顺序查找

【问题】在集合中依次查找值为k的元素，若有给出该元素在集合中的位置；若查找失败，则给出失败信息。

【想法1】从数组的一端到另一端逐个比较

【算法实现1】

int SeqSearch1(int r[],int n ,int k) {
    int i = n;
    while(i>0&&r[i]!=k)
    i--;
    return i ;
}

【算法分析1】该算法时间主要耗费在条件表达式中 i>0&&r[i]!=k 执行次数为O(n)

【改进】可以在一段的尽头加一个k值，充当”哨兵“，这样每次循环时候就不需要判断是否越界

【算法实现2】

int SeqSearch2(int r[],int n ,int k) {
    r[0]=k;
    int i = n;
    while(r[i]!=k)
    i--;
    return i ;
}

串匹配问题中的蛮力法

字符串匹配

对于字符串s和t，若t是s子串，返回t在s中的位置(t的首字符在s中对应的下标)，否则返回-1。

蛮力法的策略就是找到字符串s中所有长度为t的字符串的长度的连续子串，然后将连续子串与t进行比较，判断t是否为s的子串，这个字符串匹配的算法称为BF算法(Brute-Force算法)也就是暴力算法的意思。

【算法1】设字符数组S存放主串，字符数组T存放模式，BF算法如下

输入：主串S，模式T
输出：T在S中的位置
初始化主串比较开始的位置 index= 0；
在串S和串T中设置比较的起始下标i=0，j=0；
重复下述操作，直到S或T的所有字符均比较完毕；
  3.1如果S[i]=T[i],则继续比较下一对字符
  3.2否则，下一趟匹配的开始位置为index++，回溯下标 i= index，j=0；
4.如果T中所有字符均比较完毕，则返回开始的位置的序号，否则返回0

int BF(char S[],char T[]) {
    int i=0,j=0,index = 0;
    while(S[i]!='\0'&&T[j]!='\0') {
        if(S[i]==T[j]) {i++,j++}
        else{index++;i=index;j=0;}
    }
    if(T[j]=='\0') return index+1;
    else return 0;
}

排序问题中的蛮力法

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序中的数据元素选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

void SelectSort(int r[],int n)
{
    int i,j,index,temp;=
    for(i=0;i<n-1;i++) {         //进行n-1趟排序
        for(j=i+1;j<n;j++) {
            if(r[j]<r[index])  indxex=j;
            
        }temp = r[i]; r[i]=r[index];r[index]=temp;
    }
}

执行次数为O（n的二次方）

气泡排序（冒泡排序）

 ①、 比较相邻的元素 : 如果第一个元素比第二个元素大，那么就交换他们两个。

②、从 第一对相邻的元素 开始比较 直到 最后一对，这样在最后的元素应该会是最大的数。

③、 针对所有的元素（除了最后一个）重复以上的步骤。

重复步骤 1~3 ，直到没有任何一对数字需要比较。

template<class T>
void BubbleSort(T arr[], int n) {
    bool exchange;                        //标识本次是否发生交换
    for (int i = 1; i < n; i++) {        //共进行n - 1趟排序：从1到n-1,逐步缩小待排序列
        exchange = false;           //每趟起泡之前将exchange赋值false
        for (int j = n - 1; j >= i; j--) {  //反向检测，检查是否逆序
            if(arr[j] > arr[j - 1]){        //发生逆序，交换元素的位置
                T temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                exchange = true;    //本趟发生了交换
            }
        }
        if (exchange = false)
            return;                   //本次无逆序，停止处理             
    }
}

图问题中的蛮力法

哈密顿回路问题

问题描述：哈密顿图是一个无向图，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。从一张普通图的任意一点出发，路途中经过图中每一个结点当且仅当一次，则成为哈密顿回路。

哈密顿回路条件约束：

1.加入路径的节点与前一个加入路径的顶点一定是连通的；

2.加入路径的最后一个顶点和第一个顶点一定是连通的；

3.路径上不能出现重复的顶点。

伪代码：
算法：哈密顿回路
输入：无向图G=（V,E）
输出:如果存在哈密顿回路，则输出该回路，否则，输出无解信息
对顶点集合{1，2，.....，n}的每一个全排列vi1，vi2...执行下述操作
    1.1循环变量j从1到n-1重复执行下述操作. 
        1.1.1如果顶点vij和Vij+1之间不存在边，则转步骤1考察下一个全排列；
        1.1.2否则j++
    1.2如果Vin和Vi1之间存在边，则输出全排列，算法结束；
输出无解信息
最坏的情况下需要考虑所有顶点的全排列 时间复杂度为O（n！）

0/1背包问题

问题描述：有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？

背包问题的蛮力解法是穷举这些物品的所有子集，找出能够装到背包中的所有子集，并在这些子集中找出价值最大的子集。

输入：重量{w1,w2,···,wn}，价值{v1,v2,···,vn}，容量C
输出：装入背包的物品编号

1. 初始化最大价值maxValue=0；结果子集S=∅；
2. 对集合{1,2,···,n}的每一个子集T，执行如下操作：
2.1 初始化背包的价值value=0；背包的重量weight=0；
2.2 对子集T的每一个元素j
2.2.1 如果weight+wj＜C，则weight=weight+wj；value=value+vj；
2.2.2 否则，转入步骤2考察下一个子集；
2.3 如果maxValue＜value，则maxValue=value；S=T；
3.输出S中的各元素；

#include<iostream>
#include<cstdio>
#include<cstdlib>
//用于计算程序运算时间
#include<ctime>

using namespace std;

#define N 100

struct goods{
int sign;//物品序号
int wight;//物品重量
int value;//物品价值
};

int n, maxValue, cv, cw, C;//物品数量，价值最大，当前价值，当前重量，背包容量
int X[N],cx[N];//最终存储状态，当前存储状态
struct goods goods[N];

int Force(int i)
{
    if(i > n-1)
    {
        if(maxValue < cv && cw + goods[i].wight <= C)
        {
            for(int k = 0;k < n;k++)
                X[k] = cx[k];//存储最优路径
            maxValue = cv;
        }

        return maxValue;
    }

    cw = cw + goods[i].wight;
    cv = cv + goods[i].value;
    cx[i] = 1;//装入背包

    Force(i+1);
    cw = cw-goods[i].wight;
    cv = cv-goods[i].value;
    cx[i] = 0;//不装入背包

    Force(i+1);

    return maxValue;
}

int main()
{
    clock_t starttime,finish; //用于计算时间
    double time;
    starttime=clock();//用于计算程序运行时间

    printf("物品种类n：");
    scanf("%d",&n);
    printf("背包容量C：");
    scanf("%d",&C);

    for(int i = 0; i < n; i++)
    {
        printf("物品%d的重量w[%d]及其价值v[%d]：",i+1,i+1,i+1);
        scanf("%d%d",&goods[i].wight,&goods[i].value);
    }

    int sum1 = Force(0);

    printf("蛮力法求解0/1背包问题：\nX=[");

    for(int i = 0; i < n; i++)
    {
        cout << X[i]<<" ";
    }

    printf("] 装入总价值%d\n",sum1);

    finish=clock();
    time = (double)(finish-starttime)/1000;//时间单位为秒
    starttime=clock();//用于计算程序运行时间

    cout<<"time is:"<<time<<endl;

    return 0;
}