HDU

原题链接

题意：

有 $m$ 台机器，一台机器同一时刻只能够做一个任务，任务可以被中断并给另一个空闲的机器去完成；

现在有 $n$ 个任务，每个任务有 $Pi , si , ei $, 分别表示该任务完成所需要的  任务量，开始时间，截止时间；

问  是否能够在规定时间内完成所有任务。

思路：

设定 $S = 0$ 为超级源点，将 $S$ 与每一个任务点相连，流量为$P[i]$，每个任务点与其 $si$ 到 $ei$ 范围内相连，流量为1，最后将所有任务的时间区间与 $T$ 相连，流量为 $m$；

跑一遍最大流之后判断是否大于  $sum_{i=1}^{n} Pi $，若大于等于，则能够完成所给的任务，反之则不能。  感觉是一道比较好的网络流入门题目

/*
* @Author: WindyStreet
* @Date:   2018-07-31 16:00:05
* @Last Modified by:   WindyStreet
* @Last Modified time: 2018-07-31 19:14:55
*/
#include<bits/stdc++.h>

using namespace std;

#define X first
#define Y second
#define eps  1e-2
#define gcd __gcd
#define pb push_back
#define PI acos(-1.0)
#define lowbit(x) (x)&(-x)
#define bug printf("!!!!!
");
#define mem(x,y) memset(x,y,sizeof(x))

typedef long long LL;
typedef long double LD;
typedef pair<int,int> pii;
typedef unsigned long long uLL;

const int maxn = 1e3+2;
const int INF  = 1<<30;
const int mod  = 1e9+7;

struct Edge{
     int from,to,cap,flow;
};
struct node
{
    int p,s,e;
}s[maxn];

struct Dinic
{
    int n,m,s,t;
    vector<Edge>edge;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];
    void init(int n){
        this->n = n;
        for(int i=0;i<=n;i++)G[i].clear(),edge.clear();
    }
    void addedge(int from,int to,int cap){
        edge.pb((Edge){from,to,cap,0});
        edge.pb((Edge){to,from,0,0});
        m = edge.size();
        G[from].pb(m-2);
        G[to].pb(m-1);
    }
    bool bfs(){
        mem(vis,0);
        queue<int>Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while(!Q.empty()){
            int x = Q.front(); Q.pop();
            int sz = G[x].size();
            for(int i=0;i<sz;++i){
                Edge &e = edge[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow){
                    vis[e.to] = 1 ;
                    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;
        int sz = G[x].size();
        for(int &i = cur[x];i<sz;i++){
            Edge &e = edge[G[x][i]];
            if(d[x] + 1 == d[e.to] && (f = dfs(e.to,min(a,e.cap - e.flow)))>0){
                e.flow += f;
                edge[G[x][i]^1].flow -=f;
                flow += f;
                a -= f;
                if(a==0)break;
            }
        }
        if(!flow) d[x] = -2;
        return flow;
    }
    int maxflow(int s,int t){
        this->s = s; this -> t = t;
        int flow = 0;
        while(bfs()){
            mem(cur,0);
            flow += dfs(s,INF);
        }
        return flow;
    }
};

void solve(){
    int n,m,len = -1,st = 0,ed = 1001,sum = 0;
    Dinic dinic;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&s[i].p,&s[i].s,&s[i].e);    
        len = max(len,s[i].e);                            // 记录最大的时间
        sum += s[i].p;
        dinic.addedge(st,i,s[i].p);                        // 将 S 与每个任务点相连
        for(int j = s[i].s ;j <= s[i].e;j++ ){
            dinic.addedge(i,j+n,1);                        // 将每个任务点与其相对应的时间区间相连
        }
    }
    for(int i = 1;i<=len;i++)
    {
        dinic.addedge(i+n,ed,m);                        // 将所有的时间区间与 T汇点相连
    }
    int ans = dinic.maxflow(st,ed);
    if(sum<=ans){                                         // 判断最大流是否大于等于所需时间
        printf("Yes

");
    }else{
        printf("No

");
    }
    return;
}

int main()
{
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
//    ios::sync_with_stdio(false);
    int t = 1,cas = 1;
    scanf("%d",&t);
    while(t--){
        printf("Case %d: ",cas++);
        solve();
    }
    return 0;
}