HDU3572 Task Schedule(ISAP)

学了几天的网络流,感觉还是ISAP算法比较实用,用这道题整理了一下,可以当作模版

题意:给出n个任务+m台机器,还有一个任务处理时限+开始时间+结束时间,一个时刻里一台机器只能处理一个任务,但是一个任务可以在不同机器处理,问能否处理完所有任务?

方法:最大流。这个题的建图算是经典,因为限定每个时刻每台机器只能处理一个任务,所以可以把时间点分配给各个合法的机器...具体是先设定一个超 级源点S(我设为0这个点),连向各个任务,容量为该任务所需时间,各个任务连向在范围内的时间点,容量为1,所有时间点连向超级汇点T,容量为机器台数,最后求最大流,等于所有机器所需时间和的就是yes,否则就是no。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <cmath>
#include <vector>
#include <algorithm>
#include <limits.h>
using namespace std;
#define inf 1e8
#define maxm 400000
#define maxn 1100
int head[maxn],eid;
int dis[maxn];//残量网络中节点i到汇点t的最短距离
int num[maxn];//和t的最短距离等于i的节点数量
int cur[maxn];//当前弧下标
int pre[maxn];//可增广路上的上一条弧的编号
struct node
{
    int v,cap,next;
} edge[maxm];
void add(int u,int v,int cap)
{
    edge[eid].v=v;
    edge[eid].cap=cap;
    edge[eid].next=head[u];
    head[u]=eid++;
    edge[eid].v=u;
    edge[eid].cap=0;
    edge[eid].next=head[v];
    head[v]=eid++;
}
void bfs(int source,int sink)//预处理,利用反向BFS,更新dis数组
{
    queue<int>q;
    while(!q.empty()) q.pop();
    memset(num,0,sizeof(num));
    memset(dis,-1,sizeof(dis));
    q.push(sink);
    dis[sink]=0;
    num[0]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            if(dis[v]==-1)
            {
                dis[v]=dis[u]+1;//找允许弧
                num[dis[v]]++;
                q.push(v);
            }
        }
    }
}
int isap(int source,int sink,int n)//n为残量网络中的节点到汇点的最大距离,通常节点的个数,即上限
{
    memcpy(cur,head,sizeof(cur));
    int flow=0,u=pre[source]=source;
    bfs(source,sink);//更新dis数组
    while(dis[source]<n)
    {
        if(u==sink)
        {
            int df=inf,pos;
            for(int i=source;i!=sink;i=edge[cur[i]].v)//追踪增广路路径,最小残量df
            {
                if(df>edge[cur[i]].cap)
                {
                    df=edge[cur[i]].cap;
                    pos=i;
                }
            }
            for(int i=source;i!=sink;i=edge[cur[i]].v)//更新流量
            {
                edge[cur[i]].cap-=df;
                edge[cur[i]^1].cap+=df;
            }
            flow+=df;
            u=pos;
        }
        int st;
        for(st=cur[u];st!=-1;st=edge[st].next)//从当前弧开始查找允许弧
            if(dis[edge[st].v]+1==dis[u]&&edge[st].cap)//找到允许弧跳出
                break;
        if(st!=-1)
        {
            cur[u]=st;
            pre[edge[st].v]=u;
            u=edge[st].v;
        }
        else
        {
            if((--num[dis[u]])==0) break;//GAP优化,出现断层结束
            int mind=n;
            for(int id=head[u];id!=-1;id=edge[id].next)//retreat操作:更新dis数组
            {
                if(mind>dis[edge[id].v]&&edge[id].cap)
                {
                    cur[u]=id;//修改标号的同时修改当前弧
                    mind=dis[edge[id].v];
                }
            }
            dis[u]=mind+1;
            num[dis[u]]++;
            if(u!=source) u=pre[u];// 回溯继续寻找允许弧
        }
    }
    return flow;
}
void init()
{
    memset(head,-1,sizeof(head));
    eid=0;
}
int main()
{
    //freopen("in.txt","r",stdin);
    int t,n,m,a,b,c;
    scanf("%d",&t);
    for(int cas=1; cas<=t; cas++)
    {
        init();
        int sum=0,tt=0;
        scanf("%d%d",&n,&m);
        for(int i=1; i<=n; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            sum+=a;
            if(c>tt) tt=c;
            add(0,i,a);
            for(int j=b; j<=c; j++)
                add(i,n+j,1);
        }
        int sink=n+tt+1;
        for(int i=1; i<=tt; i++)
            add(n+i,sink,m);
        printf("Case %d: ",cas);
        int ans=isap(0,sink,sink);
        if(ans==sum) printf("Yes\n\n");
        else printf("No\n\n");
    }
    return 0;
}
时间: 2024-10-13 22:36:18

