背包问题（贪心算法）

注意：这是背包问题，而不是0-1背包问题，背包问题可以用贪心算法进行求解，但0-1无法用贪心算法求解，需要用动态规划算法求解；

首先对贪心算法做一下总结，以及它与动态规划算法的区别：

贪心算法两个最重要的性质：

（1）贪心选择性质；

（2）最优子结构性质；

其中，贪心选择性质：自顶向下进行决策，每次做出的决策都是局部最优解，且每次做出决策后问题规模都变小了；最优子结构性质：即问题的最优解结构中包含子问题的最优解；

动态规划算法的两个最重要的性质：

（1）重叠子问题性质；

（2）最优子结构性质；

其中最优解子结构性质和贪心算法相似，唯一不同的是重叠子问题性质，因为动态规划算法是自底向上的算法，它需要首先将原始问题分解为若干个相互有联系的子问题，在计算的时候有的子问题可能会被计算很多次，所以动态规划算法会将这些子问题的解存在一个表格中，使得最终对于这些子问题只需要求解一次（可以使原来需要再指数时间内解决的问题可以在多项式问题中得到解决）

背包问题求解代码如下：

（其中使用的排序算法基于合并排序算法）

#ifndef MERGE_SORT_H
#define MERGE_SORT_H

template <class Type>
void MergeSort(Type a[], int n);

#endif

//merge_sort.template实现部分
#include "merge_sort.h"

template <class Type>
void MergeSort(Type *a , Type *v, int n)  //a是重量,v是价值
{
    Type *b = new Type[n];
    int s = 1;
    while (s < n)
    {
        MergePass(a, b, v , s, n);  //合并到数组b
        s += s;
        MergePass(b, a, v , s, n);  //合并到数组a
        s += s;
    }
    delete b;
}

template <class Type>
void MergePass(Type *x, Type *y, Type *v, int s, int n)
{
    int i = 0;
    while (i <= n - s * 2)
    {
        Merge(x, y ,v , i, i + s - 1, i + 2 * s - 1);  //合并大小为s的相邻两段子数组
        i += s * 2;
    }
    if (i + s < n)  //剩下的元素少于2s
        Merge(x, y, v, i, i + s - 1, n - 1);
    else for (int j = i; j <= n - 1; j++)
        y[j] = x[j];
}

template <class Type>
void Merge(Type *c, Type *d, Type *v , int l, int m, int r)  //合并c[l:m]和c[m+1:r]到d[l:r],其中c[l:m]和c[m+1:r]都是已经经过升序排好的数组
{
    int i = l, j = m + 1, k = l;
    while ((i <= m) && (j <= r))
    {
        if ((v[i] / c[i]) >= (v[j] / c[j]))  //这里使用降序排序
            d[k++] = c[i++];
        else
            d[k++] = c[j++];
    }
    if (i > m)
        for (int q = j; q <= r; q++)
            d[k++] = c[q];
    else for (int q = i; q <= m; q++)
        d[k++] = c[q];
}

//背包问题，使用贪心算法进行求解
//======================================================
#include <iostream>
#include "merge_sort.cpp"

using namespace std;


void init_data(float *v, float *w, float *x, int n)  //初始化数据
{
    cout << "请输入每类物体的价值：" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> v[i];
    }
    cout << "请输入每类物体的重量： " << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> w[i];
    }
    for (int i = 0; i < n; i++)
        x[i] = 0;
}

void Knapsack(int n, float M, float *v, float *w, float *x)
//n是物体的种类数，M是背包容量，v是每类物体的价值，w是每类物体的重量,x是每类物体装入的份额，属于[0,1]
{
    int i = 0;
    float c = M;

    MergeSort(w , v , n);  //v[i]/w[i]是每一类物体的单位重量价值，然后对它们进行降序排序

    for (i = 0; i < n; i++)
    {
        if (w[i] > c)
            break;
        x[i] = 1;
        c -= w[i];
    }
    if (i < n)
        x[i] = c / w[i];
}

int main(void)
{
    float M = 0.0;  //背包容量
    cout << "请输入背包容量：  ";
    cin >> M;
    int n = 0;  //物体数量
    cout << "\n请输入物体数量 n :  ";
    cin >> n;
    float *v = new float[n];
    float *w = new float[n];
    float *x = new float[n];

    init_data(v, w, x, n);  //初始化数据
    Knapsack(n, M, v, w, x);

    cout << "排好序的w[i]:  " << endl;
    for (int i = 0; i < n; i++)
    {
        cout << w[i] << "  ";
    }
    cout << "\n\n输出最后的决策x[i] : " << endl;
    for (int i = 0; i < n; i++)
    {
        cout << x[i] << "  ";
    }

    /*MergeSort(w, v, n);
    cout << "输出排好序的w[i] : " << endl;
    for (int i = 0; i < n; i++)
    {
        cout << w[i] << "  ";

    }*/
    system("pause");
    delete v , w , x;
    return 0;
}