华为2018编程挑战赛分配部分二维背包c++代码实现

最新推荐文章于 2024-09-11 11:46:11 发布
最新推荐文章于 2024-09-11 11:46:11 发布
阅读量207 收藏 1
点赞数
分类专栏： 其他学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37946085/article/details/82922995
版权

这个月参加了华为编程挑战赛，（初赛赛题：http://codecraft.devcloud.huaweicloud.com/home/detail）。
分配部分的代码主要由我负责，放出来做个备份。
背包法的参考资料：
https://baike.baidu.com/item/%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%98/2416931?fr=aladdin
https://blog.csdn.net/na_beginning/article/details/62884939

1. distrubute.h

#ifndef Dis_H
#define Dis_H
#include <string>
#include <iostream>
#include "predict.h"
#include <list>
using namespace std;
#define ISCPU true
#define ISMEM false
#define FLAVORNUMMAX 999
#define LOWISTRATE 0.3
#define LOWRATE 0.95



//int f[FLAVORNUMMAX][CPUSUM+1][MEMSUM+1] = { 0 };  // 存放value的数组
//bool g[FLAVORNUMMAX][CPUSUM+1][MEMSUM+1] = { false }; // 存放是否放入背包的数组


class Flavor
{
public:
    string flavor;  
    int CPU;        
    int Memory;     
    Flavor(const string FLAVOR){
        flavor = FLAVOR;
        str2int(type,FLAVOR);
        switch (type)
        {
        case 1:
            CPU = 1;
            Memory = 1;
            break;
        case 2:
            CPU = 1;
            Memory = 2;
            break;
        case 3:
            CPU = 1;
            Memory = 4;
            break;
        case 4:
            CPU = 2;
            Memory = 2;
            break;
        case 5:
            CPU = 2;
            Memory = 4;
            break;
        case 6:
            CPU = 2;
            Memory = 8;
            break;
        case 7:
            CPU = 4;
            Memory = 4;
            break;
        case 8:
            CPU = 4;
            Memory = 8;
            break;
        case 9:
            CPU = 4;
            Memory = 16;
            break;
        case 10:
            CPU = 8;
            Memory = 8;
            break;
        case 11:
            CPU = 8;
            Memory = 16;
            break;
        case 12:
            CPU = 8;
            Memory = 32;
            break;
        case 13:
            CPU = 16;
            Memory = 16;
            break;
        case 14:
            CPU = 16;
            Memory = 32;
            break;
        case 15:
            CPU = 16;
            Memory = 64;
            break;
        default:
            cout << "ERROR: ÊäÈëµÄÐéÄâ»úÐͺÅûÓÐÕÒµ½" << endl;
        }
    }

    int type;       // 0~15 虚拟机型号
};
class BagItem
{
public:
    string flavor;
    int CPUWeight;
    int memoryWeight;
    int value;  // 该虚拟机的CPU个数或内存大小
    int num; // 有多少种该虚拟机
    BagItem(const Flavor FLAVOR, const int NUM, const bool CM1){
        flavor = FLAVOR.flavor;
        CPUWeight = FLAVOR.CPU * NUM;
        memoryWeight = FLAVOR.Memory * NUM;
        value = (CM1 == ISCPU) ? CPUWeight : memoryWeight;
        num = NUM;
        type = FLAVOR.type;
    };
    int type;       // 0~15 虚拟机型号
};

class PhysicalServer
{
public:
    list<BagItem> flavorList;   // ·物理机上存放的虚拟机列表
    int num;    // ÎïÀí»ú±êºÅ
    PhysicalServer(int NUM)
    {
        num = NUM;
    };
};


list<BagItem> PreTreatmentSingle(const Flavor flavor, const int NUM);
list<BagItem> PreTreatment(list<Flavor> flavorList, int * num);
void InitialFlavorList(list<Flavor> &flavorList);
void GetF(list<BagItem> itemList);
void GetG(list<BagItem> &itemList, list<PhysicalServer> &serverList);
list<PhysicalServer> GetPhysicalServerList(list<BagItem> &itemList, list<PhysicalServer> &serverList);
vector<double> Distribute(list<PhysicalServer> &serverList, int *a,bool CM_in,int CPUSUM_in, int MEMSUM_in);
#endif

