HDU 3572 Task Schedule (最大流)

C - Task Schedule

Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64u

Description

Our geometry princess XMM has stoped her study in computational geometry to concentrate on her newly opened factory. Her factory has introduced M new machines in order to process the coming N tasks. For the i-th task, the factory has to start processing it at or after day Si, process it for Pi days, and finish the task before or at day Ei. A machine can only work on one task at a time, and each task can be processed by at most one machine at a time. However, a task can be interrupted and processed on different machines on different days.
Now she wonders whether he has a feasible schedule to finish all the tasks in time. She turns to you for help.

Input

On the first line comes an integer T(T<=20), indicating the number of test cases.

You are given two integer N(N<=500) and M(M<=200) on the first line of each test case. Then on each of next N lines are three integers Pi, Si and Ei (1<=Pi, Si, Ei<=500), which have the meaning described in the description. It is guaranteed that in a feasible schedule every task that can be finished will be done before or at its end day.

Output

For each test case, print “Case x: ” first, where x is the case number. If there exists a feasible schedule to finish all the tasks, print “Yes”, otherwise print “No”.

Print a blank line after each test case.

Sample Input

2
4 3
1 3 5
1 1 4
2 3 7
3 5 9

2 2
2 1 3
1 2 2

Sample Output

Case 1: Yes

Case 2: Yes

题意：给n个任务和m台机器，每个任务有三个值，s e p表示这个完成这个任务需要p天，并且这p天要在s到e这段时间完成（包括s和e），任务可以中断再换台机器换一天来继续做，每台机器每天只能完成一个任务，而且一个任务每天只能给一台机器来做

思路：最大流。建图方法是，把每个任务当成一个点，每个时间点也当成一个点，源点连接每个任务容量为p，每个任务连接每个时间点容量为1，每个时间点连接汇点容量为m，然后判断最大流是否和p点总和相等

妈蛋啊，这题卡了不少天，还以为是各种模板错了，原来所因为给每个时间点连汇点点时候for循环用i但是下面却用了j我擦擦擦卡勒那么多天，都换了几个模板来做了。。

AC代码： 1.白书dinic模板 2.白书ISAP模板 3.网上的dinic模板 4.网上ISAP模板

1和2跑了350ms 3跑了78ms 4跑了109ms

1. 359ms

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <vector>

#include <queue>

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int INF = 1e9;

const double eps = 1e-;

const int maxn = ;

int cas = ;

struct Edge{

    int from,to,cap,flow;

    Edge() {}

    Edge(int a,int b,int c,int d)

    {

        from=a,to=b,cap=c,flow=d;

    }

};

struct Dinic{

    int n,m,s,t;

    vector<Edge> edges;

    vector<int> G[maxn];

    bool vis[maxn];

    int d[maxn];

    int cur[maxn];

    void AddEdge(int from,int to,int cap)

    {

        edges.push_back(Edge(from,to,cap,));

        edges.push_back(Edge(to,from,,));

        m=edges.size();

        G[from].push_back(m-);

        G[to].push_back(m-);

    }

    void init(int x)

    {

        memset(d,,sizeof(d));

        edges.clear();

        for(int i=;i<=x;i++)

            G[i].clear();

    }

    bool BFS()

    {

        memset(vis,,sizeof(vis));

        queue<int> Q;

        Q.push(s);

        d[s]=;

        vis[s]=;

        while(!Q.empty())

        {

            int x=Q.front(); Q.pop();

            for(int i=;i<G[x].size();i++)

            {

                Edge &e = edges[G[x][i]];

                if(!vis[e.to] && e.cap>e.flow)

                {

                    vis[e.to]=;

                    d[e.to]=d[x]+;

                    Q.push(e.to);

                }

            }

        }

        return vis[t];

    }

    int DFS(int x,int a)

    {

        if(x==t || a==) return a;

        int flow = , f;

        for(int &i=cur[x];i<G[x].size();i++)

        {

            Edge &e=edges[G[x][i]];

            if(d[x]+==d[e.to] && (f=DFS(e.to,min(a,e.cap-e.flow)))>)

            {

                e.flow += f;

                edges[G[x][i]^].flow -= f;

                flow += f;

                a -= f;

                if(a==) break;

            }

        }

        return flow;

    }

