CSP认证202109T3-脉冲神经网络（优化）

66分的思路（数据量大时超时）

• 存储每个神经元，每个突触，每个源。
• 每个突触具有一个（待发出）队列，其中元素表示该脉冲的发出时间
• 对每个时间步：
  • 遍历每个突触，若队首元素加上该突触的D等于该时间则到达神经元I_k加上对应的值
  • 每个神经元更新状态。如果激活则在对应突触队列中增加一条信息。
  • 对每个源同样

100分思路（循环队列优化）

• 上述每个时间步的循环步骤中需要遍历每个突触。能否将每个神经元结点（源）发出的信号就保留在目标神经元中（不断累计）并到时就加入？这样避免了遍历突触
• 对每个神经元使用一个数组其每个时间点将要到来的I_k。
• 该数组是一个循环队列。维护cur指针在当前时间点指向当前队列首部。由于延时D至多为1000，因此该队列长度至多1001.

#include <iostream>
#include<vector>
#include<map>
#include<string>
#include<set>
#include<algorithm>
#include<queue>
using namespace std;
double delay[1003][1003];   //每个结点在该时间步得到的(循环队列节约空间)
double v[1001];  //每个结点的v值，当前时间步
double u[1001];  //每个结点的u值，当前时间步
double a[1001],b[1001],c[1001],d[1001];  //每个结点的常数
int r[1001];  //发射结点的常数
int f[1001];  //每个结点的发射次数
struct ed
{
    int to;   //到达
    double w;     //边容量
    int D;
};
struct ed edge[1001];
//和哪条边连接
vector<ed> n_g[1001];
vector<ed> r_g[1001];




static unsigned long next_1 = 1;

/* RAND_MAX assumed to be 32767 */
int myrand(void) {
    next_1 = next_1 * 1103515245 + 12345;
    return((unsigned)(next_1/65536) % 32768);
}


int main()
{
    int N,S,P,T;
    cin >> N >> S >> P >>T;
    double delt;
    cin >>delt;
    int total = 0;
    while(total < N)
    {
        int j;
        cin >> j;
        double v_1,u_1,a_1,b_1,c_1,d_1;
        cin >> v_1 >> u_1 >> a_1 >> b_1 >> c_1 >> d_1;
        for(int i = total;i < j + total ;i++)
        {
            v[i]  = v_1; u[i] = u_1; a[i] = a_1; b[i] = b_1; c[i] = c_1; d[i] = d_1;
        }
        total += j;
    }
    for(int j = 0;j<P;j++)
        cin >> r[j];
    int maxd = 0;
    for(int j= 0;j<S;j++)
    {
        int s,t,D;
        double w;
        cin >> s >> t >> w >> D;
        maxd = max(maxd,D);
        struct ed y;
        y.D = D; y.to =t ; y.w  = w;
        if(s < N)
        {
            n_g[s].push_back(y);
        }
        else r_g[s - N].push_back(y);
    }
    for(int i = 0;i<N;i++)
    {
        f[i] = 0;
                for(int j = 0;j<=maxd;j++)
            {
                delay[i][j] = 0;
            }
    }
    int cur = 0;
    for(int t = 1;t<=T;t++)
    {
        for(int  i = 0;i<N;i++)
        {
            double v_p = v[i];
            double u_p = u[i];
            v[i] = v_p  + delt * (0.04 * v_p * v_p + 5 * v_p + 140 - u_p) + delay[i][cur];  //接收当前脉冲
            u[i] = u_p + delt * a[i] * (b[i] * v_p - u_p);
            //cout << v[i] << endl;
            if(v[i] >= 30)  //发送下一个脉冲
            {
                v[i] = c[i];
                u[i] += d[i];
                for(int y = 0;y<n_g[i].size();y++)
                {
                    struct ed x = n_g[i][y];
                    delay[x.to][(cur + x.D) % (maxd + 1)] += x.w;
                }
                f[i]++;
            }
            delay[i][cur] = 0;  //队首清零准备放入队尾
        }

        for(int i = 0;i<P;i++)
        {
            int  z = myrand();
            if(r[i] > z)   //发射
            {
                for(int y = 0;y<r_g[i].size();y++)
                {
                    struct ed x = r_g[i][y];
                    delay[x.to][(cur + x.D) % (maxd + 1)] += x.w;
                }
            }
        }
        cur = (cur + 1) % (maxd + 1);
    }
    double v_min = 1e10;
    double v_max = -1e10;
    int f_min = 1e10;
    int f_max = -1e10;
    for(int i = 0;i<N;i++)
    {
        v_min = min(v_min,v[i]);
        v_max = max(v_max,v[i]);
        f_min = min(f_min,f[i]);
        f_max = max(f_max,f[i]);
    }
    printf("%.3lf %.3lf\n%d %d\n",v_min,v_max,f_min,f_max);
    return 0;
}