HDU 3572 Task Schedule(最大流)

题意：给N个任务，M台机器。每个任务有起始时间S，最后期限 E，和完成这个任务需要的时间P。每个任务可以分段进行,但是在同一时刻,一台机器最多只能执行一个任务. 问存不存在可行的工作时间。

思路：这题由于每一个任务都是可以断断续续这样完成的，所以一开始不知道怎么建图，留意到这里一共的时间才500，所以可以把每一天都作为一个顶点，任务的编号为500+1到500+n，汇点为500+n+1

          建图：

          从源点0连一条容量为m的边到每一个点，表示每天最多可以有多少个机器可以工作，每个任务连向汇点，容量为完成任务需要的时间，枚举500天，如果该天满足大于等于起始时间，小于等于最后期限，就在这天和机器连一条边，容量为1，最后跑一遍最大流看看是否等于总时间即可

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <set>
#include <ctime>
#include <cmath>
#include <cctype>
using namespace std;
#define maxn 1550
#define INF 1<<29
#define LL long long
int cas=1,T;
struct Edge
{
	int from,to,cap,flow;
	Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};
int n,m;
struct Dinic
{
//	int n,m;
    int s,t;
	vector<Edge>edges;        //边数的两倍
	vector<int> G[maxn];      //邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
	bool vis[maxn];           //BFS使用
	int d[maxn];              //从起点到i的距离
	int cur[maxn];            //当前弧下标
	void init()
	{
	   for (int i=0;i<=1200;i++)
		   G[i].clear();
	   edges.clear();
	}
	void AddEdge(int from,int to,int cap)
	{
		edges.push_back(Edge(from,to,cap,0));
		edges.push_back(Edge(to,from,0,0));        //反向弧
		int mm=edges.size();
		G[from].push_back(mm-2);
		G[to].push_back(mm-1);
	}
	bool BFS()
	{
		memset(vis,0,sizeof(vis));
		queue<int>q;
		q.push(s);
		d[s]=0;
		vis[s]=1;
		while (!q.empty())
		{
			int x = q.front();q.pop();
			for (int i = 0;i<G[x].size();i++)
			{
				Edge &e = edges[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;
		for(int &i=cur[x];i<G[x].size();i++)
		{
			Edge &e = edges[G[x][i]];
			if (d[x]+1 == d[e.to] && (f=DFS(e.to,min(a,e.cap-e.flow)))>0)
			{
				e.flow+=f;
				edges[G[x][i]^1].flow-=f;
				flow+=f;
				a-=f;
				if (a==0)
					break;
			}
		}
		return flow;
	}

	int Maxflow(int s,int t)
	{
		this->s=s;
		this->t=t;
		int flow = 0;
		while (BFS())
		{
			memset(cur,0,sizeof(cur));
			flow+=DFS(s,INF);
		}
		return flow;
	}
}dc;

int p[maxn];
int s[maxn];
int e[maxn];
int main()
{
	scanf("%d",&T);
	while (T--)
	{
		printf("Case %d: ",cas++);
		scanf("%d%d",&n,&m);
		dc.init();
		memset(p,0,sizeof(p));
		memset(s,0,sizeof(s));
		memset(e,0,sizeof(e));
		int sum =0;
        for (int i = 1;i<=n;i++)
		{
			scanf("%d%d%d",&p[i],&s[i],&e[i]);
			sum+=p[i];
		}
		for (int i = 1;i<=500;i++)         //源点到每一天连边
			dc.AddEdge(0,i,m);
        for (int i = 1;i<=n;i++)
			dc.AddEdge(500+i,500+n+1,p[i]);   //每个任务到汇点有边
		for (int i = 1;i<=n;i++)
		{
			for (int j=1;j<=500;j++)
			{
				if (j <= e[i] && j>=s[i])
					dc.AddEdge(j,500+i,1);
			}
		}
        printf("%s\n\n",dc.Maxflow(0,500+n+1) == sum?"Yes":"No");
	}
}

          

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