背包問題（貪心算法）

注意：這是背包問題，而不是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;
}