背包问题

   
   
   
   

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

    
    
    
    #define
    
    
    
     MAXSIZE 100 
    
    
    
    //
    
    
    
    假设物体总数
    
    
    
    

    
    
    
    #define
    
    
    
     M 15 
    
    
    
    //
    
    
    
    背包的载荷能力
    
    
    
    

    
    
    
    using
    
    
    
     
    
    
    
    namespace
    
    
    
     std;


    
    
    
    //
    
    
    
    算法核心，贪心算法
    
    
    
    

    
    
    
    void
    
    
    
     GREEDY(
    
    
    
    float
    
    
    
     w[], 
    
    
    
    float
    
    
    
     x[], 
    
    
    
    int
    
    
    
     sortResult[], 
    
    
    
    int
    
    
    
     n)
{
 
    
    
    
    float
    
    
    
     c 
    
    
    
    =
    
    
    
     M;
 
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;
 
    
    
    
    int
    
    
    
     temp 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;

 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
    
    
    
    //
    
    
    
    准备输出结果
    
    
    
    

    
    
    
     {
 x[i] 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;
 }

 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 {
 
    
    
    
    for
    
    
    
    (
    
    
    
    int
    
    
    
     j
    
    
    
    =
    
    
    
    0
    
    
    
    ;j
    
    
    
    <
    
    
    
    n;j
    
    
    
    ++
    
    
    
    )
 
    
    
    
    if
    
    
    
    (sortResult[j]
    
    
    
    ==
    
    
    
    i
    
    
    
    +
    
    
    
    1
    
    
    
    )
 {
 temp 
    
    
    
    =
    
    
    
     j;
    
    
    
    //
    
    
    
    得到取物体的顺序
    
    
    
    

    
    
    
     
    
    
    
    break
    
    
    
    ;
 }
 
    
    
    
    if
    
    
    
     (w[temp] 
    
    
    
    >
    
    
    
     c)
 {
 
    
    
    
    break
    
    
    
    ;
 }

 x[temp] 
    
    
    
    =
    
    
    
     
    
    
    
    1
    
    
    
    ;
    
    
    
    //
    
    
    
    若合适则取出
    
    
    
    

    
    
    
     c 
    
    
    
    -=
    
    
    
     w[temp];
    
    
    
    //
    
    
    
    将容量相应的改变
    
    
    
    

    
    
    
     }

 
    
    
    
    if
    
    
    
     (i 
    
    
    
    <=
    
    
    
     n)
    
    
    
    //
    
    
    
    使背包充满
    
    
    
    

    
    
    
     {
 x[temp] 
    
    
    
    =
    
    
    
     c 
    
    
    
    /
    
    
    
     w[temp]; 
    
    
    
    //
    
    
    
    取某件物品的一部分
    
    
    
    

    
    
    
     }

 
    
    
    
    return
    
    
    
    ;
}


    
    
    
    void
    
    
    
     sort(
    
    
    
    float
    
    
    
     x[], 
    
    
    
    int
    
    
    
     sortResult[], 
    
    
    
    int
    
    
    
     n)
{
 
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    , j 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;
 
    
    
    
    int
    
    
    
     index 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    , k 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;

 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
    
    
    
    //
    
    
    
    对映射数组赋初值0
    
    
    
    

    
    
    
     {
 sortResult[i] 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;
 }

 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 {
 
    
    
    
    float
    
    
    
     temp 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;

 index 
    
    
    
    =
    
    
    
     i;

 
    
    
    
    //
    
    
    
    找到性价比最高的商品，并保存下标
    
    
    
    

    
    
    
     
    
    
    
    for
    
    
    
     (j 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; j 
    
    
    
    <
    
    
    
     n; j
    
    
    
    ++
    
    
    
    )
 {
 
    
    
    
    if
    
    
    
     ((temp 
    
    
    
    <
    
    
    
     x[j]) 
    
    
    
    &&
    
    
    
     (sortResult[j] 
    
    
    
    ==
    
    
    
     
    
    
    
    0
    
    
    
    ))
 {
 temp 
    
    
    
    =
    
    
    
     x[j];
 index 
    
    
    
    =
    
    
    
     j;
 }
 }

 
    
    
    
    //
    
    
    
    对w[i]作标记
    
    
    
    

    
    
    
     
    
    
    
    if
    
    
    
     (sortResult[index] 
    
    
    
    ==
    
    
    
     
    
    
    
    0
    
    
    
    )
 {
 sortResult[index] 
    
    
    
    =
    
    
    
     
    
    
    
    ++
    
    
    
    k;
 }
 }
 cout
    
    
    
    <<
    
    
    
    "
    
    
    
    映射数组sortResult：
    
    
    
    "
    
    
    
    <<
    
    
    
    endl;
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 cout
    
    
    
    <<
    
    
    
    sortResult[i]
    
    
    
    <<
    
    
    
    "
    
    
    
     
    
    
    
    "
    
    
    
    ;


    
    
    
    return
    
    
    
    ;
}


    
    
    
    //
    
    
    
    得到本算法的所有输入信息
    
    
    
    

    
    
    
    void
    
    
    
     getData(
    
    
    
    float
    
    
    
     p[], 
    
    
    
    float
    
    
    
     w[], 
    
    
    
    int
    
    
    
     
    
    
    
    *
    
    
    
    n)
{
 
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;

 printf(
    
    
    
    "
    
    
    
    please input the total count of object: 
    
    
    
    "
    
    
    
    );
 scanf(
    
    
    
    "
    
    
    
    %d
    
    
    
    "
    
    
    
    , n);

 printf(
    
    
    
    "
    
    
    
    Please input array of p :\n
    
    
    
    "
    
    
    
    );
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     (
    
    
    
    *
    
    
    
    n); i
    
    
    
    ++
    
    
    
    )
 {
 scanf(
    
    
    
    "
    
    
    
    %f
    
    
    
    "
    
    
    
    , 
    
    
    
    &
    
    
    
    p[i]);
 }

 printf(
    
    
    
    "
    
    
    
    Now please input array of w :\n
    
    
    
    "
    
    
    
    );
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     (
    
    
    
    *
    
    
    
    n); i
    
    
    
    ++
    
    
    
    )
 {
 scanf(
    
    
    
    "
    
    
    
    %f
    
    
    
    "
    
    
    
    , 
    
    
    
    &
    
    
    
    w[i]);
 }

 
    
    
    
    return
    
    
    
    ;
}


    
    
    
    void
    
    
    
     output(
    
    
    
    float
    
    
    
     x[], 
    
    
    
    int
    
    
    
     n)
{
 
    
    
    
    int
    
    
    
     i;

 printf(
    
    
    
    "
    
    
    
    \n\nafter arithmetic data: advise method\n
    
    
    
    "
    
    
    
    );
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 {
 printf(
    
    
    
    "
    
    
    
    x[%d]\t
    
    
    
    "
    
    
    
    , i);
 }

 printf(
    
    
    
    "
    
    
    
    \n
    
    
    
    "
    
    
    
    );
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 {
 printf(
    
    
    
    "
    
    
    
    %2.3f\t
    
    
    
    "
    
    
    
    , x[i]);
 }

 
    
    
    
    return
    
    
    
    ;
}


    
    
    
    int
    
    
    
     main()
{
 
    
    
    
    float
    
    
    
     p[MAXSIZE], w[MAXSIZE], x[MAXSIZE];
 
    
    
    
    int
    
    
    
     i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    , n 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ;
 
    
    
    
    int
    
    
    
     sortResult[MAXSIZE];

 getData(p, w, 
    
    
    
    &
    
    
    
    n); 
    
    
    
    //
    
    
    
    获取数据
    
    
    
    

    
    
    
    
 
    
    
    
    for
    
    
    
     (i 
    
    
    
    =
    
    
    
     
    
    
    
    0
    
    
    
    ; i 
    
    
    
    <
    
    
    
     n; i
    
    
    
    ++
    
    
    
    )
 {
 x[i] 
    
    
    
    =
    
    
    
     p[i] 
    
    
    
    /
    
    
    
     w[i]; 
    
    
    
    //
    
    
    
    得到每件物品的单位重量的价值
    
    
    
    

    
    
    
     }

 sort(x, sortResult, n); 
    
    
    
    //
    
    
    
    得到映射数组，数组中按照物品单位重量的价值从大到小的顺序做了标记，方便取物品
    
    
    
    

    
    
    
    
 GREEDY(w, x, sortResult, n); 
    
    
    
    //
    
    
    
    按照映射数组标记的顺序取物品，和总重量比较
    
    
    
    

    
    
    
    
 output(x, n);
 
    
    
    
    return
    
    
    
     
    
    
    
    0
    
    
    
    ;
}

   
   
   
   

