基本算法思想

最新推荐文章于 2021-02-27 08:14:48 发布

RED-GO

最新推荐文章于 2021-02-27 08:14:48 发布

阅读量656

点赞数 1

分类专栏： --------【算法】文章标签：算法

本文链接：https://blog.csdn.net/u010137431/article/details/46841875

版权

--------【算法】专栏收录该内容

2 篇文章 0 订阅

订阅专栏

常用算法思想概述

在实际应用中，不同的问题往往解题的思路不同。如果找不到一个合适的思路，那么可能使求解决过程变得复杂，更有甚者无法求解得到结果。选择合理的思路，往往可以帮助用户理清问题的头绪，更快地解决问题。算法就是起到了这个作用。
根据问题的不同，我们可以采用如下几种常用的算法来进行求解。

穷举算法思想
递推算法思想
递归算法思想
分治算法思想
概率算法思想

穷举算法思想

穷举算法（Exhaustive Attack method）是最简单的一种算法，其依赖于计算机的强大计算能力，来穷尽每一种可能的情况，从而达到求解问题的目的。穷举算法效率并不高，但是适合于一些没有明显规律可循的场合。

基本思想

穷举算法的基本思想就是从所有可能的情况中搜索正确的答案，其执行步骤如下：
（1）对于一种可能的情况，计算其结果。
（2）判断结果是否满足要求，如果不满足则继续执行（1）步来搜索下一个可能的情况；如果满足要求，则表示寻找到一个正确的答案。
在使用穷举算法时，需要明确问题的答案的范围，这样才可以在指定范围内搜索答案，指定范围之后，就可以使用循环语句和条件判断语句逐步验证候选答案的正确性，从而得到需要的正确答案。

实例

今有鸡兔同笼，上有三十五头，下有九十四足，问鸡兔各几何？
这个问题的大致意思是：在一个笼子关着若干只鸡和若干只兔，从上面数共有35个头，从下面数共有94只脚，问笼中鸡和兔的数量各是多少？

java

public static void main(String[] args) {

        int head, foot;
        Scanner sc = new Scanner(System.in);
        System.out.println("穷举法求解鸡兔同笼问题");
        System.out.print("请输入头数： ");
        head = sc.nextInt();
        System.out.print("请输入脚数： ");
        foot = sc.nextInt();
        qiongju(head, foot);
    }

    private static void qiongju(int head, int foot) {
        int haveResult = 0;
        int chick, habbit = 0;
        for(chick = 0; chick <= head; chick++){
            habbit = head - chick; //鸭数目
            if(chick * 2 + habbit * 4 == foot){
                haveResult = 1; //判断，确定是否有答案
                break;
            }
        }
        if(haveResult == 1)
            System.out.println("鸡有" + chick + "只， 兔有" + habbit + "只");
        else
            System.out.println("无法求解！");
    }

运行结果

穷举法求解鸡兔同笼问题
请输入头数： 35
请输入脚数： 94
鸡有23只， 兔有12只

递推算法思想

递推算法是很常用的算法思想，在数学计算等场合有着广泛的应用，递推算法适合有着明显公式规律的场合。

递推算法基本思想

递推算法是一种理性思维模式的代表，其根据已有的数据和关系，逐步推导而得到结果。递推算法的执行过程如下：
（1）根据已知结果和关系，求解中间结果。
（2）判定是否达到要求，如果没有达到，则继续根据已知结果和关系求解中间结果；如果满足要求，则表示寻找到一个正确的答案。
递推算法往往需要用户知道答案和问题之间的逻辑关系。在许多数学问题中，都有着明确的计算公式可以遵循，因此往往可以采用递推算法来实现。

实例

数学里面的斐波那契数列便是一个使用递推算法的经典例子。13世纪意大利数学家斐波那契的《算盘书》中记载了典型的兔子产仔问题，其大意如下：
如果一对两个月大的兔子以后每一个月都可以生一对小兔子，而一对新生的兔子出生两个月后才可以生小兔子。也就是说，1月份出生，3月份才可产仔。那么假定一年内没有产生兔子死亡事件，那么1年后共有多少对兔子呢？

