【题意】有n个任务,每个任务必须开始于第Si天之后(包括Si),结束于第Ei天之前(包括Ei),每个任务持续的时间为Pi,现在有m台机器,每台每天只能专注做其中一件任务,每个任务做的时间可以不连续。问是否存在一种方案使得这n个任务顺利完成

【类型】最大流

【建图】设一个源点S,将每个任务分别化成一个点,S向每个任务连一条边,容量为Pi,接着每个任务向时间Si~Ei分别连一条容量为1的边,每个时间向汇点连一条容量为m的边。这样跑最大流即可。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<queue>
#include<string>
#include<sstream>
#define eps 1e-9
#define FOR(i,j,k) for(int i=j;i<=k;i++)
#define MAXN 10005
#define MAXM 1000005
#define INF 0x3fffffff
using namespace std;
typedef long long LL;
int i,j,k,n,m,x,y,T,ans,big,cas,num,w,t,u,v,p,s,e,S,F,sum,max_time;
bool flag; struct Edge{
int u,v,weight;
int next;
}edge[MAXM];
int head[MAXN]; /* head[u]表示顶点u第一条邻接边的序号, 若head[u] = -1, u没有邻接边 */
int current; /* 当前有多少条边 */ void add_edge(int u, int v, int weight)
{
/* 添加正向边u->v */
edge[current].u = u;
edge[current].v = v;
edge[current].weight = weight;
edge[current].next = head[u];
head[u] = current++;
/* 添加反向边v->u */
edge[current].u = v;
edge[current].v = u;
edge[current].weight = 0;
edge[current].next = head[v];
head[v] = current++;
} int isap(int s, int e , int n)
{
int i,u,v,max_flow,aug,min_lev; /* 寻找增广路径的过程中, curedge[u]保存的是对于顶点u当前遍历的边, 寻找顶点u的邻接边时不用每次
* 都从head[u]开始找, 而是从curedge[u]开始找, 这样就减少了搜索次数
* 当增广路径找到后
* curedge保存的就是一条增广路径了, 比如
* 0---四-->1---六-->2--七--->3---八--->4 0,1,2,3,4是顶点号, 四六七八是边的序号
* curedge[0] = 四, curedge[1] = 六, ... curedge[3] = 8, curedge[i]即保存找过的轨迹
*/
int curedge[MAXN],parent[MAXN],level[MAXN]; /* count[l]表示对于属于层次l的顶点个数, 如果某个层次没有顶点了,
* 就出现断层, 意味着没有增广路径了, 这就是gap优化, 可以提前结束寻找过程
* augment[v]表示从源点到顶点v中允许的最大流量, 即这条路线的最小权重
*/
int count[MAXN],augment[MAXN]; memset(level,0,sizeof(level));
memset(count,0,sizeof(count));
//初始时每个顶点都从第一条边开始找
for (i=0;i<=n;i++)
{
curedge[i] = head[i];
}
max_flow=0;
augment[s]=INF;
parent[s]=-1;
u=s; while (level[s]<n) /* 不能写成level[s] < MAX_INT */
{
if (u==e) /* 找到一条增广路径 */
{
max_flow+=augment[e];
aug=augment[e];
//debug("找到一条增广路径, augment = %d\n", aug);
//debug("%d", e);
for (v=parent[e];v!=-1;v=parent[v]) /* 从后往前遍历路径 */
{
i=curedge[v];
//debug("<--%d", v);
edge[i].weight-=aug;
edge[i^1].weight+=aug; /* 如果i是偶数, i^1 = i+1, 如果i是奇数, i^1 = i-1 */
augment[edge[i].v]-=aug;
if (edge[i].weight==0) u=v; /* u指向增广后最后可达的顶点, 下次就从它继续找 */
}
//debug("\n");
}
/* 从顶点u往下找邻接点 */
for (i=curedge[u];i!=-1;i=edge[i].next) /* 从curedge[u]开始找, 而不是head[u]从头开始, curedge[u]保存的是上次找过的边 */
{
v=edge[i].v;
if (edge[i].weight>0 && level[u]==(level[v]+1)) /* 找到一条边就停止 */
{
augment[v]=min(augment[u],edge[i].weight);
curedge[u]=i;
parent[v]=u;
u=v;
break;
}
}
if (i==-1) /* 没有邻接点, 回溯到上一个点 */
{
if (--count[level[u]]==0)
{
//debug("顶点%d在level %d断层\n", u, level[u]);//GAP优化
break;
}
curedge[u]=head[u]; /* 顶点u的所有边都试过了,没有出路, 更新了u的level后, 又从第一条边开始找 */
//找出level最小的邻接点
min_lev=n;
for (i=head[u];i!=-1;i=edge[i].next)
{
if (edge[i].weight>0)
{
min_lev=min(level[edge[i].v],min_lev);
}
}
level[u]=min_lev+1;
count[level[u]]++;
//debug("顶点%d的level= %d\n", u, level[u]);
//debug("顶点%d走不通, 回到%d\n", u, edge[curedge[u]].u);
if (u!=s) u=parent[u]; /* 回退到上一个顶点 */
}
}
return max_flow;
} int main()
{
scanf("%d",&T);
for (cas=1;cas<=T;cas++)
{
memset(head,-1,sizeof(head));current=0;
scanf("%d%d",&n,&m);
S=0;sum=0;
max_time=0;
for (i=1;i<=n;i++)
{
scanf("%d%d%d",&p,&s,&e);
sum+=p;
max_time=max(max_time,e);
add_edge(S,i,p);
for (j=s;j<=e;j++)
{
add_edge(i,n+j,1);
}
}
F=n+max_time+1;
for (i=1;i<=max_time;i++)
{
add_edge(n+i,F,m);
}
if (isap(S,F,F)==sum) printf("Case %d: Yes\n\n",cas);
else printf("Case %d: No\n\n",cas);
}
return 0;
}

  

