网易买苹果

链接： https://www.nowcoder.com/questionTerminal/61cfbb2e62104bc8aa3da5d44d38a6ef
来源：牛客网

分析

• 思路1：动态规划（通用解法）

采用动态规划求解。思路同本文中前面的编程题——跳石板。创建一个vector容器steps，steps[i]表示购买i个苹果所需的最小袋数。初始化为steps容器为INT_MAX。从1苹果开始遍历，若steps[i]为INT_MAX，表示无法购买该个数的苹果，直接开始下次循环。若steps[i]不为INT_MAX，表示该个数的苹果可以购买，进行动态规划求解。动态规划的转移方程为

steps[i+j] = min(steps[i]+1,steps[i+j])   //j为6或8
steps[0] = 0

动态规划的过程如下图所示。

可以理解一下贪婪算法，就是每次选择最好的，如果剩下空间不够最好的，再去用下一等来填充，如果超标，就把最好的减一，，进行回溯

• 思路2：贪婪算法

对于金额，优先选取每袋含有8个苹果的包装。若还有余数，则再用6个装的包装去购买。如果不行的话，则将8个装的个数减去1个，进行回溯，再用6包装的去购买。如果还不行的话，再次回溯，直到购买8包装的个数为0。

贪婪算法并不一定能得到最优解，但是一个可行的，较好的解。下面对使用贪婪算法能否得到最优解进行分析。

首先，6和8都是偶数。因此，能凑出的个数也一定是偶数。程序中若苹果总数是奇数，可以直接返回-1。

再次，偶数个苹果数对8取模，其结果只可能为0,2,4,6。若余数为6或者0，则可以直接用6包装情况处理，不需要回溯购买8包装的情况。若余数为4，只需回溯1次即可，因为8+4=12, 12%6 = 0。若余数为2，只需回溯2次即可，因为8+8+2=18, 18%6 = 0。

综上，本题情况使用贪婪算法一定能得到最优解。

贪婪算法并不一定能得到最优解，但是一个可行的，较好的解。例如，给定硬币coins=[1,2,10,25]，金额总数amounts=30，不限制每种币值的硬币数量，要求用所给硬币凑出所需金额，并且硬币数量最少。若采用贪婪算法求解，需要6枚（25+5*1）硬币。 若采用动态规划求解，所需3枚（10+10+10）硬币。 --- 贪婪算法

• 思路3：数字分析求解。O(1)算法

对数字特征进行分析。

首先，6和8都是偶数。因此，能凑出的个数也一定是偶数。程序中若苹果总数是奇数，可以直接返回-1。

再次，偶数个苹果数对8取模，其结果只可能为0,2,4,6。若余数为6或者0，则可以直接用6包装情况处理，不需要回溯购买8包装的情况。若余数为4，只需回溯1次即可，因为8+4=12, 12%6 = 0。若余数为2，只需回溯2次即可，因为8+8+2=18, 18%6 = 0。

综上，可以采用如下思路进行处理。（由于数字6和8的特征，本方法只适用于本题）

• 情况1：若num不是偶数，则直接返回-1
• 情况2：若num%8 = 0，则返回num/8
• 情况3：若num%8 != 0，则只需回溯1次或者2次8包装购买个数，就可以求解。回溯1次，其结果为n/8-1+2 = n/8+1；回溯1次，其结果为n/8-2+3 = n/8+1。因此，可以情况3下，可以返回n/8+1。

求解

• 方法1：动态规划。

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

int main(){
    int amounts;
    cin>>amounts;
    vector<int> steps(amounts+1,INT_MAX);
    steps[6] = 1;
    steps[8] = 1;
    for(int i=6;i<=amounts;i++){
        if(steps[i] == INT_MAX){
            continue;
        }
        else{
            if(i+6 <= amounts){
                steps[i+6] = min(steps[i]+1,steps[i+6]);
            }
            if(i+8 <= amounts){
                steps[i+8] = min(steps[i]+1,steps[i+8]);
            }

        }
    }
    steps[amounts] = (steps[amounts] == INT_MAX)? -1:steps[amounts];

    cout<<steps[amounts]<<endl;
    return 0;
}

• 方法2：贪婪算法。

#include <iostream>
using namespace std;

int maxPackages(int num) {
    int res = 0;
    int mul, remains;
    if(num%2 != 0){
        return -1;  //非偶数直接返回
    }

    if (num % 8 == 0) {
        res += num / 8;
        return res;
    }
    else{
        mul = num / 8;  //倍数
        remains = num % 8;
        res += mul;
        num = num % 8;
        while (mul >= 0) {  //回溯8包装
            if (num % 6 == 0) {
                res += num / 6;
                return res;
            }
            else {
                mul--;  //回溯  8包装购买袋数-1
                res--;
                num = num + 8;
            }
        }
    }
    return -1;

}


int main() {
    int num;
    while (cin >> num) {
        cout << maxPackages(num) << endl;
    }
    return 0;
}

• 方法3：数字分析求解。O(1)。

#include <iostream>
using namespace std;

int main() {
    int num;
    while (cin >> num) {
        if(num%2 != 0){
            cout<<-1<<endl;
        }
        else{
            if(num%8 == 0){
                cout<<num/8<<endl;
            }
            else{
                cout<<1+num/8<<endl;
            }
        }
    }
    return 0;
}