CSP20221202训练计划（多思路分析）

题目链接：http://118.190.20.162/view.page?gpid=T159

首先，第一种思路就是建立依赖链，但是这样必然会引起时间和存储超限，代码如下：

#include<bits/stdc++.h>//vector版，内存超限 
using namespace std;
struct node{
 int bianhao;
 int dep;//依赖编号 
 int nd;//训练需要天数
 int day1;//最早开始天数 
 int day2;//最晚开始天数 
 int deped=0;//是否被依赖，不唯一 
};
vector<int> link[200];//放编号 ,无分支依赖链（倒着求） 
struct node a[110];
 
int main()
{
 int n,m;
 bool flag=1;//能否完成 
 cin>>n>>m;
 for(int i=1;i<=m;i++)//只依赖编号比自己小的node 
 {
 cin>>a[i].dep;
 a[a[i].dep].deped=1;
 a[i].bianhao=i;
 } 
 for(int i=1;i<=m;i++)
 {
 cin>>a[i].nd;
 //初步判断能否完成
 if(a[i].nd>n)flag=0;
 //输出最早天数
 if(!a[i].dep)
 {
 a[i].day1=1; 
 a[i].day2=n-a[i].nd+1;//无依赖链的最晚开始时间 
}
 else a[i].day1=a[a[i].dep].day1+a[a[i].dep].nd;
    cout<<a[i].day1<<' ';
 }
 cout<<endl;
 
 if(flag==1){
       int linksum=0;
 	for(int i=m;i>0;i--)//从叶建立
	 {
	 	if(a[i].deped==0&&a[i].dep!=0)
	 	{
	 		linksum++;//从1开始
            link[linksum].push_back(i);
            struct node temp=a[a[i].dep];//临时 
            while(temp.dep==0)
            {
            	  link[linksum].push_back(temp.bianhao);
            	  temp=a[temp.dep];
			}
		 }
	 }
	 
	for(int i=1;i<=linksum;i++)//分析每个依赖序列完成天数 
  {
   int sum=0; 
   int temp=n;
       for(int j=0;j<link[i].size();j++)
       {
        sum+=a[link[i][j]].nd;
        a[link[i][j]].day2=max(a[link[i][j]].day2,(temp-a[link[i][j]].nd+1));
        temp=temp-a[link[i][j]].nd;
    }
 	    if(sum>n)
    {
     flag=0;
     break;
 }
}
 	   if(flag==1)
   {
    for(int i=1;i<=m;i++)cout<<a[i].day2<<' ';
   }
 	
 	
 } 
 
 
 return 0; 
 } 

接下来，我们充分利用后依赖前，一个点只有一个依赖点这个已知条件，再结合AOE网络求解最早、最晚时间的思路。得到方法：求最早开始时间从前往后，求最晚开始时间从后往前（好处已经写在代码注释中）：

#include<bits/stdc++.h>//①参考AOE网络，最早时间从前往后，最晚时间从后往前 
using namespace std;//②通过题目要求抓关键（多点对一点，后依赖前）。1.从后往前处理的时候，该点的被依赖关系无或者已被处理（自身ed已经是定值） 2.不会出现分叉的依赖链 
const int N=400;// ③不用直接求出ed结束时间（需要知道依赖链具体情况），而是设置初值，被依赖则被移动，不需要知道依赖链具体情况，线性处理降低时间复杂度 
struct node{
	int nd;
	int dep;
	int st;
	int ed;
	bool move=false;//ed是否被移动 
}a[N];

int main()
{
	int n,m;
	cin>>n>>m;
	bool flag=true;
	for(int i=1;i<=m;i++)cin>>a[i].dep;

	for(int i=1;i<=m;i++)
	{
	cin>>a[i].nd;
	//判断
	if(a[i].nd>n)flag=false; 
	//直接输出最早时间，前面依赖关系少 
    if(!a[i].dep)a[i].st=1;
	else a[i].st=a[a[i].dep].st+a[a[i].dep].nd;
	cout<<a[i].st<<' ';	
	//设置初始最晚时间 
	a[i].ed=n-a[i].nd+1;
    }
    cout<<endl;
    
    if(flag==true){
    	for(int i=m;i>=1;i--)//最晚时间从后往前 
    	{
    			if(a[i].dep!=0){//有依赖关系，并且被依赖者的ed被移动过 
					if((a[i].ed-a[a[i].dep].nd)<=0)//相当于反向求最早开始时间原理 
					{
						flag=false;
						break;
					}
					if(a[a[i].dep].move==true) a[a[i].dep].ed=min(a[a[i].dep].ed,a[i].ed-a[a[i].dep].nd);//比最早，才满足所有都能完成 
					else{
						a[a[i].dep].ed=a[i].ed-a[a[i].dep].nd;
						a[a[i].dep].move=true;
						
					}
				}
			} 

		if(flag==true)
		{
			for(int i=1;i<=m;i++)cout<<a[i].ed<<' ';
			cout<<endl;
		}
} 
	return 0;
}