    int Maxflow(int s,int t)

    {

        this->s=s; this->t=t;

        int flow = ;

        while(BFS())

        {

            memset(cur,,sizeof(cur));

            flow+=DFS(s,INF);

        }

        return flow;

    }

};

Dinic dinic;

int n,m;

inline int id_task(int x)  {return x;}

inline int id_time(int x)  {return x+;}

int s = , t = ;

void run()

{

    scanf("%d%d",&n,&m);

    dinic.init();

    int i,j;

    int a,b,c;

    int sum=;

    for(i=;i<=n;i++)

    {

        scanf("%d%d%d",&c,&a,&b);

        sum+=c;

        dinic.AddEdge(s,id_task(i),c);

        for(j=a;j<=b;j++)

            dinic.AddEdge(id_task(i),id_time(j),);

    }

    for(i=;i<=;i++)

        dinic.AddEdge(id_time(i),t,m);

//    printf("%d\n",dinic.Maxflow(0,500+500+1));

    printf("Case %d: %s\n\n",cas++,dinic.Maxflow(s,t)==sum?"Yes":"No");

}

int main()

{

    #ifdef LOCAL

    freopen("in","r",stdin);

    #endif

    int _;

    scanf("%d",&_);

    while(_--)

        run();

    return ;

}

2. 343ms

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <vector>

#include <queue>

#define FOR(i,n) for(i=0;i<=(n);i++)

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int INF = 1e9;

const double eps = 1e-;

const int maxn = ;

const int N = ;

int cas = ;

struct Edge{

    int from,to,cap,flow;

    Edge() {}

    Edge(int a,int b,int c,int d)

    {

        from=a,to=b,cap=c,flow=d;

    }

};

struct ISAP{

    int n,m,s,t;

    int p[N],num[N];

    vector<Edge> edges;

    vector<int> G[N];

    bool vis[N];

    int d[N],cur[N];

    void init(int _n)

    {

        n=_n;

        int i;

        edges.clear();

        FOR(i,n)

        {

            G[i].clear();

            d[i]=INF;

        }

    }

    void AddEdge(int from,int to,int cap)

    {

        edges.push_back(Edge(from,to,cap,));

        edges.push_back(Edge(to,from,,));

        m = edges.size();

        G[from].push_back(m-);

        G[to].push_back(m-);

    }

    bool BFS()

    {

        memset(vis,,sizeof(vis));

        queue<int> Q;

        Q.push(t);

        d[t]=;

        vis[t]=;

        while(!Q.empty())

        {

            int x = Q.front(); Q.pop();

            for(unsigned i=;i<G[x].size();i++)

            {

                Edge& e = edges[G[x][i]^];

                if(!vis[e.from] && e.cap>e.flow)

                {

                    vis[e.from]=;

                    d[e.from] = d[x]+;

                    Q.push(e.from);

                }

            }

        }

        return vis[s];

    }

    int Augment()

    {

        int x=t, a=INF;

        while(x!=s)

        {

            Edge& e = edges[p[x]];

            a = min(a,e.cap-e.flow);

            x = edges[p[x]].from;

        }

        x = t;

        while(x!=s)

        {

            edges[p[x]].flow+=a;

            edges[p[x]^].flow-=a;

            x=edges[p[x]].from;

        }

        return a;

    }

    int Maxflow(int _s,int _t)

    {

        s=_s; t=_t;

        int flow = , i;

        BFS();

        if(d[s]>=n) return ;

        memset(num,,sizeof(num));

        memset(p,,sizeof(p));

        FOR(i,n) if(d[i]<INF) num[d[i]]++;

        int x=s;

        memset(cur,,sizeof(cur));

        while(d[s]<n)

        {

            if(x==t)

            {

                flow+=Augment();

                x=s;

            }

            int ok=;

            for(unsigned i=cur[x];i<G[x].size();i++)

            {

                Edge& e=edges[G[x][i]];

                if(e.cap>e.flow && d[x]==d[e.to]+)

                {

                    ok=;

                    p[e.to]=G[x][i];

                    cur[x]=i;

                    x=e.to;

                    break;

                }

            }

            if(!ok)

            {

                int m=n-;

                for(unsigned i=;i<G[x].size();i++)

                {

                    Edge& e=edges[G[x][i]];

                    if(e.cap>e.flow) m=min(m,d[e.to]);

                }

                if(--num[d[x]]==) break;

                num[d[x]=m+]++;

                cur[x]=;

                if(x!=s) x=edges[p[x]].from;

            }

        }

        return flow;

    }

};