2. distrubute.cpp

#include "distribute.h"
#include <iostream>
#include <list>
#include <vector>
#include <exception>
using namespace std;
bool CM;
int CPUSUM; // 物理服务器的cpu总数
int MEMSUM; // 物理服务器的内存总量
//#define LOWISTRATE 0.3

list<BagItem> PreTreatmentSingle(const Flavor flavor, const int NUM )
{

    list<BagItem> itemList;

    if (NUM <= 0)
    {
        return itemList;
    }

    if (NUM == 1)
    {
        BagItem item(flavor, NUM, CM);
        itemList.push_back(item);
        return itemList;
    }

    int n = NUM;
    int k = 1;
    while (n > 1)
    {
        BagItem item(flavor, k, CM);
        itemList.push_back(item);
        k = k * 2;
        n = n / 2;
    }
    BagItem item(flavor, NUM - k + 1, CM);
    itemList.push_back(item);
    return itemList;
}

// 预处理
list<BagItem> PreTreatment(list<Flavor> flavorList, int * num)
{

    list<BagItem> bagItemList;
    int j = 0;
    list<Flavor>::iterator it;
    for(it = flavorList.begin(); it != flavorList.end(); it++)  //for each (auto flavor in flavorList)
    {
        Flavor flavor = *it;
        if (num[j] != 0){
            for (int i = 0; i < num[j]; i++)
            {
                BagItem item(flavor, 1, CM);
                bagItemList.push_back(item);
            }
        }
        j++;
    }
    return bagItemList;

}
void InitialFlavorList(list<Flavor> &flavorList)
{
    for (int i = 1; i <= 15; i++)
    {
        Flavor flavor(to_string(i));
        flavorList.push_back(flavor);
    }
}


int f[FLAVORNUMMAX][100][513] = { 0 };  
bool g[FLAVORNUMMAX][100][513] = { false }; 

list<PhysicalServer> serverList;

void GetF(list<BagItem> itemList)
{
    int i = 0;
    list<BagItem>::iterator it = itemList.begin();
    for (it = itemList.begin(); it != itemList.end();it++)
    {
        BagItem bagItem = *it;
        for (int u = 1; u <= CPUSUM; u++)
        {
            for (int v = 1; v <= MEMSUM; v++)
            {
                if ((i > 0) && (u - bagItem.CPUWeight >= 0) && (v - bagItem.memoryWeight >= 0))      // 一般情况
                {
                    if (f[i - 1][u][v] < f[i - 1][u - bagItem.CPUWeight][v - bagItem.memoryWeight] + bagItem.value)
                    {
                        f[i][u][v] = f[i - 1][u - bagItem.CPUWeight][v - bagItem.memoryWeight] + bagItem.value;
                        g[i][u][v] = true;
                    }
                    else if (f[i - 1][u][v] == f[i - 1][u - bagItem.CPUWeight][v - bagItem.memoryWeight] + bagItem.value)
                    {
                        f[i][u][v] = f[i - 1][u][v];
                        --it;
                        g[i][u][v] = bagItem.value>(*it).value ? true : false;
                        ++it;
                    }
                    else
                    {
                        f[i][u][v] = f[i - 1][u][v];
                        g[i][u][v] = false;
                    }
                }
                else if (i == 0)    // 第一行
                {
                    if ((u - bagItem.CPUWeight >= 0) && (v - bagItem.memoryWeight >= 0)) {
                        f[i][u][v] = bagItem.value;
                        g[i][u][v] = true;
                    }
                    else{
                        f[i][u][v] = 0;
                        g[i][u][v] = false;
                    }
                }
                else        // 重量减了之后超限
                {
                    f[i][u][v] = f[i - 1][u][v];
                    g[i][u][v] = false;
                }
            }
        }
        i++;
    }

}

