24 Hours – 第 5 页 – Pancake's Personal Website

树莓派4b jupyter frp端口映射

树莓派 frpc 设置：
从 github 中找到 arm 版本 wget 下载
frpc.ini 参考配置

[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

[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端口

[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

[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 参考配置：

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;
    }
}

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

全部是正确答案，慎用。Adams和Milne需要用另外的算法如runge-kutta（代码示例求法）求前3个数，当然也可以用Euler和Euler Improved，大家不要都一样啦。Python缩进规范请注意！

Python Euler Improved

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

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

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

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

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

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

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
            y += delta
            y_dot.append(function(a + (i + 4) * h, y))
    return y

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

y += delta

y_dot.append(function(a + (i + 4) * h, y))

return y

Python Milne

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(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):
            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]

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(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):

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]

计算数学 ODE Python参考代码

class ODE:
    def __init__(self, function, x0, y0):
        self.function = function
        self.x0 = x0
        self.y0 = y0

    def euler(self, h, step):
        result = []
        pre_y = self.y0
        for i in range(step):
            x = self.x0 + i * h
            fy = self.function(x, pre_y)
            y = pre_y + h * fy
            result.append(y)
            pre_y = y
            # print("y_{} = {}".format(i + 1, y))
        return result

    def eulerImproved(self, h, step):
        result = []
        pre_y = self.y0
        pre_fy = self.y0
        for i in range(step):
            x = self.x0 + (i + 1 / 2) * h
            yHalf = pre_y + pre_fy * h / 2
            fyHalf = self.function(x, yHalf)
            y = pre_y + h * fyHalf
            result.append(y)
            pre_y = y
            pre_fy = function(x + h / 2, y)
            # print("y_{} = {}".format(i + 1, y))
        return result

    def runge_kutta(self, h, step):
        result = []
        pre_y = self.y0
        for i in range(step):
            x = self.x0 + i * h
            k1 = h * self.function(x, pre_y)
            k2 = h * self.function(x + h / 2, pre_y + k1 / 2)
            k3 = h * self.function(x + h / 2, pre_y + k2 / 2)
            k4 = h * self.function(x + h, pre_y + k3)
            y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y
            result.append(y)
            pre_y = y
            # print("y_{} = {}".format(i + 1, y))
        return result

    def milne(self, h, step):
        y = [self.y0] + self.runge_kutta(h, 3)
        y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]
        for i in range(step - 3):
            y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))
            y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))
            y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])
            y_dot[-1] = function(self.x0 + (i + 4) * h, y[-1])
            # print("y_{} = {}".format(i + 4, y[-1]))
        return y[1:]

    def adams(self, h, step):
        y = [self.y0] + self.runge_kutta(h, 3)
        y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]
        for i in range(step - 3):
            y.append(y[-1] + (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h)
            y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))
            # print("y_{} = {}".format(i + 4, y[-1]))
        return y[1:]


if __name__ == "__main__":
    function = lambda x, y: y - 2 * x / y
    x0 = 0
    y0 = 1
    h = 0.002
    step = 1000
    ode = ODE(function, x0, y0)
    print(ode.euler(h, step)[-1])
    print("--------------------------------------------")
    print(ode.eulerImproved(h, step)[-1])
    print("--------------------------------------------")
    print(ode.runge_kutta(h, step)[-1])
    print("--------------------------------------------")
    print(ode.adams(h, step)[-1])
    print("--------------------------------------------")
    print(ode.milne(h, step)[-1])

class ODE:

def __init__(self, function, x0, y0):

self.function = function

self.x0 = x0

self.y0 = y0

def euler(self, h, step):

result = []

pre_y = self.y0

for i in range(step):

x = self.x0 + i * h

fy = self.function(x, pre_y)

y = pre_y + h * fy

result.append(y)

pre_y = y

# print("y_{} = {}".format(i + 1, y))

return result

def eulerImproved(self, h, step):

result = []

pre_y = self.y0

pre_fy = self.y0

for i in range(step):

x = self.x0 + (i + 1 / 2) * h

yHalf = pre_y + pre_fy * h / 2

fyHalf = self.function(x, yHalf)

y = pre_y + h * fyHalf

result.append(y)

pre_y = y

pre_fy = function(x + h / 2, y)

# print("y_{} = {}".format(i + 1, y))

return result

def runge_kutta(self, h, step):

result = []

pre_y = self.y0

for i in range(step):

x = self.x0 + i * h

k1 = h * self.function(x, pre_y)

k2 = h * self.function(x + h / 2, pre_y + k1 / 2)

k3 = h * self.function(x + h / 2, pre_y + k2 / 2)

k4 = h * self.function(x + h, pre_y + k3)

y = (k1 + 2 * k2 + 2 * k3 + k4) / 6 + pre_y

result.append(y)

pre_y = y

# print("y_{} = {}".format(i + 1, y))

return result

def milne(self, h, step):

y = [self.y0] + self.runge_kutta(h, 3)

y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]

for i in range(step - 3):

y.append(y[-4] + 4 * h / 3 * (2 * y_dot[-1] - y_dot[-2] + 2 * y_dot[-3]))

y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))

y[-1] = y[-3] + h / 3 * (y_dot[-1] + 4 * y_dot[-2] + y_dot[-3])

y_dot[-1] = function(self.x0 + (i + 4) * h, y[-1])

# print("y_{} = {}".format(i + 4, y[-1]))

return y[1:]

def adams(self, h, step):

y = [self.y0] + self.runge_kutta(h, 3)

y_dot = [function(self.x0 + i * h, y[i]) for i in range(4)]

for i in range(step - 3):

y.append(y[-1] + (55 * y_dot[-1] - 59 * y_dot[-2] + 37 * y_dot[-3] - 9 * y_dot[-4]) / 24 * h)

y_dot.append(function(self.x0 + (i + 4) * h, y[-1]))

# print("y_{} = {}".format(i + 4, y[-1]))

return y[1:]

if __name__ == "__main__":

function = lambda x, y: y - 2 * x / y

x0 = 0

y0 = 1

h = 0.002

step = 1000

ode = ODE(function, x0, y0)

print(ode.euler(h, step)[-1])

print("--------------------------------------------")

print(ode.eulerImproved(h, step)[-1])

print("--------------------------------------------")

print(ode.runge_kutta(h, step)[-1])

print("--------------------------------------------")

print(ode.adams(h, step)[-1])

print("--------------------------------------------")

print(ode.milne(h, step)[-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代码即可

#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;
}

#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中，代码写起来更简单，但是复杂度会变大很多很多。（但是能过就行）

#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;
}

#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;

}