HDOJ 2883 - kebab 巧妙的构图最大流...

                 题意:

                          卖烧烤..一次最多烤M个羊肉串..每个顾客有四个值si (到达的时间), ni (需要的羊肉串数量), ei (离开的时间) and ti (烤一个羊肉串的时间)...问能否让所有的顾客都满足要求...

                 题解:

                          官方题解: 将所有的到达时间和结束时间按升序排序，得到 x <= 2n-1 个时间区间。建立网络流模型：s为源，t为汇，每个顾客i作为一个结点并连边（s, i, ni*ti），每个区间j作为一个结点并连边(j, t, (ej-sj)*M)，其中sj, ej分别表示区间j的起始时间和终止时间。对任意顾客i和区间j，若 [sj, ej] 完全包含在 [si, ei] 之中，则连边(i, j, INF)。若最大流等于 ∑ni*ti 则是 Yes，否则是 No。

                           大神题解:

                                            s为源，t为汇，

                                             每个顾客i作为一个结点并连边（s, i, ni*ti）

                                             每个区间j作为一个结点并连边(j, t, (ej-sj)*M)，其中sj, ej分别表示区间j的起始时间和终止时间

                                             对任意顾客i和区间j，若 [sj, ej] 完全包含在 [si, ei] 之中，则连边(i, j, INF)

                                             若最大流等于 ∑ni*ti 则是 Yes，否则是 No。

                             我的理解:

                                              这题和HDOJ 3572没什么区别吧...这里要用区间来做的主要原因我觉得就是时间跨度太长..而时间段较少..所以做了一个转化...

Program:

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#define MAXN 2005
#define MAXM 200005
#define oo 1000000007
#define ll long long
using namespace std;   
struct node
{
      int s,e; 
}H[MAXN];
int P[MAXN];
struct Dinic  
{  
      struct node   
      {  
             int x,y,c,next;  
      }line[MAXM];     
      int Lnum,_next[MAXN],dis[MAXN];  
      void initial(int n)   
      {  
             for (int i=0;i<=n;i++) _next[i]=-1;  
             Lnum=-1;  
      }   
      void addline(int x,int y,int c)  
      {  
             line[++Lnum].next=_next[x],_next[x]=Lnum;  
             line[Lnum].x=x,line[Lnum].y=y,line[Lnum].c=c;  
             line[++Lnum].next=_next[y],_next[y]=Lnum;  
             line[Lnum].x=y,line[Lnum].y=x,line[Lnum].c=0;               
      }  
      bool BFS(int s,int e)  
      {   
             queue<int> Q;  
             while (!Q.empty()) Q.pop();  
             memset(dis,0,sizeof(dis));  
             dis[s]=1;  
             Q.push(s);  
             while (!Q.empty())  
             {  
                   int h,k;  
                   h=Q.front(),Q.pop();  
                   if (h==e) return dis[e];  
                   for (k=_next[h];k!=-1;k=line[k].next)  
                      if (line[k].c && !dis[line[k].y])  
                         dis[line[k].y]=dis[h]+1,Q.push(line[k].y);                   
             }   
             return false;  
      }  
      int dfs(int x,int flow,int e)    
      {       
             if (x==e) return flow;     
             int temp,cost=0;    
             for (int k=_next[x];k!=-1;k=line[k].next)    
             if (line[k].c && dis[line[k].y]==dis[x]+1)    
             {    
                    temp=dfs(line[k].y,min(flow-cost,line[k].c),e);     
                    if (temp)    
                    {    
                           line[k].c-=temp,line[k^1].c+=temp;    
                           cost+=temp;    
                           if (flow==cost) return cost;    
                    }else dis[line[k].y]=-1;    
             }    
             return cost;    
      }    
      int MaxFlow(int s,int e)  
      {  
             int MaxFlow=0;  
             while (BFS(s,e)) 
                MaxFlow+=dfs(s,oo,e);   
             return MaxFlow;  
      }  
}T;   
int main()
{  
      int n,m,N,i,j,sum,S,E; 
      while (~scanf("%d%d",&n,&m))
      { 
                S=2000,E=S+1,T.initial(E),sum=N=0;
                for (i=1;i<=n;i++)
                {
                       int ni,ti; 
                       scanf("%d%d%d%d",&H[i].s,&ni,&H[i].e,&ti);
                       sum+=ni*ti;
                       T.addline(S,i,ni*ti);  
                       P[++N]=H[i].s,P[++N]=H[i].e;
                }
                sort(P+1,P+1+N);
                for (i=1;i<N;i++) T.addline(i+n,E,(P[i+1]-P[i])*m);
                for (i=1;i<=n;i++)
                   for (j=1;j<N;j++)
                      if (H[i].s<=P[j] && P[j+1]<=H[i].e)
                         T.addline(i,j+n,oo);
                if (T.MaxFlow(S,E)==sum) printf("Yes\n");
                                   else  printf("No\n"); 
      }      
      return 0;
}