void GetG(list<BagItem> &itemList, list<PhysicalServer> &serverList)
{
    int u = CPUSUM ;
    int v = MEMSUM ;
    int i = itemList.size() - 1;
    PhysicalServer physicalServer(serverList.size());
    list<BagItem>::iterator it = itemList.end();  // 迭代器初始化为数组最末尾
    for (it--; it != itemList.begin(); it--)        // 逆序访问物品列表
    {
        if (g[i][u][v])
        {
            physicalServer.flavorList.push_back(*it);   // 放在该物理机中
            u = u - (*it).CPUWeight;
            v = v - (*it).memoryWeight;
            it = itemList.erase(it);        // 删除元素, 指向被删除元素之后的元素
        }
        i--;
    }   // 直到it指向itemList.begin，此时i应等于0
    if (g[i][u][v])     // 处理itemList.begin这个元素
    {
        physicalServer.flavorList.push_back(*it);   // 放在该物理机中
        itemList.erase(it);     // 删除元素, 指向被删除元素之后的元素
    }
    serverList.push_back(physicalServer);
}

list<PhysicalServer> GetPhysicalServerList(list<BagItem> &itemList, list<PhysicalServer> &serverList)
{
    while (itemList.size() > 0)
    {
        GetF(itemList);
        GetG(itemList, serverList);
    }
    return serverList;
}

/

void AddFlavor(list<BagItem> &flavorList, int *a, bool CM_in, int CPUSUM_in, int MEMSUM_in)
{
    int cpuu = 0;
    int mem = 0;
    list<BagItem>::iterator it2;
    for (it2 = flavorList.begin(); it2 != flavorList.end(); it2++)
    {
        cpuu += (*it2).CPUWeight * (*it2).num;
        mem += (*it2).memoryWeight * (*it2).num;
    }

    int cpuLeft =  CPUSUM_in-cpuu;
    int memLeft =  MEMSUM_in-mem;

    // int order[10]={ 13, 12, 10, 9, 7, 6, 4, 3 ,1, 0 };  // flavor14,flavor13, 11, 10...... 2, 1
    // if(CM_in == ISMEM)
    // {
    //  order[0]=14; // flavor15;
    //  order[1]=11; // flavor12;
    //  order[2]=8; // flavor9;
    //  order[3]=7; // flavor8;
    //  order[4]=5; // flavor6;
    //  order[5]=4; // flavor5;
    //  order[6]=2; // flavor3;
    //  order[7]=3; // flavor4;
    //  order[8]=1; // flavor2;
    //  order[9]=0; // flavor1;
    // }
    // int order[7]={ 12, 9, 6, 3, 0, 0, 0 };  // flavor14,flavor13, 11, 10...... 2, 1
    // if(CM_in == ISMEM)
    // {
    //  order[0]=14; // flavor15;
    //  order[1]=11; // flavor12;
    //  order[2]=8; // flavor9;
    //  order[3]=5; // flavor6;
    //  order[4]=2; // flavor3;
    //  order[5]=1; // flavor2;
    //  order[6]=0; // flavor1;
    // }
    int order[10]={9, 7, 6, 13, 12, 10,  4, 3 ,1, 0 };  // flavor14,flavor13, 11, 10...... 2, 1
    if(CM_in == ISMEM)
    {
        order[0]=8; // flavor9;
        order[1]=7; // flavor8;
        order[2]=5; // flavor6;
        order[3]=14; // flavor15;
        order[4]=11; // flavor12;
        order[5]=4; // flavor5;
        order[6]=2; // flavor3;
        order[7]=3; // flavor4;
        order[8]=1; // flavor2;
        order[9]=0; // flavor1;
    }

    for(int i=0;i<10;i++)
    {
        if(a[order[i]]>=0)  // if flavor i  need be predicted 
        {   
            Flavor f(to_string(order[i]+1));
            BagItem flavor(f, 1, CM_in);

            while((cpuLeft >= flavor.CPUWeight)&&(memLeft >= flavor.memoryWeight))
            {
                for (it2 = flavorList.begin(); it2 != flavorList.end(); it2++)
                {
                    if ((*it2).type == flavor.type)
                    {
                        (*it2).num++ ;
                        break;
                    }
                }
                if(it2 == flavorList.end())
                    flavorList.push_back(flavor);
                a[order[i]]++;
                cpuLeft -=  flavor.CPUWeight;
                memLeft -=  MEMSUM_in-mem;
            }

        }
    }

}


