《趣学算法》，陈小玉

觉得还是先从简单例子程序着手，先了解各个算法的基本思想。

目录：

1. 贪心算法
2. 分治法
3. 动态规划
4. 回溯法
5. 分支限界法
6. 线性规划网络流

算法是指对特定问题求解步骤 的一种描述

算法的评价标准：时间复杂度与空间复杂度。

时间复杂度：考虑给定的数据数目n，关于算法的执行次数。渐进上界用O()表示，最坏情况对衡量算法的好坏具有实际的意义。

空间复杂度：算法占用的空间大小。一般将算法的辅助空间作为衡量标准。

1.贪心算法

算法思想：一个贪心算法总是做出当前最好的选择，也就是说，它期望通过局部最优选择从而得到全局最优的解决方案。

小插曲：c++中有排序函数sort，可以直接利用

#include<iostream>
using namespace std;
#include<algorithm>

int main()
{
    int a[4] = { 4,7,3,5 };
    for (int i = 0; i < 4; i++)
        cout << a[i] << " ";
    cout << endl << "排序后::::" << endl;
    sort(a, a + 3);          //可以只对某几项进行排列
    for (int i = 0; i < 4; i++)
        cout << a[i] << " ";


    cin.ignore();
    return 0;
}

4 7 3 5
排序后::::
3 4 7 5

举列1：最优装载问题

描述：海盗们截获一批财宝，海盗船载重有限，如何尽可能多的获取宝贝？？

算法设计：每次选择重量最小的，直到不能再装为止。

代码：

#include<iostream>
using namespace std;
#include<algorithm>

const int N = 100;
double w[N];   //古董 的重量数组

int main()
{
    double c;
    int n;
    cout << "请输入载重量c以及古董个数n:" << endl;
    cin >> c >> n;

    cout << "请输入每个古董的重量" << endl;

    for (int i = 0; i < n; i++)
    {
        cin >> w[i];
    }
    sort(w, w + n);

    double temp = 0;
    int ans = 0;

    for (int i = 0; i < n; i++)
    {
        temp += w[i];
        if (temp <= c)
            ans++;
        else
            break;
    }
    cout << "最大装载数目：" << ans << endl;

    cin.ignore();
    cin.ignore();
    cin.ignore();
    return 0;
}

请输入载重量c以及古董个数n:
30 8
请输入每个古董的重量
4 10 7 11 3 5 14 2
最大装载数目：5

 扩展：如何知道装入了那些宝贝呢？？

引入结构体数组，增加宝贝的编号属性，具体程序如下

#include<iostream>
using namespace std;
#include<algorithm>

const int N = 100;
struct two {
    int n;    //宝物标号
    double w;  //宝物重量
}s[N];
//double w[N];   //古董 的重量数组
bool cmp(two a, two b)
{
    return a.w < b.w;
}

int main()
{
    double c;
    int n;
    cout << "请输入载重量c以及古董个数n:" << endl;
    cin >> c >> n;

    cout << "请输入每个古董的重量" << endl;
    
    for (int i = 0; i < n; i++)
    {
        cin >> s[i].w;
        s[i].n = i + 1;
    }
    sort(s, s + n, cmp);

    double temp = 0;
    int ans = 0;

    for (int i = 0; i < n; i++)
    {
        temp += s[i].w;
        if (temp <= c)
        {
            ans++;
            cout << "选择第" << s[i].n << "个宝贝" << endl;
        }
        else
            break;
    }
    cout << "最大装载数目：" << ans << endl;
    

    cin.ignore();
    cin.ignore();
    cin.ignore();
    return 0;
}

请输入载重量c以及古董个数n:
30 8
请输入每个古董的重量
4 10 7 11 3 5 14 2
选择第8个宝贝
选择第5个宝贝
选择第1个宝贝
选择第6个宝贝
选择第3个宝贝
最大装载数目：5

2.分治法

算法思想：本质是将一个大规模的问题分解为若干个规模较小 的相同子问题，分而治之

               在分治算法中，各个子问题形式相同，解决的方法也一样，因此可以使用递归算法快速解决，递归是彰显分治法优势的利器

举列1：猜数游戏

描述：n个数，给定一个数x，从中找出特定的元素x

算法设计：每次从中间元素开始 查找，与x进行比较，这样每次就可以将问题的规模减半，直到查到x

code:

#include<iostream>

#include<algorithm>
using namespace std;

const int M = 10000;
int s[M];

int  BinarySearch(int n, int s[], int x)
{
    int low = 0, high = n - 1;
    while (low <= high)
    {
        int middle = (low + high) / 2;
        if (x == s[middle])
            return middle;
        else if (x < s[middle])
            high = middle - 1;
        else
            low = middle + 1;
    }
    return -1;
}

int main()
{
    int n,x,i;

    cout << "请输入数列中的元素个数n为： ";
    while (cin >> n)
    {
        cout << "请依次输入：";
        for (int i = 0; i < n; i++)
            cin >> s[i];
        sort(s, s + n);
        cout << "排序后的数组为：";
        for (int i = 0; i < n; i++)
            cout << s[i]<<" ";
        cout << endl;
        cout << "输入要查找的元素：";
        cin >> x;
        i = BinarySearch(n, s, x);
        if (i == -1)
            cout << "no found";
        else
            cout << "the element found is" << i + 1 << "位" << endl;

        
    }
    
    cin.ignore();
    return 0;
}

请输入数列中的元素个数n为： 11
请依次输入：2 6 3 7 99 33 45 82 14 32 5
排序后的数组为：2 3 5 6 7 14 32 33 45 82 99
输入要查找的元素：3
the element found is2位

 扩展：使用递归算法实现：

#include<iostream>

#include<algorithm>
using namespace std;

const int M = 10000;
int s[M];

int  BinarySearch(int s[], int x, int low, int high)
{
        
        if (low>high)
            return -1;
        int middle = (low + high) / 2;
        if (x == s[middle])
            return middle;
        else if (x < s[middle])
            return BinarySearch(s, x, low, middle - 1);
        else
            return BinarySearch(s, x, middle + 1, high);
}

int main()
{
    int n,x,i;

    cout << "请输入数列中的元素个数n为： ";
    while (cin >> n)
    {
        cout << "请依次输入：";
        for (int i = 0; i < n; i++)
            cin >> s[i];
        sort(s, s + n);
        cout << "排序后的数组为：";
        for (int i = 0; i < n; i++)
            cout << s[i]<<" ";
        cout << endl;
        cout << "输入要查找的元素：";
        cin >> x;
        i = BinarySearch(s,x,0,n-1);
        if (i == -1)
            cout << "no found";
        else
            cout << "the element found is" << i + 1 << "位" << endl;

        
    }
    
    cin.ignore();
    return 0;
}

3.动态规划

算法思想：