hdu 2883 kebab (最大流 + 建图)

kebab

Problem Description

Almost everyone likes kebabs nowadays (Here a kebab means pieces of meat grilled on a long thin stick). Have you, however, considered about the hardship of a kebab roaster while enjoying the delicious food? Well, here's a chance for you to help the poor roaster make sure whether he can deal with the following orders without dissatisfying the customers.

Now N customers is coming. Customer i will arrive at time si (which means the roaster cannot serve customer i until time si). He/She will order ni kebabs, each one of which requires a total amount of ti unit time to get it well-roasted, and want to get them before time ei(Just at exactly time ei is also OK). The roaster has a big grill which can hold an unlimited amount of kebabs (Unbelievable huh? Trust me, it’s real!). But he has so little charcoal that at most M kebabs can be roasted at the same time. He is skillful enough to take no time changing the kebabs being roasted. Can you help him determine if he can meet all the customers’ demand?

Oh, I forgot to say that the roaster needs not to roast a single kebab in a successive period of time. That means he can divide the whole ti unit time into k (1<=k<=ti) parts such that any two adjacent parts don’t have to be successive in time. He can also divide a single kebab into k (1<=k<=ti) parts and roast them simultaneously. The time needed to roast one part of the kebab well is linear to the amount of meat it contains. So if a kebab needs 10 unit time to roast well, he can divide it into 10 parts and roast them simultaneously just one unit time. Remember, however, a single unit time is indivisible and the kebab can only be divided into such parts that each needs an integral unit time to roast well.

 

Input

There are multiple test cases. The first line of each case contains two positive integers N and M. N is the number of customers and M is the maximum kebabs the grill can roast at the same time. Then follow N lines each describing one customer, containing four integers: si (arrival time), ni (demand for kebabs), ei (deadline) and ti (time needed for roasting one kebab well). 

There is a blank line after each input block.

Restriction:
1 <= N <= 200, 1 <= M <= 1,000
1 <= ni, ti <= 50
1 <= si < ei <= 1,000,000

 

Output

If the roaster can satisfy all the customers, output “Yes” (without quotes). Otherwise, output “No”.

 

题目大意：有n个人来烧烤店点烤串，每个烤串需要花 ti 的时间，注意烤串可以拆开再合并的，但是每一个时刻他只能处理m个烤串，每个顾客来的时间是 ( si - ei ]，问能不能满足所有顾客的要求。

解题思路：根据上一道网络流 hdu 3572 可以很容易想到这道题的建图思路，将人和时间分别建图，设一个超级源点往每个人连边，然后每个人往 (si,ei] 这个时间区间里面连边，最后每个时间点往超级汇点连边。但是要注意一点这道题的时间比较大，所以需要将时间离散化，分成一个一个时间段，可以证明这样的时间段是不多于400个的。这样的节点数量和边的数量可以保证 dinic 算法是可行的。具体的边权如果思考一下也并不难。

AC代码：

/*
* @Author: wchhlbt
* @Last Modified t: 2017-10-17
*/
#include <bits/stdc++.h>

#define inf 0x3f3f3f3f
#define pb push_back
#define AA first
#define BB second
#define ONES(x) __builtin_popcount(x)
#define _  << "  " <<
using namespace std;

typedef pair<int, int> P;
typedef long long ll ;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
const double eps =1e-8;
const int mod = 1000000007;
const double PI = acos(-1.0);
inline int read(){ int num;    scanf("%d",&num);   return num;}
const int maxn = 1000;

int n,m;
int ss[maxn],ee[maxn],nn[maxn],tt[maxn];
/*
    最大流Dinic算法
    使用前调用init函数
*/
struct Edge
{
    int from,to,cap,flow;
    Edge(){}
    Edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int cur[maxn];
    int d[maxn];

    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        for(int i=0;i<n;++i) G[i].clear();
    }

    void AddEdge(int from,int to,int cap)
    {
        edges.push_back( Edge(from,to,cap,0) );
        edges.push_back( Edge(to,from,0,0) );
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        queue<int> Q;
        memset(vis,0,sizeof(vis));
        vis[s]=true;
        d[s]=0;
        Q.push(s);
        while(!Q.empty())
        {
            int x=Q.front(); Q.pop();
            for(int i=0;i<G[x].size();++i)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow)
                {
                    vis[e.to]=true;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t || a==0) return a;
        int flow=0, f;
        for(int &i=cur[x];i<G[x].size();++i)
        {
            Edge &e=edges[G[x][i]];
            if(d[e.to]==d[x]+1 && ( f=DFS(e.to,min(a,e.cap-e.flow) ) )>0)
            {
                e.flow +=f;
                edges[G[x][i]^1].flow -=f;
                flow +=f;
                a -=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int max_flow()
    {
        int ans=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            ans += DFS(s,inf);
        }
        return ans;
    }
}dinic;

int t[2*maxn];

int main()
{
    //ios::sync_with_stdio(false);    cin.tie(0); 
    while(~scanf("%d%d",&n,&m)){
        int sum = 0,cnt = 0;
        for(int i = 1; i<=n; i++){
            scanf("%d%d%d%d",ss+i,nn+i,ee+i,tt+i);
            sum += (nn[i]*tt[i]);
            t[++cnt] = ss[i];
            t[++cnt] = ee[i];
        }
        sort(t+1,t+cnt+1);
        int c = 0;
        for(int i = 1; i<=cnt; i++){ //把每一个时间段当作一个节点
            if(t[i]!=t[c])
                t[++c] = t[i];
        }
        int to = n + c + 1;//终点编号
        dinic.init(n+c+2,0,to);
        for(int i = 1; i<=n; i++){
            dinic.AddEdge(0,i,nn[i]*tt[i]);
        }
        for(int i = 1; i<=c; i++){
            dinic.AddEdge(n+i,to,m*(t[i]-t[i-1]));//每个时间段往终点连边
            for(int j = 1; j<=n; j++){
                if(ss[j]<=t[i-1] && t[i]<=ee[j])
                    dinic.AddEdge(j,n+i,inf);//每个人往时间段连边
            }
        }
        int full_flow = dinic.max_flow();
        if(full_flow==sum)  puts("Yes");
        else    puts("No");

    }    
    return 0;
}

/*

unsigned   int   0～4294967295
int   2147483648～2147483647
unsigned long 0～4294967295
long   2147483648～2147483647
long long的最大值：9223372036854775807
long long的最小值：-9223372036854775808
unsigned long long的最大值：18446744073709551615

__int64的最大值：9223372036854775807
__int64的最小值：-9223372036854775808
unsigned __int64的最大值：18446744073709551615

*/