CCFCSP 201912-4 区块链 80分（超时）

思路

• 事实证明不要想太多，我一开始的时候考虑如果时间非顺序输入要如何解决，给自己凭空增加了2小时的无效工作量，事实证明他的数据时间是顺序输入的
• 在1号node更新后，告诉2号考虑一下更新，如果2号更新了，务必要把2号也加入到传播队列里。
• 这里使用队列来进行传播操作，队列中存放着该节点当前时间的状态以及何时需要更新其邻居。
• 本题的顺序应该是，先更新邻居（传播链），再查询，再插入块。
• 由于太过暴力超时了啊哈哈，时间紧迫，所以就没再做改进。

代码（80分）

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>

using namespace std;

struct node{
    vector<int> Mlink;
    vector<int> neis;
};

queue< pair<node,int> > update(vector<node>& nodes,node u,int nv,int anotime){
    queue< pair<node,int> > update;
    pair<node,int> p;
    node v=nodes[nv];
    int flag=0;
    if(u.Mlink.size()>v.Mlink.size()){
        v.Mlink=u.Mlink;
        p.first=v;
        p.second=anotime;
        flag=1;
    }
    else if(*(u.Mlink.end()-1)<(*(v.Mlink.end()-1) )&& u.Mlink.size()==v.Mlink.size()){
        //cout<<nu<<*(u.Mlink.end()-1)<<endl;
        v.Mlink=u.Mlink;
        p.first=v;
        p.second=anotime;
        flag=1;
    }
    nodes[nv]=v;
    if(flag==1)
        update.push(p);
    return update;
}


int main(){
    int m=0,n=0;
    cin>>n>>m;
    vector<node> nodes;
    for(int i=0;i<n;i++){
        node N;
        N.Mlink.push_back(0);
        nodes.push_back(N);
    }
        
    for(int i=0;i<m;i++){
        int u=0,v=0;
        cin>>u>>v;
        u--;
        v--;
        nodes[u].neis.push_back(v);
        nodes[v].neis.push_back(u);
    }
    
    int t=0,k=0;
    
    
    pair<int,vector<node> > nowp;
    nowp.first=0;
    nowp.second=nodes;
    
    cin>>t>>k;
    int nowtime=1;
    
    vector<node> res;
    queue<pair<int,int> > search;
    queue<pair<node,int> > uptoano;
    
    string s="";
    getline(cin,s);
    while(k--){
        getline(cin,s);
        
        int count=0;
        int arr[3]={0,0,-1};
        
        for(int i=0;i<s.length();i++){
            if(s[i]>='0' && s[i]<='9'){
                arr[count]=arr[count]*10+s[i]-'0';
            }
            else if(s[i]==' '){
                count++;
                if(count==2)
                    arr[count]=0;
            }
            else
                continue;
        }
        
        arr[0]--;
        
        if(arr[0]==0 && arr[1]==0 &&arr[2]==0){
            k++;
            continue;
        }
        
        //更新链
        while(!uptoano.empty() && uptoano.front().second<=arr[1]){
            //cout<<uptoano.front().second<<endl;
            //cout<<"looping"<<endl;
            pair<node,int> p=uptoano.front();
            uptoano.pop();
            //cout<<p.first.neis[0]<<endl;
            for(int i=0;i<p.first.neis.size();i++){
                int v=p.first.neis[i];
                queue<pair<node,int> > temp;
                temp=update(nodes,p.first,v,p.second+t);
                //cout<<nodes[v].Mlink.size()<<endl;
                while(!temp.empty()){
                    uptoano.push(temp.front());
                    temp.pop();
                }
                
            }
        }
        
        //查询
        if(count==1){
            res.push_back(nodes[arr[0]]);
        }
        
        //添加块
        if(count==2){
            int u=arr[0];
            nodes[u].Mlink.push_back(arr[2]);
            pair<node,int> p;
            p.first=nodes[arr[0]];
            p.second=arr[1]+t;
            uptoano.push(p);
        }
        
    }
    
    
    
    for(int i=0;i<res.size();i++){
        cout<<res[i].Mlink.size()<<" ";
        for(int j=0;j<res[i].Mlink.size();j++){
            cout<<res[i].Mlink[j]<<" ";
        }
        cout<<endl;
    }
    
    return 0;
}