[关闭]
@darkproject 2019-11-03T14:55:50.000000Z 字数 6100 阅读 556

校园杂记

杂记

2018.3重邮校赛数模C，15届浙大数模B（没想到数模也能刷刷题，卖了50块233）
image.png-76.4kB

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <algorithm>
  4. #include <cstring>
  5. #include <string>
  6. using namespace std;
  7. const int inf =0x3f3f3f3f;
  8. int dp[15][15][15],yua[15][15][15],yub[15][15][15],yuc[15][15][15];
  9. int cost[15]={0,0,830,1630,4900,14700,51300,97100,194200,388000,776000};
  10. int value[15]={inf,60,120,180,240,300,360,420,480,540,600}; //value[0]=inf初始化防止value[i-1]除数为0错误情况
  11. int mxrA[15]={0,0,660,1320,2600,5200,9200,16900,38000,76000,228000};
  12. int mxrB[15]={0,0,960,2880,5760,8640,17280,51840,86500,173000,519000};
  13. int mxrC[15]={0,0,2300,6900,13800,27650,51840,89800,137100,274000,810000};
  14. int order[15][15][15];
  15. int needA,needB,needC,rel;
  16. int a,b,c;
  17. //D:\学习文件\C网络游戏策划与设计
  18. int maxx(int a,int b,int c) //三元比较函数定义
  19. {
  20.     int d=a;
  21.     if(b>d) d=b;
  22.     if(c>d) d=c;
  23.     return d;
  24. }
  25. int minn(int a,int b,int c)
  26. {
  27.     int d=a;
  28.     if(b<d) d=b;
  29.     if(c<d) d=c;
  30.     return d;
  31. }
  32. void print(int i,int j,int k) //递归输出解集
  33. {
  34.     if(i+j+k==3) return;
  35.     if(order[i][j][k]==1)
  36.     {
  37.         print(i-1,j,k);
  38.         cout<<"I "; 
  39.     }
  40.     else if(order[i][j][k]==2)
  41.     {
  42.         print(i,j-1,k);
  43.         cout<<"II "; 
  44.     } 
  45.     else{
  46.         print(i,j,k-1);
  47.         cout<<"III ";
  48.     }
  49. }
  50. int main()
  51. {
  52.     cin>>a>>b>>c;
  53.     memset(dp,0x3f,sizeof(dp)); //求最小优解，其余状态初始化为Inf
  54.     dp[1][1][1]=0;
  55.     //建立yua,yub,yuc数组在状态转移过程中保存更新剩余值
  56.     memset(yua,0,sizeof(yua));
  57.     memset(yub,0,sizeof(yub));
  58.     memset(yuc,0,sizeof(yuc));
  59.     memset(order,0,sizeof(order));
  60.     for(int i=0;i<=a;i++) needA+=mxrA[i];
  61.     for(int i=0;i<=b;i++) needB+=mxrB[i];
  62.     for(int i=1;i<=c;i++) needC+=mxrC[i];
  63.     for(int i=1;i<=10;i++)
  64.         for(int j=1;j<=10;j++)
  65.             for(int k=1;k<=10;k++)
  66.             {
  67.                 if(i+j+k==3) continue;
  68.                 //计算矿产I II III生级所需要的时间
  69.                 int tempI=ceil((cost[i]-yua[i-1][j][k])*1.0/value[i-1]);
  70.                 int tempII=ceil((cost[j]-yua[i][j-1][k])*1.0/value[i]);
  71.                 int tempIII=ceil((cost[k]-yua[i][j][k-1])*1.0/value[i]);
  72.                 dp[i][j][k]=minn(dp[i-1][j][k]+tempI,dp[i][j-1][k]+tempII,dp[i][j][k-1]+tempIII);
  73.                 //dp[i][j][k]到达等级i,j,k时的最小时间
  74.                 //可列出转移方程为dp[i-1][j][k],dp[i][j-1][k],dp[i][j][k-1]三种状态递推
  75.                 //判断状态转移到哪一步方便对剩余值进行更新与确定解集序列
  76.                 if(dp[i][j][k]==dp[i-1][j][k]+tempI){
  77.                     order[i][j][k]=1;
  78.                     yua[i][j][k]=tempI*value[i-1]-cost[i]+yua[i-1][j][k];
  79.                     yub[i][j][k]=tempI*value[j]+yub[i-1][j][k];
  80.                     yuc[i][j][k]=tempI*value[k]+yuc[i-1][j][k];
  81.                 }
  82.                 else if(dp[i][j][k]==dp[i][j-1][k]+tempII){
  83.                     order[i][j][k]=2;
  84.                     yua[i][j][k]=tempII*value[i]-cost[j]+yua[i][j-1][k];
  85.                     yub[i][j][k]=tempII*value[j-1]+yub[i][j-1][k];
  86.                     yuc[i][j][k]=tempII*value[k]+yuc[i][j-1][k]; 
  87.                 }
  88.                 else if(dp[i][j][k]==dp[i][j][k-1]+tempIII){
  89.                     order[i][j][k]=3;
  90.                     yua[i][j][k]=tempIII*value[i]-cost[k]+yua[i][j][k-1];
  91.                     yub[i][j][k]=tempIII*value[j]+yub[i][j][k-1];
  92.                     yuc[i][j][k]=tempIII*value[k-1]+yuc[i][j][k-1];
  93.                 }
  94.             }
  95.     rel=inf;
  96.     int aa,bb,cc;
  97.     //枚举所有状态等级的最小时间，计算这个等级矿产使工厂升级的时间
  98.     //升级时间取a b c升级最大值，总体取最小值
  99.     for(int i=1;i<=10;i++)
  100.         for(int j=1;j<=10;j++)
  101.             for(int k=1;k<=10;k++)
  102.             {
  103.                 int temp=dp[i][j][k];
  104.                 int tempa=needA-yua[i][j][k];
  105.                 //cout<<temp<<endl;
  106.                 int tempb=needB-yub[i][j][k];
  107.                 int tempc=needC-yuc[i][j][k];
  108.                 int tt=maxx(temp+ceil(tempa*1.0/value[i]),temp+ceil(tempb*1.0/value[j]),temp+ceil(tempc*1.0/value[k]));
  109.                 //cout<<tt<<endl;
  110.                 if(rel>tt)
  111.                 {
  112.                     aa=i,bb=j,cc=k;
  113.                     rel=tt;
  114.                 }
  115.             }
  116.     cout<<rel<<endl;
  117.     print(aa,bb,cc);
  118.     return 0;
  119. }