ISAP dinic;

int n,m;

inline int id_task(int x)  {return x;}

inline int id_time(int x)  {return x+;}

int s = , t = ;

void run()

{

    scanf("%d%d",&n,&m);

    dinic.init();

    int i,j;

    int a,b,c;

    int sum=;

    for(i=;i<=n;i++)

    {

        scanf("%d%d%d",&c,&a,&b);

        sum+=c;

        dinic.AddEdge(s,id_task(i),c);

        for(j=a;j<=b;j++)

            dinic.AddEdge(id_task(i),id_time(j),);

    }

    for(i=;i<=;i++)

        dinic.AddEdge(id_time(i),t,m);

//    printf("%d\n",dinic.Maxflow(0,500+500+1));

    printf("Case %d: %s\n\n",cas++,dinic.Maxflow(s,t)==sum?"Yes":"No");

}

int main()

{

    #ifdef LOCAL

    freopen("in","r",stdin);

    #endif

    int _;

    scanf("%d",&_);

    while(_--)

        run();

    return ;

}

3. 78ms

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <vector>

#include <queue>

#define FOR(i,n) for(i=0;i<=(n);i++)

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int INF = 0xfffffff;

const double eps = 1e-;

const int N = ;

int cas = ;

const int maxn=;

const int maxm=;

struct edge{

    int v,next,val;

} G[maxm];

int s = , t = ;

struct Dinic{

    int pre[maxn],idx, sum;

    int N,M;

    int level[maxn];

    int gap[maxn];

    void add_edge(int from,int to,int val)

    {

        G[idx].v=to;

        G[idx].val=val;

        G[idx].next=pre[from];

        pre[from]=idx++;

        G[idx].v=from;

        G[idx].val=;

        G[idx].next=pre[to];

        pre[to]=idx++;

    }

    int dfs(int pos,int cost, int cnt)

    {

        if (pos==t)

        {

            return cost;

        }

        int j,minh=cnt-,lv=cost,d;

        for (j=pre[pos];j!=-;j=G[j].next)

        {

            int v=G[j].v,val=G[j].val;

            if(val>)

            {

                if (level[v]+==level[pos])

                {

                    if (lv<G[j].val) d=lv;

                    else d=G[j].val;

                    d=dfs(v,d,cnt);

                    G[j].val-=d;

                    G[j^].val+=d;

                    lv-=d;

                    if (level[s]>=cnt) return cost-lv;

                    if (lv==) break;

                }

                if (level[v]<minh)    minh=level[v];

            }

        }

        if (lv==cost)

        {

            --gap[level[pos]];

            if (gap[level[pos]]==) level[s]=cnt;

            level[pos]=minh+;

            ++gap[level[pos]];

        }

        return cost-lv;

    }

    int Maxflow(int s,int t, int cnt)

    {

        int flow=;

        gap[s]=cnt;

        while (level[s]<cnt)

        {

//            int t=dfs(s,INF,cnt);

            flow+=dfs(s,INF, cnt);

//            flow+=t;

//            cout<<flow<<endl;

        }

        return flow;

    }

    void init()

    {

        memset(pre, -, sizeof(pre));

        memset(gap,,sizeof(gap));

        memset(level,,sizeof(level));

        sum = idx = ;

    }

};

Dinic dinic;

int n,m;

inline int id_task(int x)  {return x;}

inline int id_time(int x)  {return x+;}

void run()

{

    scanf("%d%d",&n,&m);

    dinic.init();

    int i,j;

    int a,b,c;

    int sum=;

    for(i=;i<=n;i++)

    {

        scanf("%d%d%d",&c,&a,&b);

        sum+=c;

        dinic.add_edge(s,id_task(i),c);

        for(j=a;j<=b;j++)

            dinic.add_edge(id_task(i),id_time(j),);

    }

    for(i=;i<=;i++)

        dinic.add_edge(id_time(i),t,m);

//    printf("%d\n",dinic.Maxflow(0,500+500+1));

    printf("Case %d: %s\n\n",cas++,dinic.Maxflow(s,t,t+)==sum?"Yes":"No");

}

