加工零件-execution

题面：

有 N 个零件需要加工。零件之间有 M 个限制，x->y 表示 x 要在 y 之前先加工完。每个零件的加工时间都是 1。现在有无限个多个机床，在满足限制条件的情况下，零件可以同时加工。求加工完所有零件最少需要多少时间，然后还要求出在时间最少的前提下，最少需要多少机床。数据保证有解。

对于 100%的数据，1<=N<=200，1<=M<=2000；

做法：

题目保证有解，说明是一个DAG。

首先，最少的时间比较好求，只需要对于第一个点进行拓扑排序就行了。

那么容易发现，第二个答案是不超过N的，考虑从1到N枚举，直到某一个可行就返回Ans2

关键问题在于如何判断。

如何判断呢？

贪心地，一定是工序长的先在前面的机床。

那么我们可以先来一次倒的拓扑（第一问也同样求进去），得到每个点到工序结束的距离

正着的时候，考虑一个一个把节点压入优先队列，每次要做的时候，取出优先队列中最大的Ans2个。

然后对这Ans2个扩展（元素不到Ans2个跳出）。

注意到，时间复杂度是O((N+M) + N * (N log N + M)) <=500000——考虑到STL的堆常数较大，但还是够的（但是方便QAQ）

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
const int maxn = 205;
const int maxm = 2005;
struct Edge{
	int to,nxt;
}edge[maxm];
int first[maxn],nume;
void add_edge(int a,int b){
	edge[nume] . to = b;
	edge[nume] . nxt = first[a];
	first[a] = nume++;
}

int a[maxm],b[maxm],Mark[maxn];
int In[maxn];
int n,m,Len;
int DOWN(){
	memset(first,-1,sizeof(first));
	memset(In,0,sizeof(In));
	nume = 0;
	for (int i=1;i<=m;i++){
		add_edge(b[i],a[i]);
		In[a[i]]++;
	}
	int front,rear,q[maxn];
	front = rear = 0;
	for (int i=1;i<=n;i++)
	if (In[i] == 0){
		q[rear++] = i;
		Mark[i] = 1;
	}
	while (front < rear){
		int u = q[front++];
		for (int e=first[u];~e;e=edge[e].nxt){
			int v = edge[e] . to;
			Mark[v] = max(Mark[v],Mark[u]+1);
			In[v]--;
			if (In[v] == 0){
				q[rear++] = v;
			}
		}
	}
	Len = 0;
	for (int i=1;i<=n;i++){
		Len = max(Len,Mark[i]);
	}
	return Len;
}

struct cmp{
	bool operator ()(int a,int b){return Mark[a] < Mark[b];}
};
bool vis[maxn];
bool check(int M){
	priority_queue<int,vector<int>,cmp> heap;
	memset(In,0,sizeof(In));
	for (int i=1;i<=m;i++) In[b[i]]++;
	for (int i=1;i<=n;i++){
		if (In[i] == 0)	heap.push(i);
	}
	memset(vis,false,sizeof(vis));
	int tmp[maxn];
	for (int i=1;i<=Len;i++){
		tmp[0] = 0;
		for (int j=1;j<=M;j++){
			if (heap.empty()) break;
			tmp[++tmp[0]] = heap.top();
			heap.pop();
		}
		for (int j=1;j<=tmp[0];j++){
			int u = tmp[j];
			vis[u] = true;
			for (int e=first[u];~e;e=edge[e].nxt){
				int v = edge[e].to;
				In[v]--;
				if (In[v] == 0) heap.push(v);
			}
		}
//		for (int j=1;j<=n;j++) printf("%d ",In[j]);puts("");
	}
 //	puts("");
	for (int i=1;i<=n;i++)
		if (!vis[i]) return false;
	return true;
}

int UP(){
	memset(first,-1,sizeof(first));
	nume = 0;
	for (int i=1;i<=m;i++){
		add_edge(a[i],b[i]);
	}
	for (int i=1;i<=n;i++){
		if (check(i)) return i;
	}
	return -1;
}

int main(){
	freopen("execution.in","r",stdin); 
	freopen("execution.out","w",stdout);
	scanf("%d%d",&n,&m);
	for (int i=1;i<=m;i++){
		scanf("%d%d",&a[i],&b[i]);
	}
	printf("%d ",DOWN()); 
//	puts("");
	printf("%d\n",UP());
}

注意到，这个算法是错的，但是随机数据基本可过，特殊构造数据过的概率还是有点大的。

O-->O-->O-->O

X-->O

O-->Y-->O

O-->Y-->O

X到2个Y都有一条边。