常用基本算法思想

1.穷举算法思想（Exhaustive Attack method）

	穷举算法的基本的思想就是从所有可能的情况中搜索正确的答案。其执行流程：
	（1）对于一种可能的情况，计算其结果；
	（2）判断结果是否满足要求，如果不满足则执行（1）步来搜索下一个可能的情况；如果满足要求，则表示寻找到一个正确的答案。
	PS:需要明确问题答案的范围。

示例：鸡兔同笼—>狗鸭同居 ^ -^ 哈哈
今有狗鸭同居，上有三十五头，下有九十四足，问狗鸭个几何？

#include <iostream>

using namespace std;

int exhaustion(int head,int foot,int *duck,int *dog)     //穷举算法
{
    int flag = 0;
    for (int i=0;i<=head;i++)
    {
        int j;
        j = head-i;
        if(i*2+j*4==foot)
        {
            flag =1;
            *duck = i;
            *dog = j;
        }

    }
    return flag;

}

int main()
{
    int duck,dog,head,foot,flag;

    cout << "穷举法求解鸭狗同居问题：" << endl;
    cout<<"输入头数："<<endl;
    cin>>head;
    cout<<"输入脚数："<<endl;
    cin>>foot;

    flag = exhaustion(head,foot,&duck,&dog);
    if(flag==1)
    {
        cout<<"鸭子有:"<<duck<<"只"<<endl;
        cout<<"狗狗有:"<<dog<<"只"<<endl;

    }
    else
    {
        cout<<"无解"<<endl;
    }
     system("pause");
    return 0;
}

2.递推算法思想

	递推算法是一种理性思维模式的代表，根据已有数据和关系，逐步推导而的得到结果。其执行流程：
	（1）根据已知结果和关系，求解中间结果；
	（2）判断是否达到要求，如果没有达到，则根据已知结果和关系求解中间结果。如果满足要求，则表示寻找到一个正确答案。
	PS：需要知道答案和问题之间的逻辑关系。

示例：斐波那契数列

#include<iostream>

using namespace std;

int Fibonacci(int n)
{
    int t1,t2;

    if(n==1||n==2)
    {
        return 1;
    }
    else
    {
        t1=Fibonacci(n-1);
        t2=Fibonacci(n-2);
        return t1+t2;
    }
}


int main()
{
    int n,num;

    cout<<"递推算法求解兔子产仔问题！"<<endl;
    cout<<"请输入时间："<<endl;
    cin>>n;
    num = Fibonacci(n);
    cout<<"经过"<<n<<"月的时间，共能繁殖"<<num<<"对兔子"<<endl;

}

3.递归算法思想

	递归算法就是在程序中不断反复调用自身来达到解决问题的方法。
    PS：编写递归函数时，必须使用if语句强制函数在末执行递归调用前返回，否则，在调用函数后，它将永远不会返回。

函数的递归调用可分为：@直接递归：即在函数中调用函数本身；@间接递归：即间接的调用一个函数，如func_a调用func_b,func_b又调用func_a。

示例：阶乘，汉诺塔

#include<iostream>

using namespace std;

long fact(int n);

int main()
{
    int i;
    cout<<"请输入一个数，求阶乘结果"<<endl;
    cin>>i;
    cout<<i<<"的阶乘为"<<fact(i)<<endl;

}

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

4.分治算法思想

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

示例：递归分治求解寻找假币

#include<iostream>

using namespace std;

#define MAXNUM 30

int FakeCoin(int coin[],int low,int high)   //coin为银币重量数组，low为寻找的起始银币编号，high为寻找的结束银币编号
{
    int i,sum1=0,sum2 =0,sum3=0;
    int flag;

    if(low+1 ==high)
    {
        if(coin[low]<coin[high])
        {
            flag = low +1;
            return flag;

        }
        else
        {
            flag = high +1;
            return flag;
        }
    }

    if((high-low+1)%2==0)
    {
        for (i=low;i<=low+(high-low)/2;i++)
        {
            sum1 =sum1 + coin[i];
        }
        for (i=low+(high-low)/2+1;i<=high;i++)
        {
              sum2 = sum2 +coin[i];
        }
        if(sum1>sum2)
        {
            flag = FakeCoin(coin,low+(high-low)/2+1,high);
            return flag;
        }else if (sum1<sum2)
        {
                flag = FakeCoin(coin,low,low+(high-low)/2);
                return flag;
        }else
        {

        }

    }
    else
    {
        for (i=low;i<=low+(high-low)/2-1;i++)
        {
            sum1 =sum1+coin[i];

        }
        for (i=low+(high-low)/2+1;i<=high;i++)
        {
             sum2 = sum2 +coin[i];

        }
        sum3 = coin[low+(high-low)/2];
        if(sum1>sum2)
        {
            flag =FakeCoin(coin,low+(high-low)/2+1,high);
            return flag;

        }
        else if (sum1<sum2)
        {
             flag =FakeCoin(coin,low,low+(high-low)/2);
             return flag;

        }
        else {

        }
        if(sum1+sum3==sum2+sum3)
        {
            flag = low+(high-low)/2+1;
            return flag;
        }
    }
}


int main()
{
    int coin[MAXNUM];
    int n;
    int position;

    cout<<"分治算法求解假银币问题！"<<endl;
    cout<<"请输入银币的总个数："<<endl;
    cin>>n;
    cout<<"请输入银币的真假："<<endl;
    for (int i=0;i<n;i++)
    {
        cin>>coin[i];

    }
    position =FakeCoin(coin,0,n-1);
    cout<<"在上述"<<n<<"个银币中，第"<<position<<"个是假币"<<endl;



}

5.概率算法思想

	概率算法是依照概率统计的思路来求解问题的算法，它往往不能得到问题的精确解，但却在数值计算领域的到广泛运用。其执行过程如下：
	（1）将问题转化为相应的几何图形S,S的面积是容易计算的，问题的结果往往对应几何图形中某一部分S1的面积；
	（2）向几何图形中随机撒点；
	（3）统计几何图形S和S1中的点数。根据S面积和S1面积的关系以及个图形中的点数来计算得到结果；
	（4）判断上述结果是否在需要的精度之内，如果未达到精度则执行步骤（2）。如果达到精度，则输出近似结果。

概率算法大致分为四种：

1. 数值概率算法
2. 蒙特卡洛算法（Monto Carlo）
3. 拉斯维加斯算法（Las Vegas）
4. 舍伍德算法（Sherwood）

示例：蒙塔卡罗算法 计算圆周率π

#include <iostream>
#include<stdlib.h>
#include<time.h>


using namespace std;



double MontePI(int n)
{
    double PI;
    double x,y;


    int sum = 0;
    srand(time(NULL));
    for (int i=1;i<n;i++)
    {
        x = (double)rand()/RAND_MAX;
        y = (double)rand()/RAND_MAX;
        if((x*x+y*y)<=1) sum++;
     }

    PI = 4.0*sum/n;
    return PI;
}



int main()
{

    cout<<"蒙塔卡罗概率算法计算Π："<<endl;
    cout<<"输入点的数量："<<endl;
    int n;
    cin>>n;
    double PI;

    clock_t start, finish;     //测量程序消耗时间
    double  duration;
    start = clock();


    PI = MontePI(n);
    cout<<"Π的计算结果:"<<PI<<endl;


    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    cout<<"本次计算结果消耗时间:"<<duration<<"s"<<endl;

    system("pause");
    return 0;
}