int main()

{

    #ifdef LOCAL

    freopen("in","r",stdin);

    #endif

    int _;

    scanf("%d",&_);

    while(_--)

        run();

    return ;

}

4.109ms

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <vector>

#include <queue>

#define FOR(i,n) for(i=0;i<=(n);i++)

using namespace std;

typedef long long ll;

typedef pair<int,int> pii;

const int INF = 1e9;

const double eps = 1e-;

const int maxn = ;

const int N = ;

int cas = ;

const int inf = 0x3fffffff;

template <int N, int M>

struct Isap

{

    int top;

    int d[N], pre[N], cur[N], gap[N];

    struct Vertex{

        int head;

    } V[N];

    struct Edge{

        int v, next;

        int c, f;

    } E[M];

    void init(){

        memset(V, -, sizeof(V));

        top = ;

    }

    void add_edge(int u, int v, int c){

        E[top].v = v;

        E[top].c = c;

        E[top].f = ;

        E[top].next = V[u].head;

        V[u].head = top++;

    }

    void add(int u,int v, int c){

        add_edge(u, v, c);

        add_edge(v, u, );

    }

    void set_d(int t){

        queue<int> Q;

        memset(d, -, sizeof(d));

        memset(gap, , sizeof(gap));

        d[t] = ;

        Q.push(t);

        while(!Q.empty()) {

            int v = Q.front(); Q.pop();

            ++gap[d[v]];

            for(int i = V[v].head; ~i; i = E[i].next) {

                int u = E[i].v;

                if(d[u] == -) {

                    d[u] = d[v] + ;

                    Q.push(u);

                }

            }

        }

    }

    int sap(int s, int t, int num) {

        set_d(t);

        int ans = , u = s;

        int flow = inf;

        memcpy(cur, V, sizeof(V));

        while(d[s] < num) {

            int &i = cur[u];

            for(; ~i; i = E[i].next) {

                int v = E[i].v;

                if(E[i].c > E[i].f && d[u] == d[v] + ) {

                    u = v;

                    pre[v] = i;

                    flow = min(flow, E[i].c - E[i].f);

                    if(u == t) {

                        while(u != s) {

                            int j = pre[u];

                            E[j].f += flow;

                            E[j^].f -= flow;

                            u = E[j^].v;

                        }

                        ans += flow;

                        flow = inf;

                    }

                    break;

                }

            }

            if(i == -) {

                if(--gap[d[u]] == )

                    break;

                int dmin = num - ;

                cur[u] = V[u].head;

                for(int j = V[u].head; ~j; j = E[j].next)

                    if(E[j].c > E[j].f)

                        dmin = min(dmin, d[E[j].v]);

                d[u] = dmin + ;

                ++gap[d[u]];

                if(u != s)

                    u = E[pre[u] ^ ].v;

            }

        }

        return ans;

    }

};

Isap<, > Sap;

//调用方式：

//Sap.init(); //建边前调用

//Sap.add(u, v, c); //在u->v之间建一条容量为c的边

//Sap.sap(s, t, num); //s为源点，t为汇点，num为边的数量

int n,m;

inline int id_task(int x)  {return x;}

inline int id_time(int x)  {return x+;}

int s = , t = ;

void run()

{

    scanf("%d%d",&n,&m);

    Sap.init();

    int i,j;

    int a,b,c;

    int sum=;

    for(i=;i<=n;i++)

    {

        scanf("%d%d%d",&c,&a,&b);

        sum+=c;

        Sap.add(s,id_task(i),c);

        for(j=a;j<=b;j++)

            Sap.add(id_task(i),id_time(j),);

    }

    for(i=;i<=;i++)

        Sap.add(id_time(i),t,m);

//    printf("%d\n",Sap.sap(s,t,t+100));

    printf("Case %d: %s\n\n",cas++,Sap.sap(s,t,t+)==sum?"Yes":"No");

}

int main()

{

    #ifdef LOCAL

    freopen("in","r",stdin);

    #endif

    int _;

    scanf("%d",&_);

    while(_--)

        run();

    return ;

}

HDU 3572 Task Schedule (最大流)的更多相关文章

