CSP认证201912-4区块链

70分超时做法

• "延时"使用循环队列模拟（和CSP脉冲神经网络类似）
• 结点接收时仅传递vector的引用，插入时新开个vector，与原vector断开联系

#include<iostream>
#include<algorithm>
#include<map>
#include<stdio.h>
#include<string.h>
#include<unordered_map>
#include<vector>
#include<queue>
#include<set>
#include<math.h>
using namespace std;



struct list
{
    vector<int> a;
    int lastsize;
};   //维护每个结点在某一时刻的链
//sup拷贝时候使用引用？


struct list l[501][1005];  //每个结点将要更新的list用循环队列实现
struct list x[501];   //每个结点在当前时刻的list使用数组
int cur=0;

int main()
{
    int n,m; cin>>n>>m;
    for(int i = 0;i<n;i++) {x[i].lastsize=1;x[i].a.push_back(0);}
    vector<int> adjmap[n];
    for(int i = 0;i<m;i++)  //对每条边循环
    {
        int u,v; cin>>u >> v;
        adjmap[u-1].push_back(v-1); adjmap[v-1].push_back(u-1);
    }
    int t,k; cin >> t >> k;
    for(int i =0 ;i<n;i++) {for(int j = 0;j<=t;j++) l[i][j].lastsize=-1;}  //没有待更新的块
    int curt = 0;  //始终指向当前待处理的第一个时间点
    string ans;
    for(int i = 0;i<k;i++)   
    {     
        int cnt = 0; int m[3];
        do
        {
            cin >> m[cnt++];
        }while(cin.get()!='\n');
        int a = m[0]; int b = m[1];int c =  m[2];
        for(;curt<=b;curt++)
        {   
            //每个结点接收当前的链
            for(int  j = 0;j<n;j++)
            {
                bool flag = false;
                if(l[j][cur].lastsize > x[j].lastsize) 
                {x[j] = l[j][cur]; flag = true;}
                else if(l[j][cur].lastsize == x[j].lastsize && l[j][cur].a[l[j][cur].lastsize - 1] < x[j].a[x[j].lastsize-1])
                {x[j] = l[j][cur];flag = true;}
                //产生新块
                if(flag)  //产生更新向所有邻居结点发送
                {
                    int arr = (cur + t) % (t+1);
                    for(int v : adjmap[j])
                    {
                        if(l[v][arr].lastsize < x[j].lastsize)   //接收到的链更长
                        l[v][arr] = x[j];
                        else if(l[v][arr].lastsize == x[j].lastsize && x[j].a[x[j].lastsize - 1] < l[v][arr].a[l[v][arr].lastsize - 1])
                        l[v][arr] = x[j];      
                    }
                }
            }
            cur = (cur+1) % (t+1);
        }
        if(cnt == 2)
        {
            int i;
            ans += to_string(x[a-1].lastsize) + " ";
            for(i = 0;i<x[a-1].lastsize-1;i++) ans += to_string(x[a-1].a[i]) + " ";
            ans+=to_string(x[a-1].a[i]);
            ans+='\n';
        }
        else     //插入新结点并发送
        {
            vector<int> d;
            for(int v : x[a-1].a) d.push_back(v);
            d.push_back(c);
            x[a-1].a = d; x[a-1].lastsize = d.size();   //发送
            int arr = ((cur - 1) % (t+1) + t) % (t+1);
            int  j = a-1;
            for(int v :adjmap[a-1])   //向邻居结点发送更新数据
            {
                if(l[v][arr].lastsize < x[j].lastsize)   //接收到的链更长
                l[v][arr] = x[j];
                else if(l[v][arr].lastsize == x[j].lastsize && x[j].a[x[j].lastsize - 1] < l[v][arr].a[l[v][arr].lastsize - 1])
                l[v][arr] = x[j];      
            }
        }
    }
    cout << ans;
    system("pause");
    return 0;
}

优化

• 可以考虑不遍历每个时间点，每个结点的接收情况。
• 而是为每个结点维护一个链队列，读到一个输入后把队列中time小于当前time的都执行然后出队

struct op
{
    int id;
    int tim;
    vector<int>q;
};
vector<op>op;