vector<double> mend(list<PhysicalServer> &serverList, int *a,bool CM_in,int CPUSUM_in, int MEMSUM_in)
{
    CM = CM_in;
    CPUSUM = CPUSUM_in;
    MEMSUM = MEMSUM_in;


    list<PhysicalServer>::iterator it;
    //cout<<"hhhhhh"<<endl;
    for(it = serverList.begin(); it != serverList.end(); it++)// each (auto server in serverList)
    {
        //PhysicalServer server = *it;
        //cout << server.num << ":" << endl;
        int cpuu = 0;
        int mem = 0;
        list<BagItem>::iterator it2;
        for (it2 = (*it).flavorList.begin(); it2 != (*it).flavorList.end(); it2++)
        {
            cpuu += (*it2).CPUWeight * (*it2).num;
            mem += (*it2).memoryWeight * (*it2).num;
        }

        double cp = cpuu*1.0 / CPUSUM;
        double me = mem*1.0 / MEMSUM;

        if ((CM==ISCPU && cp < LOWISTRATE)||(CM==ISMEM && me < LOWISTRATE))
        {
            for (it2 = (*it).flavorList.begin(); it2 != (*it).flavorList.end(); it2++)
            {
                a[(*it2).type-1] = a[(*it2).type-1] - (*it2).num;
                cout<<(*it2).type<<"::"<<(*it2).num<<endl;
            }
            it = serverList.erase(it);
        }
        else if ((CM==ISCPU && cp < LOWRATE)||(CM==ISMEM && me < LOWRATE))
        {
            AddFlavor( (*it).flavorList, a, CM_in, CPUSUM_in, MEMSUM_in);
        }
    }

    double cpurate = 0;
    double memrate = 0;
    int m = 0;
    for(it = serverList.begin(); it != serverList.end(); it++)// each (auto server in serverList)
    {
        //PhysicalServer server = *it;
        (*it).num = m;
        m++;
        //cout << server.num << ":" << endl;
        int cpuu = 0;
        int mem = 0;
        list<BagItem>::iterator it2;
        for (it2 = (*it).flavorList.begin(); it2 != (*it).flavorList.end(); it2++)
        {
            cpuu += (*it2).CPUWeight * (*it2).num;
            mem += (*it2).memoryWeight * (*it2).num;
        }
        double cp = cpuu*1.0 / CPUSUM;
        double me = mem*1.0 / MEMSUM;
        cpurate = cpurate + cp;
        memrate = memrate + me;
    }
    cout << cpurate / m  << "\t" << memrate/m <<  endl;
    vector<double> score2;
    score2.push_back(cpurate / m);
    score2.push_back(memrate / m );
    for(int i=0;i<15;i++)
        cout<<a[i]<<" ";
    cout<<endl;
// if((CM==ISCPU && cpurate / m< LOWRATE )||(CM==ISMEM && memrate / m < LOWRATE))
//  for(int i=0;i<15;i++)
//      a[i]=10000;
    return score2;
}
/

