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;
}

 

转载于:https://www.cnblogs.com/d-e-v-i-l/p/4765875.html