所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，所做出的仅是在某种意义上的局部最优解。
　　贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。
　　贪心算法的基本思路如下：
　　1.建立数学模型来描述问题。
　　2.把求解的问题分成若干个子问题。
　　3.对每一子问题求解，得到子问题的局部最优解。
　　4.把子问题的解局部最优解合成原来解问题的一个解。

 

利用贪心策略解题，需要解决两个问题：
一、确定问题是否能用贪心策略求解；一般来说，适用于贪心策略求解的问题具有以下特点：
① 可通过局部的贪心选择来达到问题的全局最优解。运用贪心策略解题，一般来说需要一步步的进行多次的贪心选择。在经过一次贪心选择之后，原问题将变成一个相似的，但规模更小的问题，而后的每一步都是当前看似最佳的选择，且每一个选择都仅做一次。
② 原问题的最优解包含子问题的最优解，即问题具有最优子结构的性质。在背包问题中，第一次选择单位质量最大的货物，它是第一个子问题的最优解，第二次选择剩下的货物中单位重量价值最大的货物，同样是第二个子问题的最优解，依次类推。
二、如何选择一个贪心标准？正确的贪心标准可以得到问题的最优解，在确定采用贪心策略解决问题时，不能随意的判断贪心标准是否正确，尤其不要被表面上看似正确的贪心标准所迷惑。在得出贪心标准之后应给予严格的数学证明。

贪心一般都伴随着使用排序