HDU 3572 最大流的更多相关文章

  1. hdu 3572 最大流判断满流

    #include<stdio.h> #include<string.h> #include<queue> using namespace std; #define ...

  2. HDU 3572 Task Schedule(拆点+最大流dinic)

    Task Schedule Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) To ...

  3. HDU 3572 Task Schedule (最大流)

    C - Task Schedule Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u S ...

  4. HDU 1532 最大流入门

    1.HDU 1532 最大流入门,n个n条边,求第1点到第m点的最大流.只用EK做了一下. #include<bits/stdc++.h> using namespace std; #pr ...

  5. hdu 3572 Task Schedule(最大流)2010 ACM-ICPC Multi-University Training Contest(13)——Host by UESTC

    题意: 告诉我们有m个任务和k个机器.第i个任务需要ci天完成,最早从第ai天开始,最晚在第bi天结束.每台机器每天可以执行一个任务.问,是否可以将所有的任务都按时完成? 输入: 首行输入一个整数t, ...

  6. HDU 3572 Task Schedule(最大流判断满流)

    https://vjudge.net/problem/HDU-3572 题意: 有N个作业和M台机器,每个作业都有一个持续时间P,工作的日期为S~E.作业可以断断续续的在不同机器上做,每台机器每次只可 ...

  7. hdu 3572(构图+最大流)

    Task Schedule Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Tot ...

  8. hdu 3572 Task Schedule(最大流&amp;&amp;建图经典&amp;&amp;dinic)

    Task Schedule Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) To ...

  9. hdu 3572 Task Schedule【 最大流 】

    求出最大流,再判断是否满流 先不理解为什么要这样建图 后来看了这一篇题解 http://blog.csdn.net/u012350533/article/details/12361003 把0看做源点 ...

随机推荐

  1. 何为 pimpl ?

    前言 你是否总因头文件包含冲突而苦恼? 你是否因头文件包含错乱而苦恼? 你是否因封装暴露了数据而苦恼? 你是否因经常改动实现而导致重新编译而苦恼? 在这里, 这些问题都不是问题, 跟随作者, 揭秘pi ...

  2. centos账户管理命令(root权限)

    cat /etc/passwd | grep -v /sbin/nologin | cut -d : -f 1        查看所有用户 userdel -r 用户名           -删除用户 ...

  3. php处理中文字符串

    使用mbstring 先转换成UTF-8编码 mb_convert_encoding(Input::get('tags'),'UTF-8') mbstring用法参考http://php.net/ma ...

  4. shell脚本中的括号和实例

    1.单圆括号和双圆括号 “双圆括号”命令允许将高级的数学表达式放入比较中.格式如下: (( expression )) 除了 test命令(if-then [])使用的标准数学运算符外, 双圆括号还支 ...

  5. rename 后缀

    for file in $(find . -name "*.del" -type f);do mv "$file" "${file%.del}&quo ...

  6. C++学习笔记3——类的封装(1)

    封装: 1.把属性和方法进行封装. 2.对属性和方法进行访问控制. class和struct的区别: class和struct的唯一区别是默认的访问权限不一样.struct的默认访问权限是public ...

  7. 日志收集框架 Exceptionless

    日志收集框架 Exceptionless 前言 从去年就答应过Eric(Exceptionless的作者之一),在中国会帮助给 Exceptionless 做推广,但是由于各种原因一直没有做这件事情, ...

  8. how to count uv area

    先放着,空了再整理.... fn getModeUvVolumetric mode chang= ----得到UV使用率( --global facesNumSum = meshop.getnumfa ...

  9. 百度地图LBS云平台读写数据操作类

    最近写了个叫<行踪记录仪>的手机软件,用了百度云来记录每个用户的最近位置,以便各用户能在地图上找到附近的人,为此写了个类来读写数据,大致如下: import java.util.Array ...

  10. 浅谈Java内存泄露

    一.引言 先等等吧……累了