CCFCSP认证 2019-12D区块链

题目大意

一张无向图，每个节点有条链，不同链之间有优先级。
若一个点获得更高优先级的链，则它会更新自己的链，然后把该链传递给相邻节点（有时间延迟），此过程是递归的。
现在按时间顺序给你两种操作：
1：把某节点的链加长一块
2：查询某节点的链
让你输出正确结果

考点

队列

思路

此题算是比较简单的一道D题了。
首先我发现本题的核心是时间顺序，如果枚举每一个时间单位，那么一定会超时，因为题目中的时间范围是1e9的级别。那么换种思路，只需按时间顺序枚举每次操作，然后把该时刻之前所有的“事务”处理完，不就可以了吗?
啥叫“事务”呢，比如：a点将自己的链传给了b点，并且会在c时刻到达，链为d，这就叫一个事务。为此可以定义一个结构体来模拟该“事务”。
因此我们可以用优先队列来将所有事务按时间顺序排列。对于每个操作，假设其时间为t，我们就顺序访问优先队列，处理其中所有时间小于等于t的事务，如果期间生成了新的事务，要及时入队。
但是这样还过不了这道题，上述算法复杂度约为O(kmlog(mk))，刚好会被卡。
有两个地方可以优化：
1.注意到题目中每次传播都是相邻的点，所以说新入队的元素的时间一定大于等于队列内所有元素（和bfs是一个道理，队列具有两段性）。故用普通队列即可，把log优化掉了。
2. 每次链更新后，我们会找到与它相邻的所有点，每个点产生一个新事务。完全可以把这些事务合起来称作一个事务，在处理该事务时，再找到与它相邻的所有点进行更新。这样会大大减少队列内元素个数。

易错点

1. 本题开的空间不够，不会报RE，但会报WA，容易误导debug方向。

收获

1. 优先队列撰写cmp函数作为比较器
2. bfs两段性

满分代码

#include <bits/stdc++.h>

using namespace std;

#define fi first
#define se second
const int N=2e4+10;

typedef pair<int,int> PII;
typedef long long LL;

typedef struct List{
    int len;
    vector<int> lis;
}mylis;

typedef struct Modify{
    LL t;//广播的时间
    int zd,bd;//zd：谁发起的改链
    mylis lis;

}modi;

int n,m,t,k,e[N],ne[N],h[N],dj[N],idx,list_idx;
bool st[N];
mylis best_list[N];

queue<modi> pq;

bool cmp2(mylis x,mylis y){
    if(x.len>y.len)return 1;
    else if(x.len==y.len && x.lis[x.len-1]<y.lis[y.len-1])return 1;
    return 0;
}


void add(int a,int b)
{
    e[idx]=b; ne[idx]=h[a]; h[a]=idx; idx++;
}


void query(int a)
{
    int len=best_list[a].len;
    cout<<len;
    for(int i=0;i<len;i++)cout<<" "<<best_list[a].lis[i];
    cout<<endl;
}

void addblock(int a,int b,int c)
{
    best_list[a].lis.push_back(c);
    best_list[a].len++;

    //广播
    modi tmp;
    tmp.zd=a;
    tmp.t=b+t;
    tmp.lis=best_list[a];
    pq.push(tmp);
}

int main(){
    memset(h,-1,sizeof h);

    cin>>n>>m;
    for(int i=0;i<m;i++){
        int u,v;
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }


    for(int i=1;i<=n;i++){
        best_list[i].lis.push_back(0);
        best_list[i].len=1;
    }

    cin>>t>>k;
    char c = getchar();
    for(int i=0;i<k;i++){
        int x,cnt=0,op[3];
        string s;
        getline(cin,s);
        istringstream is(s);
        while(is>>op[cnt]){
            cnt++;
        }
        if(cnt==2){
            //先把传播、修改链的事务处理完
            while(!pq.empty()){
                modi tt=pq.front();
                //if(op[1]==25)cout<<"!"<<tt.zd<<" "<<tt.bd<<" "<<tt.t<<" "<<tt.lis.len<<endl;
                if(tt.t>op[1]){
                    break;
                }
                pq.pop();
                int cur=tt.zd;
                for(int j=h[cur];j!=-1;j=ne[j]){
                    if(cmp2(tt.lis,best_list[e[j]])){
                            modi tmp;
                            tmp.zd=e[j];
                            tmp.t=tt.t+t;
                            tmp.lis=tt.lis;
                            pq.push(tmp);//e[j]有更新，需要广播
                            best_list[e[j]]=tt.lis;
                    }

                }
            }
            query(op[0]);
        }
        else{
             //先把修改链的事务处理完
            //先把传播、修改链的事务处理完
            while(!pq.empty()){
                modi tt=pq.front();
                //if(op[1]==25)cout<<"!"<<tt.zd<<" "<<tt.bd<<" "<<tt.t<<" "<<tt.lis.len<<endl;
                if(tt.t>op[1]){
                    //cout<<"over\n";
                    break;
                }
                pq.pop();
                int cur=tt.zd;
                for(int j=h[cur];j!=-1;j=ne[j]){

                    if(cmp2(tt.lis,best_list[e[j]])){
                            modi tmp;
                            tmp.zd=e[j];
                            tmp.t=tt.t+t;
                            tmp.lis=tt.lis;
                            pq.push(tmp);//e[j]有更新，需要广播
                            best_list[e[j]]=tt.lis;
                    }

                }
            }
            addblock(op[0],op[1],op[2]);
        }
    }



    return 0;
}