CCF CSP 区块链 模拟

只有90分，最后一个点没通过，想不明白，放这里晾着吧，有时间反思一下,
大概思路如下：
首先建立一个图的数据结构来描述它，然后建立一个以时间为顺序的任务表，这个表我们利用map内置的红黑树来实现“插入即排序的功能”，然后以这个时间序为事件发生顺序，按照逻辑模拟就可以了，当然我们会发现同一时刻查询和更新事件发生时，优先更新，类似的，所以我们在查询时间+0.1什么的把它的优先级降低，接下来就是大模拟了。

设计思想：

STEP1
静态设置
首先想一个基础的数据结构表达题目的所有数据，所以有图，然后想怎么操作这些结点，想着大模拟，那以时间模拟，所以建立一个以时间为序的任务链表，因为要排序，所以选用map；

要完整的描述每个结点，我们仔细阅读题目发现，只需要记录每个结点的链就可以了，所以加了个V[501], 图用M[501]

要完整的描述每个任务，我们需要建立一个结构体Task，分析任务有三种状态，查询，添加结点，更新链表 ，于是设置一个status,每个任务处理的对象是节点，所以有node,如果是添加点，就得用add_value，如果是更新链表就得有list,于是乎一个完整的任务描述就OK了

STEP2
动态设置
接下来考虑，操作，以时间为序，处理任务，所以用map p,考虑各个操作的优先级，所以选用double类型，这样通过±0.1 上下调优先级，作为时间所用的类型。

STEP3
然后考虑细节问题，具体实现需要那个模块
一开始创世点为0 init()
读取的输入需要处理 input()
创建一个任务 放到main 和 处理任务的函数中
添加一个任务到任务表 add_task
执行一个任务 process_unit
开始处理 start

划分功能模块，设计好整体的思路，再处理一下具体的细节，很快就可以写出一个还不错的程序

#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<algorithm>
#include<sstream>
//#define DEBUG
using namespace std;
enum{QUERY,ADD_SINGLE,ADD_LIST};//每个任务分为三个状态，查询，添加结点，更新链表 
struct Task{
	int node;
	int status;
	int add_value; 
	vector<int> list;
};
vector<int> V[501];//每个结点的链 
vector<int> M[501];//图 

map<double,vector<Task> > P;  //任务列表  第一个参数是时间    为什么不用int 是因为在同一时刻三个状态发生时有优先级，于是直接+-0.1来改变
//他们在任务列表里的顺序 

double t,last_t;
void init(int n)
{
	for(int i=1;i<=n;i++)
		V[i].push_back(0);
	
}
void add_task(double time,Task& a)
{
	if(P.find(time)!=P.end())
	{
		P[time].push_back(a);
	}
	else
	{
		vector<Task> k;
		P[time]=k;
		P[time].push_back(a);
	}
 } 
vector<int> input()//由于每次读入不知道是读入两个还是三个，所以我们按行读取
{
	string  str;
	getline(cin,str);

	istringstream in;
	in.str(str);
	vector<int>val;
	int a ;
	while(in>>a)
	{	
	
		val.push_back(a);
	
	}
	return val;
}

void process_unit(double time,Task &a)//事件处理单元，处理每一个事件
{	
	 
	if (a.status==QUERY)
	{
		int len =V[a.node].size();
		cout<<len<<" ";
		len--;
		for(int i=0;i<len;i++)
		{
			cout<<V[a.node][i]<<" ";
		}
		cout<<V[a.node][len]<<endl;
	}
	else if (a.status==ADD_SINGLE)
	{
		
		V[a.node].push_back(a.add_value);
		int len =M[a.node].size();
		Task B;
		B.status=ADD_LIST;
		B.list=V[a.node];
		for(int i=0;i<len;i++)
		{
			B.node=M[a.node][i];
			add_task(time+t-0.1,B); 
		}
	}
	else if(a.status==ADD_LIST) 
	{
		vector<int> &ori=a.list;
		vector<int> & ini=V[a.node];
		if(ori.size()>ini.size()||((ori.size()==ini.size())&&(*(--ori.end())<*(--ini.end()))))
		{
			ini=ori;
			
			Task B;
			B.status=ADD_LIST;
			B.list=ini;
			int len=M[a.node].size();
			for(int i=0;i<len;i++)
			{
				B.node=M[a.node][i];
				add_task(time+t-0.1,B); 
			}
		}
		
	}
	else 
	{
		cout<<"ERROR"<<endl;
	}
	
}
void start()
{
	if(P.size()==0)
		return ;
	
	map<double,vector<Task> >::iterator it=P.begin();
	
	while(it->first<=last_t)
	{
		int len=it->second.size();
		for(int i=0;i<len;i++)
		process_unit(it->first,it->second[i]);
		P.erase(it);
		it=P.begin();
		if(it==P.end())
			break;
		
	 } 
}
int main()
{
	
	int n,m;
	int x,y;
	cin>>n>>m;
	init(n);
	for(int i=1;i<=m;i++)
	{
		cin>>x>>y;
		M[x].push_back(y);
		M[y].push_back(x); 
	}
	int k;
	vector<int>val;
	cin>>t>>k;
	cin.get();
	while(k--)
	{	
		val=input();
		if(val.size()==2)
		{
			Task B;
			B.node=val[0];
			B.status=QUERY;
			
			add_task(val[1]+0.1,B);
		}
		else
		{
			Task B;
			B.add_value=val[2];
			B.node=val[0];
			B.status=ADD_SINGLE;
			add_task(val[1],B);
		}
	}
	#ifdef DEBUG
	cout<<"开始  任务列表："<<endl;
	map<double,vector<Task> > ::iterator it=P.begin();
	while(it!=P.end())
	{
		cout<<"time   "<<it->first<<"    task  "<<it->second.size()<<endl;
		int l=it->second.size();
		for(int i=0;i<l;i++)
		{
			Task &A=it->second[i];
			cout<<"结点  "<<A.node<<"   value "<<A.add_value<<"  ";
			if(A.status==QUERY)
			cout<<"QUERY";
			else if (A.status==ADD_LIST)
			cout<<"ADD_LIST";
			else 
			cout<<"ADD_SINGLE";
			cout<<endl; 
		}
		it++;
	 } 
	
	#endif 
	last_t=(--P.end())->first;
	#ifdef DEBUG
	cout<<"LAST_TIME:  "<<last_t<<endl;
	#endif
	start();
	return 0;
}