网络流：HDU 2883

HDU 2883

hdu 2883

Sample Input
2 10
1 10 6 3
2 10 4 2

2 10
1 10 5 3
2 10 4 2

Sample Output
Yes
No

题意：一个n和m，表示有n个客户，m个烤架。下面有n行每行四个输入，si，ni，ti，ei，客户si时刻到达，ei时刻离开，他需要ni串烤串，每串烤串需要ti的时间来烤。最后问你能否找出一个烤的顺序，可以在客户要求的时间内完成所有客户的需求。可以输出Yes，不行则输出No。

偷看这个大佬的
解题思路：偷偷偷，大概讲一下，对输入的时间点进行排序去重，然后用相邻的两个时间构成的区间和客户建点，我们可以转化一下这个任务的要求，本来是说烤肉的串数，我们可以转化成需要花费的工作量，那么一个区间内最多能花费的工作量就是时间m，一个客户要求的工作量就是niti，以这个为流量，我们对于每个客户，遍历我们整理好的时间区间，如果客户的时间区间包含这个区间，那么就可以在这个时间区间里来做客户要求的任务，既建一条流量为niti或者inf的边。源点和客户建边流量为niti，时间区间向汇点建边流量为时间*m。然后跑最大流看看是不是满流就可以了。

完整代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=405;
const int inf=0x3f3f3f3f;
struct Edge{
    int u,v,c;
    int next;
}edge[maxn*maxn];
int n,m;
int edn;//边数
int head[maxn*maxn],dis[maxn*maxn];
int sp,tp;//原点，汇点

void addedge(int u,int v,int c)
{
    edge[edn].u=u; edge[edn].v=v; edge[edn].c=c;
    edge[edn].next=head[u]; head[u]=edn++;

    edge[edn].u=v; edge[edn].v=u; edge[edn].c=0;
    edge[edn].next=head[v]; head[v]=edn++;
}
int bfs()
{
    queue <int> q;
    memset(dis,-1,sizeof(dis));
    dis[sp]=0;
    q.push(sp);
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        for(int i=head[cur];i!=-1;i=edge[i].next)
        {
            int u=edge[i].v;
            if(dis[u]==-1 && edge[i].c>0)
            {
                dis[u]=dis[cur]+1;
                q.push(u);
            }
        }
    }
    return dis[tp] != -1;
}
int dfs(int a,int b)
{
    int r=0;
    if(a==tp)return b;
    for(int i=head[a];i!=-1 && r<b;i=edge[i].next)
    {
        int u=edge[i].v;
        if(edge[i].c>0 && dis[u]==dis[a]+1)
        {
            int x=min(edge[i].c,b-r);
            x=dfs(u,x);
            r+=x;
            edge[i].c-=x;
            edge[i^1].c+=x;
        }
    }
    if(!r)dis[a]=-2;
    return r;
}

int dinic(int sp,int tp)
{
    int total=0,t;
    while(bfs())
    {
        while(t=dfs(sp,inf))
        total+=t;
    }
    return total;
}
int s[maxn];
int e[maxn];
int ti[maxn];
int ni[maxn];
int a[maxn];
int cnt;
int main()
{
    int i,u,v,c;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        edn=0,cnt=0;//初始化
        memset(head,-1,sizeof(head));
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&s[i],&ni[i],&e[i],&ti[i]);
            a[++cnt]=s[i];
            a[++cnt]=e[i];
            sum+=(ni[i]*ti[i]);
        }
        sort(a+1,a+1+cnt);
        cnt=unique(a+1,a+1+cnt)-a-1;
        sp=0,tp=n+cnt+1;
        for(int i=1;i<=n;i++)
        {
            addedge(sp,i,ni[i]*ti[i]);
        }
        for(int i=1;i<cnt;i++)
        {
            addedge(n+i,tp,(a[i+1]-a[i])*m);
            for(int j=1;j<=n;j++)
            {
                if(e[j]>=a[i+1]&&s[j]<=a[i])
                {
                    addedge(j,n+i,(a[i+1]-a[i])*m);
                }
            }
        }
        int ans=dinic(sp,tp);
        if(ans==sum)
            printf("Yes\n");
        else
            printf("No\n");
    }


    return 0;
}