分析，我们来逐月看一次每月的兔子对数：
第一个月：1对兔子；
第二个月：1对兔子；
第三个月：2对兔子；
第四个月：3对兔子；
第五个月：5对兔子；
……
从上面可以看出，从第3个月开始，每个月的兔子总对数等于前两个月兔子数的总和。相应的计算公式如下：第n个月兔子总数Fn=Fn-2 + Fn-1

java

public static void main(String[] args) {
        int month, num; //月份数
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入繁殖时间（月）：");
        month = sc.nextInt();
        num = Fabonacci(month); //斐波那契，求解
        System.out.printf("经过%d月的时间，共能繁殖成%d对兔子", month, num);
    }

    private static int Fabonacci(int month) { //递归调用 
        int t1, t2;
        if(month == 1 || month ==2) return 1;
        else{
            t1 = Fabonacci(month - 2);
            t2 = Fabonacci(month - 1);
            return t1 + t2;
        }
    }

运行结果：

请输入繁殖时间（月）：12
经过12月的时间，共能繁殖成144对兔子

递归算法思想

递归算法是很常用的算法思想，使用递归算法，往往可以简化代码编写，提高程序的可读性，但是，有的不合适的递归往往导致程序的执行效率变低。

递归算法基本思想

递归算法就是在程序中不断反复调用自身来达到求解问题的方法。这里的重点是调用自身，这就要求待求解的问题能够分解为相同问题的一个子问题。这样，通过多次递归调用，便可以完成求解。
递归调用是一个方法在其方法体内调用其自身的方法调用方式。这种方法也称为“递归方法”。在递归方法中，主调方法又是被调方法。执行递归方法将反复调用其自身。每调用一次就进入新的一层。
方法的递归调用分两种情况：直接递归和间接递归。

直接递归，即在方法中调用方法本身。
间接递归，即间接地调用一个方法，如func_a调用func_b，func_b调用func_a，间接递归用得不多。
编写递归方法时，必须使用if语句强制方法在未执行递归调用前返回。如果不这样做，在调用方法后，它将永远不会返回，这是一个很容易犯的错误。

实例

求n的阶乘：n! = n * (n-1) * (n-2) * ……* 2 * 1

java

public static void main(String[] args) {
        int n;
        long result; 
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入要求阶乘的一个整数：");
        n = sc.nextInt();
        result = Fact(n); //阶乘方法，求解
        System.out.printf("%d的阶乘结果为%s", n, result);
    }

    private static long Fact(int n) {
        if( n <= 1) return 1;
        else return n * Fact(n-1);
    }

分治算法思想

分治算法是一种化繁为简的算法思想。分治算法往往应用于计算步骤比较复杂的问题，通过将问题简化而逐步得到结果。

分治算法基本思想

分治算法的基本思想是将一个计算复杂的问题分为规模较小，计算简单的小问题求解，然后综合各个小问题，而得到最终问题的答案，分治算法的执行过程如下：
（1）对于一个规模为N的问题，若该问题可以容易地解决（比如说规模N较小），则直接解决；否则执行下面的步骤。
（2）将该分解为M个规模较小的子问题，这些子问题互相独立，并且与原问题形式相同。
（3）递归地解这些子问题
（4）然后，将各子问题的解合并得到原问题的解。

实例

通过一个例子来看分治算法的应用。一个袋子里有30个硬币，其中一枚是假币，并且假币和真币一模一样，肉眼很难分辨，目前只知道假币比真币重量轻一点，请问如何区分出假币呢？
1. 分治算法
我们先来分析一下寻找假币问题，可以采用递归分治的思想来求解这个问题，操作步骤如下：
（1）首先为每个银币编号，然后可以将所有的银币等分为两份，放在天平的两边。这样就将区分30个硬币的问题，变为区别两堆硬币的问题。
（2）因为假银币的分量较轻，因此天平较轻的一侧中一定包含假银币。
（3）再将较轻的一侧中的硬银币等分为两份，重复上述的做法。
（4）直到剩下两枚硬银币，可用天平直接找出假币来。