vector<double> Distribute(list<PhysicalServer> &serverList, int *a,bool CM_in,int CPUSUM_in, int MEMSUM_in)
{
    for(int i=0; i<FLAVORNUMMAX; i++)
    {
        for(int k=0; k<100; k++)
        {
            for(int j=0; j<513; j++)
            {
                f[i][k][j]=0;
                g[i][k][j]=false;
            }
        }
    }
    serverList.clear();
    CM = CM_in;
    CPUSUM = CPUSUM_in;
    MEMSUM = MEMSUM_in;

    list<Flavor> flavorList;
    InitialFlavorList(flavorList);
    //int a[15] = { 6, 1, 6, 3, 9, 9, 0, 59, 8, 2, 11, 0, 1, 16, 0 };
    list<BagItem> bagItemList = PreTreatment(flavorList, a);
    /*for each (auto var in  bagItemList)
    {
        cout << var.flavor << "\t" << var.num << endl;
    }*/
//  list<PhysicalServer> serverList;
    serverList = GetPhysicalServerList(bagItemList, serverList);
    double cpurate = 0;
    double memrate = 0;
    int m = 0;
    list<PhysicalServer>::iterator it;
    //cout<<"hhhhhh"<<endl;
    for(it = serverList.begin(); it != serverList.end(); it++)// each (auto server in serverList)
    {
        //PhysicalServer server = *it;
        m++;
        //cout << server.num << ":" << endl;
        int n = 0;
        int cpuu = 0;
        int mem = 0;
        list<BagItem>::iterator it2;
        for (it2 = (*it).flavorList.begin(); it2 != (*it).flavorList.end(); it2++)
        {
            list<BagItem>::iterator it20 = it2;
            it20++;
            while ((it20 != (*it).flavorList.end()) && ((*it20).flavor == (*it2).flavor))//(flavor.flavor == (*it2).flavor)
            {
                (*it2).num++;
                it20 = (*it).flavorList.erase(it20);
            }
            //cout << (*it2).flavor << "\t" << (*it2).num << endl;
            n += (*it2).num;
            cpuu += (*it2).CPUWeight * (*it2).num;
            mem += (*it2).memoryWeight * (*it2).num;
        }

        double cp = cpuu*1.0 / CPUSUM;
        double me = mem*1.0 / MEMSUM;
        cpurate = cpurate + cp;
        memrate = memrate + me;
        //cout << n << "\t" << cp << "\t" << me << endl;
        //cout << endl;
    }

    cout << cpurate / m  << "\t" << memrate/m <<  endl;
    //char c;
    //c = getchar();

    
    vector<double> score2 = mend(serverList, a, CM_in, CPUSUM_in, MEMSUM_in);
    //  vector<double> score2;
    // score2.push_back(cpurate / m);
    // score2.push_back(memrate / m );
    return score2;
}
258.【华为OD机试】部门人力分配（二分搜索-Java&Python&C++&JS实现）
一键难忘的博客
02-17 3515
【华为OD机试】部门人力分配（二分搜索-Java&Python&C++&JS实现） 部门在进行需求开发时需要进行人力安排。当前部门需要完成 N 个需求，需求用 requirements[i] 表示，requirements[i] 表示第 i 个需求的工作量大小，单位：人月。这部分需求需要在 M 个月内完成开发，进行人力安排后每个月的人力是固定的。 目前要求每个月最多有 2 个需求开发，并且每个月需要完成的需求不能超过部门人力。请帮部门评估在满足需求开发进度的情况下，每个月需要的最小人力是多少？
260.【华为OD机试】信道分配（贪心算法-Java&Python&C++&JS实现）
一键难忘的博客
02-18 4517
【华为OD机试】信道分配（贪心算法-Java&Python&C++&JS实现） 算法工程师小明面对着这样一个问题 ，需要将通信用的信道分配给尽量多的用户:\n\n信道的条件及分配规则如下: 1)所有信道都有属性:”阶”。阶为 r的信道的容量为 2^r比特; 2)所有用户需要传输的数据量都一样:D比特; 3)一个用户可以分配多个信道，但每个信道只能分配给一个用户; 4)只有当分配给一个用户的所有信道的容量和>=D，用户才能传输数据;
二维完全背包
Sleppypot的博客
09-18 2042
题目：hdu2159 题意：xhd升掉最后一级还需n的经验值，xhd还留有m的忍耐度，每杀一个怪xhd会得到相应的经验，并减掉相应的忍耐度。当忍耐度降到0或者0以下时，xhd就不会玩这游戏。xhd还说了他最多只杀s只怪。请问他能升掉这最后一级吗。 解答：把忍耐度看成容量，经验值看成是价值。由于限制了放入物品的个数，所以这是一个二维的完全背包问题。dp[j][w]表示用了j的忍耐值、杀了w个怪的
C++算法 —— 动态规划（10）二维费用背包
kongqizyd146的博客
10-04 234
动态规划（11），二维背包：一和零，盈利计划
二维背包问题（C++）
最新发布
lim6ere的博客
09-11 469
二维背包问题和基础背包问题的解题思路是一样的，唯一不同的就是二维背包是有两个限制条件，而一维背包只有一个限制条件。以上就是今天要讲的内容，本文仅仅详细介绍了。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 算法篇 动态规划----背包之六 二维费用背包
流年的博客
09-15 2359
二维费用背包 二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为c[i]。 算法 　　费用加了一维，只需状态也加一维即可。设f[i][v][u]表示前i件物品付出两种代价分别为v和u时可获得的最大价值。 　　状态转移方程就是：f [i]
有一个人前来买瓜 | C++ | 二维背包问题
m0_70241024的博客
09-05 1815
具体的循环过程是这样的，对每一个瓜，我扫描所有的重量和成熟度的组合，如果dp[ j ][ k ]有价值，我就可以考虑进行转移，转移情况有两种，即买这个瓜和不买这个瓜，因此转移方程为dp[ j+w[i] ] [ k+v[i] ] = max( dp[j][k]+g[i] , dp[ j+w[i] ] [ k+v[i] ])。接下来n行，每行三个整数，第i行的三个整数为wi,vi,gi(1≤wi,vi,gi≤100)，分别代表第i个瓜的重量，成熟度和价值。具体过程去课本上或者网络上一搜便是，也不难，不多赘述。
2019华为软件精英挑战赛C++ 源码实现
03-17
2019华为软件精英挑战赛C++源码，主要是实现了类的定义与数据的读取。
C语言编程规范（华为软件精英挑战赛）
onephone的专栏
03-12 4575
原文链接: http://codeshold.me/2017/03/c_programming_specification.html 参加华为软件精英挑战赛，复习了下基本的C语言编程规范，并做了小结！
遗传算法解决多维背包问题（java代码）
12-17
用遗传算法解决多维背包问题，采用java代码。用遗传算法解决多维背包问题，采用java代码用遗传算法解决多维背包问题，采用java代码用遗传算法解决多维背包问题，采用java代码。
二维背包问题
chx
08-07 1156
二维背包问题  一 问题描述：   二维费用的背包问题是指：   对于每件物品，具有两种不同的费用；   选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。   问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，   第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[
c++二维费用的背包问题（模版）
2301_76180325的博客
07-21 162
C++二维费用的背包问题是一个经典的动态规划问题，解决的是在给定容量和价值的情况下，如何选择一定数量的物品来最大化总价值的问题。但是，与一维背包问题不同的是，二维费用的背包问题中每个物品都有两个与之关联的费用，因此需要在二维数组中存储状态。求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。第一行三个整数，N,V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。
0-1背包问题（二维，滚动数组，一维）（c++）
qtmatt的博客
07-27 458
#include<iostream> using namespace std; /*const int N=1010; int f[N][N]; int n,m; int v[N],w[N]; int main()//二维数组，这个应该都会； { cin>>n>>m; for(int i=1;i<=n;i++)cin>>v[...
二维背包问题 + 代码模板
sinat_AQ的博客
05-22 2924
 二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[i]。 算法 费用加了一维，只需状态也加一维即可。设f[i]
1086超市购物（分组背包）
weixin_30416497的博客
07-21 170
1086: 超市购物 Time Limit: 1 Sec Memory Limit: 128 MB SUBMIT: 122 Solved: 48 [SUBMIT][STATUS] Description 上次去超市扫荡回来的东西用完了,Staginner又得跑超市一趟，出发前他列了一张购物清单，打算去买K种不同的商品,每种买一件。到了超市，Staginner发现每...
多维费用的01背包，杭电4501（C/C++)
weixin_44756457的博客
03-26 509
hdu.4501题目链接 题目如下： 这种背包问题是第一次见到，它又不同于二维费用背包（二维费用背包两维费用同时消费），这个可以选择消费钱，积分或者使用免费兑换的机会，因此需要比较每种情况下的解，找出最优的那个。由于数据量小，直接四重循环（我也只会四重循环…） AC代码:(含注解） #include<cstdio> #include<cstring> #include&...
二维背包
xuelanghu407
11-14 685
hdu_3496_Watch The Movie http://acm.hdu.edu.cn/showproblem.php?pid=3496
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值