HDU 6408 From ICPC to ACM（贪心+map）

最新推荐文章于 2021-07-26 16:50:33 发布

v5zsq

最新推荐文章于 2021-07-26 16:50:33 发布

阅读量513

点赞数

CC 4.0 BY-SA版权

分类专栏： HDU 贪心杂题

本文链接：https://blog.youkuaiyun.com/V5ZSQ/article/details/82632940

HDU 同时被 3 个专栏收录

803 篇文章

订阅专栏

杂题

256 篇文章

订阅专栏

贪心

142 篇文章

订阅专栏

本文介绍了一种用于解决工厂生产调度问题的算法，旨在通过合理的原料采购和产品存储策略，在满足顾客需求的同时，实现最小化的成本开支。算法考虑了原料价格波动、产品生产成本、存储费用等因素，并提供了一个具体的实现方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

一个工厂要供应顾客 $k$ 个月的需求，第 $i$ 个月工厂买入原料的代价为 $c_i$ ，一份材料可以生产一台电脑，工本费为 $m_i$ ，产量至多为 $p_i$ ，而顾客需求量为 $d_i$ ，第 $i$ 个月生产出的电脑和买的原料可以存储起来，存储一台电脑一个月的租金为 $E_i$ ，储存一份原料一个月的租金为 $R_i$ ，仓库可以储存无限的材料，但是至多只能储存 $e_i$ 电脑到下一个月，问满足顾客所有需求的前提下所需要的最小代价

Input

第一行一整数 $T$ 表示用例组数，每组用例首先输入一整数 $k$ 表示要满足需求的月数，之后 $k$ 行每行输入四个整数 $c_i,d_i,m_i,p_i$ ，最后 $k-1$ 行每行输入三个整数 $e_i,R_i,E_i$

$(1\le T\le 200,2\le k\le 50000,0\le c_i,d_i,m_i,p_i\le 10^4,0\le e_i\le 10^8,0\le R_i,E_i\le 10^4)$

Output

输出最小代价，如果无法满足顾客需求则输出 $-1$

Sample Input

2
2
10 5 3 6
15 7 2 8
2 3 2
2
0 8 0 7
0 0 0 0
0 0 0

Sample Output

170
-1

Solution

由于原料不限购且可以无限存储，故每次必然贪心的选取价格最低的原料，即第 $i$ 天的原料价格为 $min(c_j+\sum\limits_{k=j}^{i-1}R_k,1\le j\le i)$ ，对于电脑，可以先把每天可以生产的量都生产出来，每次选取其中成本最低的电脑出售，而当仓库容量有限制时就将成本最贵的电脑丢弃，由于存储电脑仓库每天的租金不同，可以首先让第 $i$ 天成产的电脑价成本为 $m_i+min(c_j+\sum\limits_{k=j}^{i-1}R_k,1\le j\le i)-\sum\limits_{j=1}^{i-1}E_j$ ，即先给该电脑交前 $i-1$ 天的租金，第 $i$ 天卖电脑时再给补上 $\sum\limits_{j=1}^{i-1}E_j$ 的租金即可，可以用 $map$ 维护每种成本电脑的数量，注意首先要提前判断产量是否能够跟得上需求，如果跟不上需求直接输出 $-1$ 即可

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
namespace fastIO 
{
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror=0;
    inline char nc() 
    {
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if(p1==pend) 
        {
            p1=buf;
            pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if(pend==p1) 
            {
                IOerror=1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) 
    {
        return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';
    }
    inline void read(int &x) 
    {
        char ch;
        while(blank(ch=nc()));
        if(IOerror)return;
        int sgn=1;
        if(ch=='-')sgn=-1;
        for(x=ch-'0';(ch=nc())>='0'&&ch<='9';x=x*10+ch-'0');
        x=sgn*x;
    }
    #undef BUF_SIZE
};
using namespace fastIO;
typedef long long ll;
typedef pair<int,int>P;
#define maxn 50005
int T,k,c[maxn],d[maxn],m[maxn],p[maxn],e[maxn],R[maxn],E[maxn];
map<int,int>M;
map<int,int>::iterator it;
int main()
{
    read(T);
    while(T--)
    {
        read(k);
        for(int i=1;i<=k;i++)
        {
            read(c[i]);read(d[i]);read(m[i]);read(p[i]);
        }
        for(int i=1;i<k;i++)
        {
            read(e[i]);read(R[i]);read(E[i]);
            E[i]+=E[i-1];
        }
        int flag=1;
        int res=0;
        for(int i=1;i<=k;i++)
        {
            res+=p[i];
            if(res<d[i])
            {
                flag=0;
                break;
            }
            res-=d[i];
            res=min(res,e[i]);
        }
        if(!flag)
        {
            printf("-1\n");
            continue;
        }
        for(int i=2;i<=k;i++)c[i]=min(c[i],c[i-1]+R[i-1]);
        M.clear();
        ll ans=0;
        int sum=0;
        for(int i=1;i<=k;i++)
        {
            M[m[i]+c[i]-E[i-1]]+=p[i];
            sum+=p[i]-d[i];
            while(d[i])
            {
                it=M.begin();
                if(it->second<=d[i])
                {
                    ans+=(ll)(it->first+E[i-1])*(it->second);
                    d[i]-=it->second;
                    M.erase(it);
                }
                else
                {
                    ans+=(ll)(it->first+E[i-1])*d[i];
                    M[it->first]-=d[i];
                    d[i]=0;
                }
            }
            if(sum<=e[i])continue;
            int temp=sum-e[i];
            sum=e[i];
            while(temp)
            {
                it=M.end();
                it--;
                if(it->second<=temp)
                {
                    temp-=it->second;
                    M.erase(it); 
                }
                else
                {
                    M[it->first]-=temp;
                    temp=0;
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}