hdu 3572 Task Schedule （dinic算法）
pid=3572">Task Schedule Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 ...
HDU 3572 Task Schedule（拆点+最大流dinic）
Task Schedule Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) To ...
hdu 3572 Task Schedule（最大流&&建图经典&&dinic）
Task Schedule Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) To ...
hdu 3572 Task Schedule
Task Schedule 题意:有N个任务,M台机器.每一个任务给S,P,E分别表示该任务的(最早开始)开始时间,持续时间和(最晚)结束时间:问每一个任务是否能在预定的时间区间内完成: 注:每一个任 ...
图论--网络流--最大流 HDU 3572 Task Schedule（限流建图，超级源汇）
Problem Description Our geometry princess XMM has stoped her study in computational geometry to conc ...
hdu 3572 Task Schedule（最大流）2010 ACM-ICPC Multi-University Training Contest（13）——Host by UESTC
题意: 告诉我们有m个任务和k个机器.第i个任务需要ci天完成,最早从第ai天开始,最晚在第bi天结束.每台机器每天可以执行一个任务.问,是否可以将所有的任务都按时完成? 输入: 首行输入一个整数t, ...
HDU 3572 Task Schedule（最大流判断满流）
https://vjudge.net/problem/HDU-3572 题意: 有N个作业和M台机器,每个作业都有一个持续时间P,工作的日期为S~E.作业可以断断续续的在不同机器上做,每台机器每次只可 ...
hdu 3572 Task Schedule【最大流】
求出最大流,再判断是否满流先不理解为什么要这样建图后来看了这一篇题解 http://blog.csdn.net/u012350533/article/details/12361003 把0看做源点 ...
hdu 3572 Task Schedule 网络流
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3572 Our geometry princess XMM has stoped her study i ...

随机推荐

Android OOM解决方案 :
清单文件里给Application标签加上android:largeHeap="true"这行代码这样会给你的app分配一个大内存如果某个页面在绘制时会耗非常多的内存 ...
EasyPlayerPro RTMP播放器助力远程娃娃机直播抓娃娃技术方案
远程娃娃机目前市面上娃娃机的方案有很多种.核心的技术流程就是实现远程直播加上对娃娃机手臂的远程操作.其中最主要的技术还是视频直播方案,需要低延时,视频秒开等流媒体技术. 最简单的直播方案视频直播方 ...
EasyNVR流媒体服务器网页兼容调试：ie浏览器下的接口调用成功但页面无法显示实时的数据
许多问题很难在开发的过程中就想的面面俱到,都是在实际应用.调试的过程中一一的优化的.由于easynvr的受众越来越多,因此也出现了好多在开发之初并没有留意的一些细节.我这次发现的问题就是给客户远程解决 ...
EasyPlayer_Android RTSP安卓播放器直播画面卡在第一帧问题修复
最近发现某些Android安卓手机在运行EasyPlayer播放视频时,会停留在第一帧画面,虽然有码率预示着接收端没有问题,但是画面却卡着不动. 一般来讲,这个现象有三种原因导致: 没有接收到视频帧; ...
python无法安装cv2的解决办法
问题:在windows命令窗口输入pip install cv2后出现:Could not find a version that satisfies the requirement cv2... 解 ...
一次php脚本出现段错误（Segment fault）的经历
今天在一台新服务器上cli运行一个php脚本,出现了Segment fault错误,第一感觉应该是某个扩展安装有问题这段php代码是调用soap接口,查看soap扩展没啥问题,一时不知道是啥原因. ...
DropDownList（For）
1.绑定数据源方法一 Controllers:var users = GetUsers(); var selectList = new SelectList(users, "Value&q ...
web性能压力测试工具http_load/webbench/ad
http_load 下载地址:http://www.acme.com/software/http_load/http_load-12mar2006.tar.gz 程序非常小,解压后也不到100K 居家 ...
L94
Early-morning births are genetically programmed THE notion that nothing good happens after midnight ...
[acm]HDOJ 1200 To and Fro
题目连接: http://acm.hdu.edu.cn/showproblem.php?pid=1200 简单字符串处理,找规律 /* 11509672 2014-08-21 11:32:55 Acc ...

HDU 3572 Task Schedule (最大流)

HDU 3572 Task Schedule (最大流)的更多相关文章

随机推荐

热门专题