华为OD机试--统一限载最小值的正确答案

原题目请见统一限载最小值
考前看过他发的这个题，4月18日考试时没多想就用和他一样的思路写了（其实就是暴力枚举），结果报超时没给过，时间紧张也来不及改，结束后算了下他这个时间复杂度居然是O(mⁿ)，如此之大，能过才是见鬼了。
这意味着即使只有10辆车10个干/湿货供应商，也要算10¹⁰次

我又重新写了一下，我的思路和代码时间复杂度是O(n²+m×n)，m是车的数量，n是货物供应商的数量，有n²是因为冒泡排序。
（讲之前先发个牢骚：他标题还写100%通过率，他专栏还这么贵，还删我评论，搞笑，我现在是非常无语）

主要逻辑是：
干湿分开算最小限载量（下面以干货为例）
干货放进k辆车，尽可能让（装的最多的那辆车）装的更少。
所以，找出没装车的（量最多的干货）装到（装的最少的车）就可以。循环直到装完所有货物。

举个例子
没装的干货为5，3，1
车的载重为1，0，3
那就把重量为5的干货装入载重为0的车

实现方法：
1、将货排序，量多的在前（随便怎么排都行）
2、找出装的最少的车，把还没装的货中排最前面的那个装进去
3、循环步骤2直到装完

附上代码（我测了各种数据都没问题，但是这不说明一定没bug，有问题请在评论区留言）（写的比较啰嗦，还有不少地方能优化优化，懒得改了，能用就行）

#include 
#include 
using namespace std;

int length, k;
vector<int> goods, types, goods_0, goods_1;
int max_0, max_1;

int main()
{

    int temp;
    string str;

    // 输入部分
    cin >> length;
    for (int i = 0; i < length; i++)
    {
        cin >> temp;
        goods.push_back(temp);
    }
    for (int i = 0; i < length; i++)
    {
        cin >> temp;
        types.push_back(temp);
    }
    cin >> k;

    // 干货湿货分开
    for (int i = 0; i < length; i++)
    {
        if (types[i] == 0)
            goods_0.push_back(goods[i]);
        else
            goods_1.push_back(goods[i]);
    }

    // 干货部分

    // 冒泡排序，把数量多的放前面
    // 冒泡比较慢，可能还是会超时，可以用其他排序算法（或者用multiset）
    bool state;
    while (1)
    {
        state = true;
        if (goods_0.size() <= 1)
            break;
        for (int i = 0; i < goods_0.size() - 1; i++)
        {
            if (goods_0[i] < goods_0[i + 1])
            {
                temp = goods_0[i + 1];
                goods_0[i + 1] = goods_0[i];
                goods_0[i] = temp;
                state = false;
            }
        }
        if (state)
            break;
    }

    // 装货，遍历每个供应商的货的数量，装进装的最少的车里
    int min_index, min_sum;
    vector<int> data_0(k, 0); // 记录每辆车的装货量
    for (int a = 0; a < goods_0.size(); a++)
    {
        min_sum = INT_MAX;
        for (int b = 0; b < k; b++)
        {
            if (min_sum > data_0[b])
            {
                min_sum = data_0[b];
                min_index = b;
            }
        }
        data_0[min_index] += goods_0[a];
    }
    // 找出装的最多的那一车，将其承载量作为最小承载量
    max_0 = 0;
    for (int a = 0; a < k; a++)
    {
        max_0 = max(max_0, data_0[a]);
    }

    // 湿货部分，同上
    while (1)
    {
        state = true;
        if (goods_1.size() <= 1)
            break;
        for (int i = 0; i < goods_1.size() - 1; i++)
        {
            if (goods_1[i] < goods_1[i + 1])
            {
                temp = goods_1[i + 1];
                goods_1[i + 1] = goods_1[i];
                goods_1[i] = temp;
                state = false;
            }
        }
        if (state)
            break;
    }

    vector<int> data_1(k, 0);
    for (int a = 0; a < goods_1.size(); a++)
    {
        min_sum = INT_MAX;
        for (int b = 0; b < k; b++)
        {
            if (min_sum > data_1[b])
            {
                min_sum = data_1[b];
                min_index = b;
            }
        }
        data_1[min_index] += goods_1[a];
    }
    max_1 = 0;
    for (int a = 0; a < k; a++)
    {
        max_1 = max(max_1, data_1[a]);
    }

    // 输出干湿货最小承载量更大的那一个，作为最终结果
    cout << max(max_0, max_1);
    return 0;
}