Task Schedule

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Problem 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

题意：给你m个机器和n个任务，每个机器一次只能运行一个任务，但是可以运行中断换任务，每个任务有一个开始的最早时间Si和完成的最晚时间Ei，这个任务完成需要的时间Pi，问是否可以完成所有任务。。

*****这个题比较难想到网络流，但是想到点上了就发现这就是个网络流，我开始用最初学的那个算法写，结果CE，不明就里，就改啊改的，然后是RE，说是下标越界，再改就成了TLE，超时。。。然后临时在网上复习了一下dinic算法，这个耗时小一些。。。

题解：和普通网络流一样，设置一个超级原点S和超级汇点T，S连接每个任务，流量限制为这个任务的Pi，T连接每个时间点，流量限制为m，因为同一时刻m个机器是能同时运行的，然后把每个任务同它相关的时间点都连接起来，流量限制为1，然后进行你的网络流模版就是了~~

#include <iostream>

using namespace std;

int n,m,sum;

struct node

{

    int to,val,next;//流向的点，流量限制，下一个对应的点

}s[M*M];//其实就类似做一个线性表

int hand[M],snum;//hand[x]表示x在之前最后出现的那次，在s中的位置，snum是s的长度

int dis[M],q[M];//dis记录dinic算法中用bfs分的层，q是模拟队列

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

hand[to]=snum++;

}

int bfs()

{

    int i,j,k,l,cur,qian,hou;

dis[0]=0;

    while(qian!=hou)//判断模拟循环队列是否为空

cur=q[hou++];//取队首元素并出队

        if(hou>=M)hou=0;//循环队列

        for(i=hand[cur];i!=-1;i=s[i].next)//线性表中快速遍历与cur相关的点

k=s[i].to;//取出点

            if(s[i].val>0&&dis[k]==-1)//判断流量限制和是否已经分层

q[qian++]=k;//入队

                if(qian>=M)qian=0;//循环队列

                if(k==1001)return
1;//已经分层汇点

}

    return 0;//到最后都没有搜到汇点表示没有增广路了

}

int dfs(int x,int flow)

{

    int i,j,k,l,cost=0;

    if(flow<=0)return
0;

    if(x==1001)return
flow;//汇点

    for(i=hand[x];i!=-1;i=s[i].next)//遍历相关点

k=s[i].to;//取点

        if(s[i].val>0&&dis[k]==dis[x]+1)//判断流量限制和层次关系是否符合

l=dfs(k,Min(flow-cost,s[i].val));//向下搜索，流量限制取当前剩余流量和路径限制流量中的最小值

            if(l>0)//向下搜到汇点则确定这一条路径

s[i^1].val+=l;//反正增加

                if(cost==flow)break;//当前点满流则结束

}else dis[k]=-1;//向下搜不到汇点则切断这条路，相当于深搜中vis的作用

}

    return cost;

}

void dinic()

{

    int i,j,k,l=0;

    while(bfs())//分层并判断原点是否与汇点相通

l+=dfs(0,MAX);//深搜在当前分层中找出最大流

}

    if(l>=sum)puts("Yes");//最大流可能大于预判，因为任务在最大时间点之前就全部完成了

    else puts("No");

}

int main (void)

{

    int t,cas=1,i,j,k,l,Pi,Si,Ei;

scanf("%d",&t);

    while(t--&&scanf("%d%d",&n,&m))

memset(hand,-1,sizeof(hand));

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

sum+=Pi;//记录总花费时间

            while(Si<=Ei)//遍历当前任务相关的所有时间点

Si++;

}

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

puts("");//格式。。

}

    return 0;

心得：我也是醉了，开始绘图错了，到后来算法时间度我没有深入了解，以至于到了大半夜还在装13卖萌充当学霸，但是给我的收货是学算法不光是了解他的用法和熟练去写它，还需要充分了解它的部分原理，学习其中一些深层的却不起眼的东西，往往这知识点关键时候就是你制胜的关键··