HDU3572 Task Schedule(ISAP)的相关文章

HDU 3572 Task Schedule(ISAP)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3572 题意:m台机器,需要做n个任务.第i个任务,你需要使用机器Pi天,且这个任务要在[Si  ,  Ei]区间内完成才有效.对于一个任务,只能由一个机器来完成,一个机器同一时间只能做一个任务.当然,一个任务可以分成几段不连续的时间来完成.问,能否做完全部任务. 题意很清晰,也就是判断是否是满流. 对于网络流问题,模板大家都有,关键在于如何建图(详见资料) 思路:今天问了龙哥,对建图有了一定的了解,

HDU 4907 (杭电BC#3 1001)Task schedule(水)

题目地址:HDU 4907 水题...不多说..哈希后从后往前遍历一遍就行了. 代码如下: #include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <ctype.h> #include <queue> #include <map> #include<a

BestCoder Round #3 1001 &amp;&amp; HDU 4907 Task schedule (预处理)

题目链接:HDU 4907 Task schedule 中文题. 思路:将工作表存在vis的组数中.预处理一遍.具体看代码 AC代码: #include<stdio.h> #include<string.h> bool vis[200100]; int tak[200100]; int main() { int j,i,ti; int n,m,t,num; while(scanf("%d",&t)!=EOF) { while(t--) { memset(

HDU 3572 Task Schedule(ISAP模板&amp;amp;&amp;amp;最大流问题)

题目链接:http://acm.hdu.edu.cn/showproblem.php? pid=3572 题意:m台机器.须要做n个任务. 第i个任务.你须要使用机器Pi天,且这个任务要在[Si  ,  Ei]区间内完毕才有效. 对于一个任务,仅仅能由一个机器来完毕.一个机器同一时间仅仅能做一个任务. 当然,一个任务能够分成几段不连续的时间来完毕.问,是否能做完所有任务. 题意非常清晰.也就是推断是否是满流. 对于网络流问题,模板大家都有,关键在于怎样建图(详见资料) 思路:今天问了龙哥,对建图

HDU - 3572 Task Schedule(网络流)(入门好题)

原题链接 题意: 有 m 台机器,一台机器同一时刻只能够做一个任务,任务可以被中断并给另一个空闲的机器去完成: 现在有 n 个任务,每个任务有 Pi , si , ei , 分别表示该任务完成所需要的  任务量,开始时间,截止时间: 问  是否能够在规定时间内完成所有任务. 思路: 设定 S = 0 为超级源点,将 S 与每一个任务点相连,流量为P[i],每个任务点与其 si 到 ei 范围内相连,流量为1,最后将所有任务的时间区间与 T 相连,流量为 m: 跑一遍最大流之后判断是否大于  ∑

hdu 4907 Task schedule(哈希运用)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4907 Task schedule Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 554    Accepted Submission(s): 275 Problem Description 有一台机器,并且给你这台机器的工作表,工作表上有

Spark源码分析之六:Task调度(二)

话说在<Spark源码分析之五:Task调度(一)>一文中,我们对Task调度分析到了DriverEndpoint的makeOffers()方法.这个方法针对接收到的ReviveOffers事件进行处理.代码如下: [java] view plain copy // Make fake resource offers on all executors // 在所有的executors上提供假的资源(抽象的资源,也就是资源的对象信息,我是这么理解的) private def makeOffers

Spark源代码分析之六:Task调度(二)

话说在<Spark源代码分析之五:Task调度(一)>一文中,我们对Task调度分析到了DriverEndpoint的makeOffers()方法.这种方法针对接收到的ReviveOffers事件进行处理.代码例如以下: // Make fake resource offers on all executors     // 在全部的executors上提供假的资源(抽象的资源.也就是资源的对象信息,我是这么理解的)     private def makeOffers() {       /

C# 异步编程Task整理(二)异常捕捉

一.在任务并行库中,如果对任务运行Wait.WaitAny.WaitAll等方法,或者求Result属性,都能捕获到AggregateException异常. 可以将AggregateException异常看做是任务并行库编程中最上层的异常. 在任务中捕获的异常,最终都应该包装到AggregateException中.一个任务并行库异常的简单处理示例如下: static void TestTwo() { Task t1= Task.Factory.StartNew(() => { throw n