hdu 3572 资源分配

资源分配，每个时间点有m个机器可用，要将这资源分配给n个任务中的一些，要求每个任务在自己的时间范围中被分配了p[i]个资源，建图：

建立源，与每个时间点连边，容量为m，每个任务向其对应的时间段中的每个时间点连边，容量1，每个任务向汇连边，容量为该任务需要的时间。

收获：

　　本题中的有：任务，时间，机器三个对象，但第三个对象是无区别的，所以它的限制就用容量表示，而其它对象都是不同的，所以要用点。

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 #define maxn 1010
 #define oo 0x3f3f3f3f
 using namespace std;

 struct Edge {
     int u, v, f;
     Edge( int u, int v, int f ):u(u),v(v),f(f){}
 };
 struct Dinic {
     int n, src, dst;
     vector<Edge> edge;
     vector<int> g[maxn];
     int dep[maxn], cur[maxn];

     void init( int n, int src, int dst ) {
         this->n = n;
         this->src = src;
         this->dst = dst;
         for( int u=; u<=n; u++ )
             g[u].clear();
         edge.clear();
     }
     void add_edge( int u, int v, int f ) {
         g[u].push_back( edge.size() );
         edge.push_back( Edge(u,v,f) );
         g[v].push_back( edge.size() );
         edge.push_back( Edge(v,u,) );
     }
     bool bfs() {
         queue<int> qu;
         memset( dep, , sizeof(dep) );
         qu.push(src);
         dep[src] = ;
         while( !qu.empty() ) {
             int u=qu.front();
             qu.pop();
             for( int t=; t<g[u].size(); t++ ) {
                 Edge &e=edge[g[u][t]];
                 if( e.f && !dep[e.v] ) {
                     dep[e.v] = dep[e.u]+;
                     qu.push( e.v );
                 }
             }
         }
         return dep[dst];
     }
     int dfs( int u, int a ) {
         if( u==dst || a== ) return a;
         int past=, remain=a, na;
         for( int &t=cur[u]; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]];
             Edge &ve = edge[g[u][t]^];
             if( dep[e.v]==dep[u]+ && e.f && (na=dfs(e.v,min(remain,e.f))) ) {
                 remain -= na;
                 past += na;
                 e.f -= na;
                 ve.f += na;
                 if( remain== ) break;
             }
         }
         return past;
     }
     int maxflow() {
         int mf = ;
         while( bfs() ) {
             memset( cur, , sizeof(cur) );
             mf += dfs(src,oo);
         }
         return mf;
     }
 };

 int n, m;
 int p[maxn], s[maxn], t[maxn], maxd, sum;
 Dinic D;

 int main() {
     int T;
     scanf( "%d", &T );
     for( int cas=; cas<=T; cas++ ) {
         scanf( "%d%d", &n, &m );
         maxd = sum = ;
         for( int i=; i<=n; i++ ) {
             scanf( "%d%d%d", p+i, s+i, t+i );
             maxd = max( t[i], maxd );
             sum += p[i];
         }
         D.init( n+maxd+, n+maxd+, n+maxd+ );
         for( int i=; i<=n; i++ ) {
             D.add_edge( D.src, i, p[i] );
             for( int d=s[i]+n; d<=t[i]+n; d++ )
                 D.add_edge( i, d,  );
         }
         for( int d=n+; d<=n+maxd; d++ )
             D.add_edge( d, D.dst, m );
         bool ok = D.maxflow()==sum;
         printf( "Case %d: %s\n\n", cas, ok ? "Yes" : "No" );
     }
 }