devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CSP CCF： 202109-3 脉冲神经网络 （C++） 66分

作者：2023面试高手 | 2024-05-30 15:29:00

赞

踩

202109-3

题目来源

计算机软件能力认证考试系统

解题思路

由于我有些看不懂这个题目，所以我是先找的他人的博客理解了一下题目。

这个博客写得很详细的（66分），有助于理解题目。 CSP 202109-3 脉冲神经网络（详解）_刘学.的博客-CSDN博客

所以我这里主要就是记录一下这道题啦，想到如何优化到100分，再更新。

代码

66分

  1. #include <iostream>
  2. #include <iomanip>
  3.  
  4. using namespace std;
  5.  
  6. // 神经元结构
  7. struct neuron {
  8.     int ID, times;
  9.     double prev, preu; //v, u;  // 由于后续这个v、u用处不大，我就没写上了
  10.     double a, b, c, d;
  11. };
  12.  
  13. struct pluse {
  14.     int ID;
  15.     long long int r;
  16. };
  17.  
  18. struct synapse {
  19.     int outID, inID, D;
  20.     double w;
  21. };
  22.  
  23. neuron neurons[1001];
  24. pluse pluses[1001];
  25. synapse synapses[1001];
  26.  
  27. void InputData(int N, int P, int S) {
  28.     for (int id = 0; id < N;) {
  29.         int RN;
  30.         double v, u, a, b, c, d;
  31.         cin>>RN>>v>>u>>a>>b>>c>>d;
  32.         for (int j = 0; j < RN; ++j, ++id) {
  33.             neurons[id].times = 0;
  34.             neurons[id].prev = v;
  35.             neurons[id].preu = u;
  36.             neurons[id].ID = id;
  37.             neurons[id].a = a;
  38.             neurons[id].b = b;
  39.             neurons[id].c = c;
  40.             neurons[id].d = d;
  41.         }
  42.     }
  43.     for (int i = 0; i < P; ++i) {
  44.         long long int r;
  45.         cin>>r;
  46.         pluses[i].ID = N + i;
  47.         pluses[i].r = r;
  48.     }
  49.     for (int i = 0; i < S; ++i) {
  50.         cin>>synapses[i].outID>>synapses[i].inID>>synapses[i].w>>synapses[i].D;
  51.     }
  52. }
  53.  
  54.  
  55. static unsigned long Next = 1;
  56. /* RAND_MAX assumed to be 32767 */
  57. int myrand(void) {
  58.     Next = Next * 1103515245 + 12345;
  59.     return((unsigned)(Next/65536) % 32768);
  60. }
  61.  
  62.  
  63.  
  64. int main() {
  65.     int N, S, P, T;
  66.     double deltaT;
  67.     cin>>N>>S>>P>>T;
  68.     cin>>deltaT;
  69.  
  70.     InputData(N, P, S);
  71.  
  72.     // 记录每个时刻的 IK  !!!关键点 !!!
  73.     double IK[1001][2001] = {0};  // int IK[1001][100101];
  74.  
  75.     for (int t = 1; t <= T; ++t) {  // 每个时刻
  76.         for (int i = 0; i < P; ++i) {  // 每个脉冲源
  77.             if (myrand() < pluses[i].r) {  // 当 r > myrand() 时发放脉冲信号
  78.                 for (int j = 0; j < S; ++j) {  // 每个突触
  79.                     if (synapses[j].outID == i + N) {
  80.                         IK[synapses[j].inID][t + synapses[j].D] += synapses[j].w;
  81.                     }
  82.                 }
  83.             }
  84.         }
  85.     }
  86.  
  87.     // 更新每个时刻的神经元
  88.     for (int t = 1; t <= T; ++t) {  // 每个时刻
  89.         for (int i = 0; i < N; ++i) {  // 每个神经元
  90.             double ik = IK[i][t];
  91.             double prev = neurons[i].prev, preu = neurons[i].preu;
  92.             double v = prev + deltaT * (0.04 * prev * prev + 5 * prev + 140 - preu) + ik,  // !!!0.04 not 0.004!!!
  93.                     u = preu + deltaT * neurons[i].a * (neurons[i].b * prev - preu);
  94.  
  95.             if (v >= 30) { // 神经元发放脉冲
  96.                 for (int j = 0; j < S; ++j) {  // 对于每个突触
  97.                     if (synapses[j].outID == i) {
  98.                         IK[synapses[j].inID][t + synapses[j].D] += synapses[j].w;  // += synapses[j].w; not synapses[synapses[j].inID].w;
  99.                     }
  100.                 }
  101.                 v = neurons[i].c;
  102.                 u = neurons[i].d + u;
  103.                 ++neurons[i].times;
  104.             }
  105.             neurons[i].prev = v;
  106.             neurons[i].preu = u;
  107.         }
  108.     }
  109.  
  110.     // 找出最后的答案
  111.     double minVV = neurons[0].prev, maxVV = neurons[0].prev;
  112.     int minTimes = neurons[0].times, maxTimes = neurons[0].times;
  113.     for (int i = 1; i < N; ++i) {
  114.         minVV = min(minVV, neurons[i].prev);
  115.         maxVV = max(maxVV, neurons[i].prev);
  116.         minTimes = min(minTimes, neurons[i].times);
  117.         maxTimes = max(maxTimes, neurons[i].times);
  118.     }
  119.  
  120.     cout<<fixed<<setprecision(3)<<minVV<<" "<<fixed<<setprecision(3)<<maxVV<<endl<<minTimes<<" "<<maxTimes<< endl;
  121.  
  122.     return 0;
  123. }