java

public static void main(String[] args) {
        final int MAXNUM = 30; //银币总数
        int[] coin = new int[MAXNUM]; //银币数组
        initialization(coin); //数组初始化，设置其中一枚为假的
        int index = FalseCoin(coin, 0, coin.length - 1); //分治求解
        System.out.printf("在%d枚银币中，第%d枚是假的", coin.length, index);
    }

    //分治求解
    private static int FalseCoin(int[] coin, int low, int high) {
        int sum1, sum2;//sum1是前半段和，sum2是后半段和
        int index; //假币位置
        sum1 = sum2 = 0;
        if(low + 1 == high) //剩两枚
        {
            if(coin[low] < coin[high]) return low + 1;
            else return high + 1;
        }
        if((high - low + 1) % 2 == 0){ //剩偶数枚银币

            for(int k = low; k <= low + (high - low)/2; k++) //前半段和
                sum1 = sum1 + coin[k];
            for(int k = low + (high - low)/2 + 1; k <= high; k++) //后半段和
                sum2 = sum2 + coin[k];
            if(sum1 > sum2) return FalseCoin(coin, low + (high - low)/2 + 1, high);
            else return FalseCoin(coin, low, low + (high - low)/2);

        }else{  //剩奇数枚银币

            for(int k = low; k <= low + (high - low)/2 - 1; k++) //前半段和
                sum1 = sum1 + coin[k];
            for(int k = low + (high - low)/2 + 1; k <= high; k++) //后半段和
                sum2 = sum2 + coin[k];
            if(sum1 > sum2) return FalseCoin(coin, low + (high - low)/2 + 1, high);
            else{
                if(sum2 > sum1)
                    return FalseCoin(coin, low, low + (high - low)/2 - 1);
                else
                    return low + (high - low)/2 + 1;
            }
        }
    }

    //数组初始化，设置其中一枚为假的
    private static void initialization(int[] coin) {
        for(int i = 0; i < coin.length; i++)
            coin[i] = 2;
        int index = (int)(Math.random() * (coin.length));
        coin[index] = 1;
    }

运行结果

在30枚银币中，第2枚是假的

概率算法思想

概率算法依照概率统计的思路来求解问题，其往往不能得到问题的精确解，但是在数值计算领域得到了广泛的应用。因为很多数学问题，往往没有或者很难计算，这时候便需要通过数值计算来求解近似值。

概率算法基本思想

概率算法执行的基本过程如下：
（1）将问题转化为相应的几何图形S，S的面积是容易计算的，问题的结果往往对应几何图形中某一部分S1的面积。
（2）然后，向几何图形中随机撒点。
（3）统计几何图形S中和S1中的点数。根据S的面积和S1面积的关系以及各图形中的点数来计算得到结果。
（4）判断上述结果是否在需要的精度之内，如果未达到精度则进行执行步骤（2），如果达到精度，则输出近似结果。

概率算法大致分为如下4种形式

数值概率算法
蒙特卡罗（Monte Carlo）算法
拉斯维加斯（Las Vegas）算法
舍伍德（Sherwood）算法

实例

通过一个实例来看看蒙特卡罗（Monte Carlo）概率算法的应用。蒙特卡罗算法的一个典型应用便是计算圆周率z。

java

public static void main(String[] args) {
        System.out.println("蒙特卡罗概率算法计算∏");
        Scanner sc = new Scanner(System.in);
        System.out.print("输入点的数量：");
        int num = sc.nextInt();  //输入撒点个数
        double PI = MontePI(num); //计算PI
        System.out.println("PI=" + PI);
    }

    private static double MontePI(int num) {
        double x, y;
        int sum = 0;
        for(int i = 0; i < num; i++){
            x = Math.random(); //产生0~1之间的一个随机数
            y = Math.random(); //产生0~1之间的一个随机数
            if((x * x + y * y) <= 1) //计数，落在阴影中的点数
                sum ++; 
        }
        return (double)(4 * sum) / num;
    }

运行结果

蒙特卡罗概率算法计算∏
输入点的数量：50000000
PI=3.1418696