mzoj P1344 工作依赖

题面

题目描述(Description):

2008年，奥运会将在中国举行。众所周知举办奥运会是一个庞大的工程，有许多准备工作要做，而这些工作也是要分先后、存在依赖关系的。比如我们说工作2依赖于工作1，意思是说在工作2开始做之前要必须结束工作1。我们假设，在一个时刻只有一个工作在进行，而且每样工作所依赖的其它工作不会超过10个。

输入文件(job.in):

第一行有两个整数N（0<=N<=10000）和M。所有工作从1到N编号。你需要计算第M个工作的最早结束时间。
接下来N行每行描述一个工作，第1行描述工作1，第二行描述工作2，……，以此类推。每行包含几个正整数，第i行的第1个整数是完成第i个工作需要的时间T（0<T<=100），第i行的其余数字是第i个工作所依赖的其它工作编号。我们保证不会出现循环依赖。

输出文件(job.out):

一个整数：工作M的最早结束时间。

样例(Sample):
Sample Input Case 1:

2 2

3

2 1

Sample Output Case 1:

5

Sample Input Case 2:

3 3

3

2 1

4 1 2

Sample Output Case 2:

9 

分析

作为蒟蒻，本题第一眼就是可以暴力搜索的
我们以依赖关系建图，若a依赖b，则a是b的父节点
此题易得玄学方程：

$f[u]=\sum f[v]$ $(v\notin vis[U])$

于是就可以染色dfs得解

code

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(int i=start;i<=end;i++)
#define clean(arry,num); memset(arry,num,sizeof(arry));
#define max(a,b) (a>b)?a:b;
#define min(a,b) (a<b)?a:b;
const int maxn=10000+10;
int f[maxn];//最早完成时间
int cost[maxn];//单个完成时间 
int son[maxn][15];//每个工作依赖的工作 
int n,m;
inline int read()
{
	int ans=0;char r=getchar();bool neg=false;
	while(r>'9'||r<'0'){if(r=='-')neg=true;r=getchar();}
	while(r>='0'&&r<='9'){ans=ans*10+r-'0';r=getchar();}
	return ans;
}
inline void getline(char *s,int SIZE)
{
    int p=0;char r=getchar();s[p]=r;
    while(SIZE>=p&&r!='\n'){r=getchar();s[++p]=r;}
}
void datasetting()
{
	n=read();m=read();scanf("\n");
	char s[1000];
	loop(i,1,n)
	{
		cost[i]=read();
		clean(s,10);
		getline(s,200);
		scanf("\n"); 
		int len=strlen(s);
		int res=0;int pos=0;int numofson=0;
		while(pos<len)
		{
			if(s[pos]==' '||s[pos]=='\n')
			{
				pos++;
				continue;
			}
			else if(s[pos]>='0'&&s[pos]<='9')
			{
				while(s[pos]>='0'&&s[pos]<='9')
				{
					res=res*10+s[pos]-'0';
					pos++; 
				}
				son[i][++numofson]=res;res=0;
			}
			else pos++;
		}
	}
}
void dfs(int u)
{
	int res=0;
	if(son[u][1]==-1)
	{
		f[u]=cost[u];
		return;	
	}
	for(int i=1;;i++)
	{
		int v=son[u][i];
		if(v==-1)break;
		if(f[v]!=2139062143)continue;
		dfs(v);
		res+=f[v];
	}
	f[u]=res+cost[u];
}
int main()
{
	//freopen("datain.txt","r",stdin);
	clean(f,0x7f);clean(cost,0);clean(son,-1);
	datasetting();
	dfs(m);
	printf("%d",f[m]);
	return 0;
}

学到的教训

1.读入
本题的读入和noip 2017 Day1 T2一样恶心，尤其是那个不定项输入，对策是写一个鲁棒性很强的输入函数或是用stl，而我选择了前者
因为刚刚写过noip 2017 Day1 T2，我就用了那时自己写的getline函数

inline void getline(char *s,int SIZE)
//SIZE是个保护机制，一定一定一定记着要开够，这是60pts到AC的关键
{
    int p=0;char r=getchar();s[p]=r;
    while(SIZE>=p&&r!='\n'){r=getchar();s[++p]=r;}
}

需要注意的是
一定要对数组清空，字符数组也不例外，否则特判会炸掉
字符数组的清空可以用

char arry[maxn];
memset(arry,10,sizeof(arry));
/*或*/
memset(arry,'\n',sizeof(arry));

将其全部赋值为‘\n’(’\n’的ascll码是10）
2.存图的方式
很多大佬都是用链式前向星存的图

int head[maxn];
struct edge{
    int v,nxt;
}e[maxm];
······
void adde(int u,int v)
{
	e[size].v=v;
	e[size].nxt=head[u];
	head[u]=size++;
}

还有些大佬使用vector

std::vector<int>G[10005];
······
G[i].push_back(x);

而我这个蒟蒻用了数组（类似于一个模拟vector）

int son[maxn][15];
······
son[i][++numofson]=res;

怎么说呢，这些方法各有千秋

个人认为数组的方式在时间和空间上都比较优，但代码要复杂一些（指针有点恼人），若在比较复杂的程序里面就可能会使得调试出问题

而用vertor，十分简便，易调错，但是时间复杂度上不是很乐观。因为vector的内存分配实现方法是 当前的容量不足就申请一块当前容量2倍的新内存空间，然后将所有的老元素全部拷贝到新内存中 ，若数据特别多，那么时间复杂度会指数级增长

而链式前向星对于对其很熟悉的oler来说，调试不是大问题，但是空间稍稍要比数组模拟的大一些，因为链式前向星相当于开了两个大小为(maxm（最大边数）<<1)的数组和一个maxn（最多点数）的数组，就占用了
(maxm$\times$ 2+maxn)
个int，而用数组只占用了
（maxn$\times$maxson（每个点最多子节点数））
个int，（指针忽略不计），显然数组开销小些

一些奇怪的东西

我不得不说，

oj的数据太水！！

我自己构造了一组数据，一不小心hack掉了两个在oj上A掉此题的大佬的代码
数据如下，各位也可以去测试一下各位的程序

10 1

11 2 5

2 3 4

4

5 9

3 4 7 8 6

10 8

6 9

7 7 10

8 

9

ans=65（也许是我算错了，但图应该是对的）
数据说明：