-------------------------------------------- 更新 ----------------------------------------------

我的代码改得就差将大佬的代码复制粘贴了，可它还是超时超时66分。呜呜。 

贴上 100分 的大佬代码的链接  CSP认证202109T3-脉冲神经网络（优化）_nth2000的博客-CSDN博客  参考参考， 方便以后复习吧。

把 66 分的也给贴上，以后再看问题在哪里了吧：

  1. /* 66 */
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <map>
  5. #include <vector>
  6. #include <fstream>
  7.  
  8. using namespace std;
  9.  
  10. // 神经元结构
  11. double nv[1002], nu[1002], na[1002], nb[1002], nc[1002], nd[1002];
  12. int ntimes[1002];
  13.  
  14. long long int pr[1002];
  15.  
  16. struct synapse {
  17.     int inID, D;
  18.     double w;
  19. };
  20.  
  21. vector<synapse> n2n[1002];
  22. vector<synapse> p2n[1002];
  23.  
  24. static unsigned long Next = 1;
  25. /* RAND_MAX assumed to be 32767 */
  26. int myrand(void) {
  27.     Next = Next * 1103515245 + 12345;
  28.     return((unsigned)(Next/65536) % 32768);
  29. }
  30.  
  31.  
  32. int main() {
  33.     int N, S, P, T;
  34.     double deltaT;
  35.     cin>>N>>S>>P>>T;
  36.     cin>>deltaT;
  37.  
  38.     for (int id = 0; id < N;) {
  39.         int RN;
  40.         double v, u, a, b, c, d;
  41.         cin>>RN>>v>>u>>a>>b>>c>>d;
  42.         for (int j = 0; j < RN; ++j, ++id) {
  43.             ntimes[id] = 0;
  44.             nv[id] = v;
  45.             nu[id] = u;
  46.             na[id] = a;
  47.             nb[id] = b;
  48.             nc[id] = c;
  49.             nd[id] = d;
  50.         }
  51.     }
  52.     for (int i = 0; i < P; ++i) {
  53.         long long int r;
  54.         cin>>r;
  55.         pr[i] = r;
  56.     }
  57.     synapse stmp;
  58.     for (int i = 0; i < S; ++i) {
  59.         int outID;
  60.         cin>>outID>>stmp.inID>>stmp.w>>stmp.D;
  61.         if (outID < N) {
  62.             n2n[outID].emplace_back(stmp);
  63.         }
  64.         else {
  65.             p2n[outID - N].emplace_back(stmp);  // 要记得 - N
  66.         }
  67.     }
  68.  
  69.     // 记录每个时刻的 IK  !!!关键点 !!!
  70.     double IK[1002][1003] = {0};  // 循环数组， IK[n][m], m的大小是要略大于 D的
  71.     int NUM = 1003;
  72.     //
  73.     for (int t = 1; t <= T; ++t) {  // 每个时刻
  74.         //
  75.         for (int i = 0; i < P; ++i) {  // 每个脉冲源
  76.             if (myrand() < pr[i]) {  // 当 r > myrand() 时发放脉冲信号
  77.                 for (int j = 0; j < p2n[i].size(); ++j) {
  78.                     synapse ss = p2n[i][j];
  79.                     IK[ss.inID][(t + ss.D) % NUM] += ss.w;  // 通过 % 来循环
  80.                 }
  81.             }
  82.         }
  83.  
  84.         // 更新每个时刻的神经元
  85.         for (int i = 0; i < N; ++i) {  // 每个神经元
  86.             double ik = IK[i][t % NUM];
  87.             double prev = nv[i], preu = nu[i];
  88.             double v = prev + deltaT * (0.04 * prev * prev + 5 * prev + 140 - preu) + ik,
  89.                     u = preu + deltaT * na[i] * (nb[i] * prev - preu);
  90.  
  91.             if (v >= 30) { // 神经元发放脉冲
  92.                 for (int j = 0; j < n2n[i].size(); ++j) {
  93.                     synapse ss = n2n[i][j];
  94.                     IK[ss.inID][(t + ss.D) % NUM] += ss.w;
  95.                 }
  96.                 v = nc[i];
  97.                 u = nd[i] + u;
  98.                 ++ntimes[i];
  99.             }
  100.             nv[i] = v;
  101.             nu[i] = u;
  102.  
  103.             IK[i][t % NUM] = 0;  // 每个时刻下遍历某一神经元后要将当前的状态修改成0， 这样后续循环才不会出错。
  104.         }
  105.     }
  106.  
  107.     // 找出最后的答案
  108.     double minVV = nv[0], maxVV = nv[0];
  109.     int minTimes = ntimes[0], maxTimes = ntimes[0];
  110.     for (int i = 1; i < N; ++i) {
  111.         minVV = min(minVV, nv[i]);
  112.         maxVV = max(maxVV, nv[i]);
  113.         minTimes = min(minTimes, ntimes[i]);
  114.         maxTimes = max(maxTimes, ntimes[i]);
  115.     }
  116.  
  117.     cout<<fixed<<setprecision(3)<<minVV<<" "<<fixed<<setprecision(3)<<maxVV<<endl<<minTimes<<" "<<maxTimes<< endl;
  118.  
  119.     return 0;
  120. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/647542
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号