来自杭州电子科技大学自动化专业的大二理工男一枚。
一只整个暑假都在学校学习的学生。
准备更新资料：无
b站同性交友帐号搜索：承包户
steam好友代码：241282993
喜欢的游戏：明日方舟、csgo、彩虹六号……
如果想联系我也可以加QQ：2114496089，请备注来意。
服务器简介
服务器主要功能为个人博客，于2021.7.1开始正式运营，为wordpress模板。
该博客会不定期更新个人学习到的知识进行分享，你也可以通过我的博客了解我。
请不要在此网站泄露任何个人信息，评论姓名等个人信息请匿名填写，个人不能保证此网站不被攻击，如果出问题请自行负责！请爱护服务器，大佬请不要无故攻击谢谢！请不要对服务器运行爬虫或各种压力测试软件，谢谢，服务器设置每秒访问上限，可能你会被封ip。服务器运行速度及网速可能稍慢，望见谅（有钱了买个好的）。
树莓派4b jupyter frp端口映射
树莓派 frpc 设置：
从 github 中找到 arm 版本 wget 下载
frpc.ini 参考配置
|
1 2 3 4 5 6 7 8 9 10 |
[common] server_addr = you server ip server_port = 7000 token = your password [jupyter] type = http local_ip = 127.0.0.1 local_port = 8888 custom_domains = your domain |
jupyter 设置跟之前文章相同，即 ip, allow_remote_access等设置
服务器端 frps 配置: 云端开启7000~7003端口
|
1 2 3 4 5 6 7 8 |
[common] bind_port = 7000 vhost_http_port = 7002 token = your password dashboard_port = 7001 dashboard_user = Your dashboard usr name dashboard_pwd = Your dashboard password vhost_http_port = 7003 |
云端 nginx 参考配置：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
server{ listen 80; listen [::]:80; server_name yourdomain; location / { proxy_pass http://127.0.0.1:7003; proxy_set_header X-Real-IP $remote_addr; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; proxy_read_timeout 120s; proxy_next_upstream error; } } |
最终效果即通过域名 python.pancake2021.work 访问树莓派 jupyter
计算数学 ODE LAB 3
全部是正确答案，慎用
Python Euler Improved
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
def solveByEulerImproved(f, epsilon, a, y_a, b): function = Result.get_function(f) n = 1 delta = float("inf") while abs(delta) >= epsilon / 10: n *= 2 h = (b - a) / n pre_y = y_a pre_fy = function(a, y_a) for i in range(n): x = a + (i + 1 / 2) * h yHalf = pre_y + pre_fy * h / 2 fyHalf = function(x, yHalf) y = pre_y + h * fyHalf delta = pre_y - y pre_y = y pre_fy = function(x + h / 2, y) return y |
Python Euler
Euler method 理论上代码正确，但是实际上因为算法的原因，与测试样例的值偏差会过大，要通过测试样例只需要初始化时把 n = 10000000
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
def solveByEuler(f, epsilon, a, y_a, b): function = Result.get_function(f) n = 1 delta = float("inf") while abs(delta) >= epsilon / 10: n *= 2 h = (b - a) / n pre_y = y_a for i in range(n): x = a + i * h fy = function(x, pre_y) y = pre_y + h * fy delta = pre_y - y pre_y = y return y |
Python Runge-Kutta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
def solveByRungeKutta(f, epsilon, a, y_a, b): function = Result.get_function(f) n = 1 delta = float("inf") while abs(delta) >= epsilon / 10: n *= 2 h = (b - a) / n pre_y = y_a for i in range(n): x = a + i * h k1 = h * function(x, pre_y) k2 = h * function(x + h / 2, pre_y + k1 / 2) k3 = h * function(x + h / 2, pre_y + k2 / 2) k4 = h * function(x + h, pre_y + k3) y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y delta = pre_y - y pre_y = y return y |
Python Adams
注释为修正公式，可用可不用
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
def runge_kutta(h, a, y_a, function): y_dot = [function(a, y_a)] pre_y = y_a for i in range(3): x = a + i * h k1 = h * function(x, pre_y) k2 = h * function(x + h / 2, pre_y + k1 / 2) k3 = h * function(x + h / 2, pre_y + k2 / 2) k4 = h * function(x + h, pre_y + k3) y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y y_dot.append(function(x + h, y)) pre_y = y return y, y_dot def solveByAdams(f, epsilon, a, y_a, b): function = Result.get_function(f) n = 2 delta = float("inf") while abs(delta) >= epsilon / 10: n *= 2 h = (b - a) / n y, y_dot = Result.runge_kutta(h, a, y_a, function) for i in range(n - 3): delta = (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h # delta = h / 24 * (y_dot[-3] - 5 * y_dot[-2] + 19 * y_dot[-1] + 9 * function((i + 4) * h, y + delta)) y += delta y_dot.append(function(a + (i + 4) * h, y)) return y |
Python Milne
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
def runge_kutta(h, a, y_a, function): y_dot = [function(a, y_a)] y_ = [y_a] pre_y = y_a for i in range(3): x = a + i * h k1 = h * function(x, pre_y) k2 = h * function(x + h / 2, pre_y + k1 / 2) k3 = h * function(x + h / 2, pre_y + k2 / 2) k4 = h * function(x + h, pre_y + k3) y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y y_dot.append(function(x + h, y)) y_.append(y) pre_y = y return y_, y_dot def solveByMilne(epsilon, a, y_a, b): function = Result.get_function(f) n = 2 delta = float("inf") while abs(delta) >= epsilon / 10: n *= 2 h = (b - a) / n y, y_dot = Result.runge_kutta(h, a, y_a, function) for i in range(n - 3): y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3])) y_dot.append(function(a + (i + 4) * h, y[-1])) y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3]) delta = y[-1] - y[-2] y_dot[-1] = function(a + (i + 4) * h, y[-1]) return y[-1] |
Timus #1162. Currency Exchange
题目：一共N个货币种类，当前为S种类的货币，当前拥有的该货币价值为V，下面M行包含可以交换货币的汇率/手续费信息：A,B,RAB,CAB,RBA,CBA分别代表种类A，种类B，A到B的汇率，A到B的手续费，B到A的汇率，B到A的手续费。求能否通过某种交换方式能让货币越来越多即大于V。
解析：Bellman-Ford。修改#1450代码即可
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
#include<iostream> #include<vector> #include<queue> #define INF 0x3f3f3f3f using namespace std; int n, m, s; float v; struct Currency { Currency() { money = INF; done = false; } //neighbor_index rate commission vector<pair<int, pair<float, float>>> neighbor; float money; bool done; }currency[100]; void SPFA() { queue<int> q; currency[s - 1].money = -v; q.push(s - 1); while (!q.empty()) { int x = q.front(); q.pop(); currency[x].done = false; for (auto ptr = currency[x].neighbor.begin(); ptr != currency[x].neighbor.end(); ptr++) { if (currency[ptr->first].money > -(-currency[x].money - ptr->second.second) * ptr->second.first) { currency[ptr->first].money = -(-currency[x].money - ptr->second.second) * ptr->second.first; if (!currency[ptr->first].done) { currency[ptr->first].done = true; q.push(ptr->first); } } } } if (currency[s - 1].money < v)return; } int main() { //货币种类 下面共几行 当前货币种类 当前拥有的该货币价值 cin >> n >> m >> s >> v; for (int i = 0; i < m; i++) { int a, b; float rab, cab, rba, cba; cin >> a >> b >> rab >> cab >> rba >> cba; currency[a - 1].neighbor.push_back(make_pair(b - 1, make_pair(rab, cab))); currency[b - 1].neighbor.push_back(make_pair(a - 1, make_pair(rba, cba))); } SPFA(); if (-currency[s - 1].money <= v) cout << "NO" << endl; else cout << "YES" << endl; } |
Timus #1160. Network
题目：有N个路由器，给出M个无向连接方式及其长度，需要将所有点可以连接起来，找到最大的连接长度中最小的。但是输出的时候输出总长度没啥关系，你可以输出很多长度小于最小的最大连接长度的点的关系。
解析：最小生成树算法。
我的代码很垃圾，模仿Prim算法，但是把所有相邻信息升序保存在neighbor中，代码写起来更简单，但是复杂度会变大很多很多。（但是能过就行）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
#include<iostream> #include<set> #include<vector> using namespace std; set<pair<int, pair<int, int>>>neighbors; set<int>node; set<pair<int, pair<int, int>>>result; bool in(int i) { set<int>::iterator ptr = node.find(i); if (ptr != node.end()) return 1; else return 0; } int main() { int n, m; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; neighbors.insert(make_pair(c, make_pair(a - 1, b - 1))); } pair<int, int>connection; int cost; bool a, b; node.insert(neighbors.begin()->second.first); while (node.size() != n) { auto ptr = neighbors.begin(); while (1) { cost = ptr->first; connection = ptr->second; a = in(connection.first); b = in(connection.second); if (!a && !b) { ptr++; continue; } if (a && !b) { node.insert(connection.second); result.insert(make_pair(cost, make_pair(connection.first, connection.second))); } if (!a && b) { node.insert(connection.first); result.insert(make_pair(cost, make_pair(connection.first, connection.second))); } ptr = neighbors.erase(ptr); break; } } cout << (--result.end())->first << endl; cout << result.size() << endl; for (auto i : result) cout << i.second.first + 1 << " " << i.second.second + 1 << endl; return 0; } |
Timus #1450. Russian Pipelines
题目：有n个点，接下来输入m行，表示从a点到b点有向边距离为c，求从S（start）起点到F（Final）终点最大路径。
解析：求最大路径问题
1. Bellman-Ford算法
2. 拓扑，利用入度（In-degree）。从入度等于0（只可能有出度）的点开始拓扑，相邻的点入度-1代表还剩in-degree个点还没拓扑到他，如果该点所有可到他的点均已经寻找完，则把该点加入queue，即可以从该点进行下一步拓扑。
错误提示：
1. WA3 Dijskra算法写错
2. TLE16 Dijskra算法因为只要小于就要加入queue，比入度算法复杂度高，不要用Dijskra改版算法，换算法
3. WA9和WA10。小部分神奇原因：输出强制类型转换成int。大部分原因：不要第一个就从开始点开始拓扑（我也不知道为什么，就是错的）。
Bellman-Ford算法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
#include<iostream> #include<unordered_map> #include<vector> #include<queue> #define INF 0x3f3f3f3f using namespace std; int n, m, beginPoint, endPoint; struct Point { Point() { distence = INF; done = false; } vector<pair<int, int>> neighbor; long long distence; bool done; }point[500]; void SPFA() { queue<int> q; point[beginPoint - 1].distence = 0; q.push(beginPoint - 1); while (!q.empty()) { int x = q.front(); q.pop(); point[x].done = false; for (auto ptr : point[x].neighbor) { if (point[ptr.first].distence > point[x].distence - ptr.second) { point[ptr.first].distence = point[x].distence - ptr.second; if (!point[ptr.first].done) { point[ptr.first].done = true; q.push(ptr.first); } } } } } int main() { cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; point[a - 1].neighbor.push_back(make_pair(b - 1, c)); } cin >> beginPoint >> endPoint; SPFA(); if (point[endPoint - 1].distence == INF) cout << "No solution" << endl; else cout << -point[endPoint - 1].distence << endl; } |
In-degree
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
#include<iostream> #include<unordered_map> #include<vector> #define INF 0x3f3f3f3f using namespace std; int n, m, beginPoint, endPoint; struct Point { Point() { distence = -INF; } unordered_map<Point*, int> neighbor; long long distence; int degree; }point[500]; void extend() { vector<Point*>queue; point[beginPoint - 1].distence = 0; Point* now; unordered_map<Point*, int>::iterator ptr; for (int i = 0; i < n; i++) if (point[i].degree == 0) queue.push_back(&point[i]); while (!queue.empty()) { now = *queue.begin(); queue.erase(queue.begin()); for (ptr = now->neighbor.begin(); ptr != now->neighbor.end(); ptr++) { ptr->first->distence = max(ptr->first->distence, now->distence + ptr->second); ptr->first->degree--; if (ptr->first->degree == 0) queue.push_back(ptr->first); } if (point[endPoint - 1].degree == 0) return; } } int main() { cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; point[a - 1].neighbor.insert({ &point[b - 1], c }); point[b - 1].degree++; } cin >> beginPoint >> endPoint; extend(); if (point[endPoint - 1].distence < 0) cout << "No solution" << endl; else cout << point[endPoint - 1].distence << endl; } |
浙公网安备 33010902002953号