2018.5坦克大战AI寻路源码记录，A*记录路径，bfs剪枝。第一次尝试稍微大点的代码量(之前就一直写100行左右的题），现场跑的时候直接坦克跑崩了，且和别人对比发现自己的代码奇丑无比QWQ用c with stl所有1000多行代码全写在一个文件里xjb怼。发现别人几百行py比自己优雅得多，被吊着锤555，怀疑自己能不能做项目。

  1. #include <cstdio>
  2. #include <cmath>
  3. #include <WinSock2.h>
  4. #include <queue>
  5. #include <cstring>
  6. #include <stack>
  7. #include <algorithm>
  8. #include "message.h"
  9. #include "time.h"
  10. const int inf = 0x3f3f3f3f;
  11. const int maxn = 100;
  12. SOCKET sockClient;
  13. int n, m;
  14. int vis[maxn][maxn];
  15. int dx[] = { 0,0,-1,1 };//0 up 1 down 2 left 3 right
  16. int dy[] = { -1,1,0,0 };
  17. struct hyx
  18. {
  19.     int x, y, f, h, g;
  20.     bool operator <(const hyx &k) const {
  21.         return f > k.f;
  22.     }
  23. };
  24. int pre[maxn][maxn];
  25. priority_queue<hyx>mxr;
  26. stack<int>path[10];
  27. bool target[maxn][maxn];
  28. bool flag[maxn][maxn];
  29. node tank[10];
  30. int lastditank[10];
  31. int nextditank[10];
  32. node stopnum[10];//特殊node x与y为锁定的coin坐标，id为次数；
  33. bool judge(int x, int y)
  34. {
  35.     if (x >= 0 && y >= 0 && x < m&&y < n) return true;
  36.     return false;
  37. }
  38. int heuristic(hyx t, int endx, int endy)
  39. {
  40.     return (abs(t.x - endx) + abs(t.y - endy)) * 10;
  41. }
  42. int ousi(int x, int y, int x1, int y1)
  43. {
  44.     return ceil(sqrt((x - x1)*1.0*(x - x1) + (y - y1)*1.0*(y - y1)));
  45. }
  46. bool bfsjudge(node s)
  47. {
  48.     int sum = 0;
  49.     int viss[maxn][maxn];
  50.     memset(viss, 0, sizeof(viss));
  51.     vector<node>xixi;
  52.     xixi.clear();
  53.     queue<node>q;
  54.     q.push(s);
  55.     while (!q.empty())
  56.     {
  57.         node ss = q.front();
  58.         q.pop();
  59.         viss[ss.x][ss.y] = 1;
  60.         if (sum > 50) {
  61.             for (int k = 0; k < xixi.size(); k++)
  62.                 flag[xixi[k].x][xixi[k].y] = true;
  63.             return true;
  64.         }
  65.         for (int i = 0; i < 4; i++)
  66.         {
  67.             int nx = ss.x + dx[i];
  68.             int ny = ss.y + dy[i];
  69.             if (judge(nx, ny) && mp[nx][ny] != '#'&&mp[nx][ny] != '@' && !viss[nx][ny])
  70.             {
  71.                 sum++;
  72.                 if ((mp[nx][ny] >= '1'&&mp[nx][ny] <= '9') || mp[nx][ny] == '*') xixi.push_back(node(nx, ny));
  73.                 q.push(node(nx, ny));
  74.             }
  75.         }
  76.     }
  77.     return false;
  78. }
  79. void dfs(int x, int y, int number)
  80. {
  81.     if (pre[x][y] != -1)
  82.     {
  83.         path[number].push(pre[x][y]);
  84.         if (pre[x][y] == 0) dfs(x, y + 1, number);
  85.         else if (pre[x][y] == 1) dfs(x, y - 1, number);
  86.         else if (pre[x][y] == 2) dfs(x + 1, y, number);
  87.         else if (pre[x][y] == 3) dfs(x - 1, y, number);
  88.     }
  89. }
  90. bool Astar(node st, node end, int number)
  91. {
  92.     hyx s;
  93.     memset(vis, 0, sizeof(vis));
  94.     while (!mxr.empty()) mxr.pop();
  95.     s.x = st.x;
  96.     s.y = st.y;
  97.     s.f = s.g = s.h = 0;
  98.     mxr.push(s);
  99.     pre[s.x][s.y] = -1;
  100.     while (!mxr.empty())
  101.     {
  102.         hyx u = mxr.top();
  103.         mxr.pop();
  104.         vis[u.x][u.y] = 1;
  105.         if (u.x == end.x&&u.y == end.y)
  106.         {
  107.             while (!path[number].empty()) path[number].pop();
  108.             dfs(u.x, u.y, number);
  109.             return true;
  110.         }
  111.         for (int i = 0; i < 4; i++)
  112.         {
  113.             hyx v;
  114.             v.x = u.x + dx[i];
  115.             v.y = u.y + dy[i];
  116.             if (judge(v.x, v.y) && !vis[v.x][v.y] && mp[v.x][v.y] != '#'&&mp[v.x][v.y] != '@')
  117.             {
  118.                 v.h = u.h + heuristic(v, end.x, end.y);
  119.                 v.g = u.g + ousi(u.x, u.y, v.x, v.y);
  120.                 v.f = v.g + v.h;
  121.                 pre[v.x][v.y] = i;
  122.                 mxr.push(v);
  123.             }
  124.         }
  125.     }
  126.     return false;
  127. }

2018.9团体赛和区域赛的失败拖队伍后腿，加上一些事情和实力下降很多且没有进步，心情变得格外急躁，在一次训练赛中被怀疑作弊离开了集训队。自爆自弃了一段时间，逃避刷题，开始对写代码有了一些抵抗心理,遂尝试接触美术相关的东西，也开始了解游戏开发。

2018.11跟着网上unity教程做了些东西玩，还是没有项目思维，都是想到什么写什么。加入了unity shader入门群，了解到了很多基础shader知识(真的是水群学习啊233，还会翻一下群聊天记录),也了解到了TA这个岗位，开始试着向这方面努力。加入了blender群(主要水群点)认识了很多网友，在色图中互相快乐。

2019.1-2019.9写了很多shader案例，尝试向着渲染更深处学习完结blender的学习，这时候houdini很火于是开始尝试玩houdini(= =觉得自己真是随意啊)，第一次使用了知乎和推特看见很多相关的分享文章(开始批量关注，无法自拔)，也不再独自学习渲染，开始有了有共同目标的朋友(虾兄)，和之前刚开始学shader一样，感觉只能潜水，无法交流。经过一段时间学习(不问太低级的问题免得被T，233)，开始尝试找一些二手资料ppt和后处理图形效果复现。ps:感觉自己的学习过程其实就是从看不懂群聊话语，到逐渐看懂的过程。

2019.10-now9月中旬意识到秋招开始了，投简历，清一色投递TA岗位，简历通过的了了无几。能收到的只有试投的客户端岗位，也尝试着面试了字节、网易游戏、盛趣。没有充分准备基础知识，一直在做渲染效果，非科班被计网，操作系统，c++问到了崩溃，近1年没刷算法题，裸写过程出了N多问题，被淘汰也是当然的了吧。其中比较感慨的是，字节面试的时候和一个面试官聊了很多图形渲染相关的知识，即便基础答的不好也让过了(很感谢认真看了简历的面试官)。盛趣面试也和面试官聊渲染比较舒服，但因为一些偏执选择了让面试官帮忙改递TA岗位。。。据说是偏A的TA，然后就失去了消息。。。看了一段时间轻小说(地错)，自身也逐渐从低沉的状态开始脱离出来，无论再怎么失败，只要坚持自己的信念一定会有好结果的q.顺便羡慕男主和女神的相遇,有了收留自己的眷族。那么收留我的眷族又在哪里呢？一起努力过一段时间的朋友虾兄也成功上岸TA了，继续努力吧，填坑程序化建模Go!

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注