筆記 on Aminiam's Blog

C CPP 解包

Fri, 09 Oct 2026 14:49:53 +0800

`C`可變參數解包

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdarg.h>

int sum(int n, ...)
{
 va_list ap;
 va_start(ap, n);

 int ans = 0;

 for (int i = 0; i < n; ++i)
 ans += va_arg(ap, int);

 va_end(ap);
 return ans;
}

int main()
{
 printf("%d\n", sum(4, 1, 3, 5, 7));
 return 0;
}

1

16

C++ 可變參數模板與遞歸解包

方式一：遞歸解包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <iostream>

using namespace std;

template<typename T>
T maxn(T a) { return a; }

template<typename T, typename... Args>
T maxn(T a, Args... rest)
{
 T b = maxn(rest...);
 return a > b ? a : b;
}

int main()
{
 cout << maxn<double>(1.1, 2.2, 3.3) << endl;
 return 0;
}

方法二：摺疊表達式

類型	寫法	展開結果
一元左摺疊	`(... + args)`	`((a + b) + c)`
一元右摺疊	`(args + ...)`	`(a + (b + c))`
二元左摺疊	`(0 + ... + args)`	`(((0 + a) + b) + c)`
二元右摺疊	`(args + ... + 0)`	`(a + (b + (c + 0)))`

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <iostream>

using namespace std;

template<typename T, typename... Args>
T maxn(T a, Args... args)
{
 ((a = a > args ? a : args), ...);
 return a;
}

int main()
{
 cout << maxn<double>(1.1, 2.2, 3.3, 4.4) << endl;
 return 0;
}

完美轉發

1
2
3
4
5
6
7


#include <utility>

template<typename T>
void wrapper(T&& x)
{
 process(std::forward<T>(x));
}

1
2


template<typename... Args>
void print(Args&&... args) { std::cout << ... <<< std::forward<Args>(args) }

Notes for C

Thu, 17 Sep 2026 13:55:05 +0800

C

register
volatile：指定變量可能被外部修改，每次都應重新讀取，不應相信緩存
1.5: double, 1.5f: float, 1.5L: long double
fabs(x - y) < \varepsilon $\leftrightarrow$ $|x - y| <\varepsilon$; fabs(x - y) < fabs(x * \varepsilon) $\leftrightarrow$ $|x-y|<|x|\varepsilon$

轉義字符：

字符	含義
`\b`	backspace
`\r`	回車，光標移動到行首
`\t`	tab
`\v`	vertical tab
`\f`	走紙換頁
`\\`
`\"`
`\'`
`\ddd`	三位八進制
`\xdd`	兩位十六進制

格式輸入輸出
逗號表達式：從左向右依次計算，最後一個表達式的值作爲表達式運算的結果
只有一元、三元、賦值運算的結合性爲從右向左
隱式轉換規則：short, char -> int -> unsigned int -> long -> unsigned long -> float -> double -> long double
字符串拼接：
- 方式一：'\'自動拼接
- 方式二：“A ““B” = “A B”：相連的字符串常量自動拼接
scanf("%d", s)會在空格中止，gets(s)會在行尾中止

<cstring>:

function	def
strlen()
strcpy(s1, s2)	s2複製到s1
strncpy(s1, s2, n)	將s2中前n個字符複製到s1
strcat(s1, s2)	將s2追加到s1中
strcmp(s1, s2)	返回字典序`s1 > s2 ? :`
strlwr(s)	覆寫s爲lowercase
strupr(s)	覆寫s爲uppercase
puts(s)	`printf("%s", s)`
gets()

Notes for Pandas

Wed, 09 Sep 2026 11:30:40 +0800

Pandas Basics

Here we import numpy, pandas as:

1
2


import numpy as np
import pandas as pd

Basic data structures in pandas

pandas provides two types of classes fro handling data:

Series: a one-dimansional labeled array holding data of any type, such as integers, strings, Python objects, etc.
DataFrame: a two-dimensional data structure that holds data like a two-dimension array or a table with rows and columns.

Object creation

Creating a Series by passing a list of values, letting pandas create a default RangeIndex

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> import numpy as np
>>> import pandas as pd
>>> s = pd.Series([1, 3, 5, np.nan, 6, 8])
>>> s
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64

Creating a DataFrame by passing a NumPy array with a datetime index using date_range() and labeled columns:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> dates = pd.date_range("20260909", periods=6)
>>> dates
DatetimeIndex(['2026-09-09', '2026-09-10', '2026-09-11', '2026-09-12',
 '2026-09-13', '2026-09-14'],
 dtype='datetime64[ns]', freq='D')
>>> df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
>>> df
 A B C D
2026-09-09 0.956212 0.496608 1.031761 0.439333
2026-09-10 -0.283260 0.644414 -0.352740 -0.617138
2026-09-11 0.667249 1.570810 -1.711173 1.114610
2026-09-12 -0.324996 -0.441097 0.821568 -0.425018
2026-09-13 0.981316 0.504753 1.098882 0.498294
2026-09-14 0.433741 0.992282 -0.737600 1.621099

Notes for Matplotlib

Sat, 05 Sep 2026 10:13:30 +0800

Pyplot Basics

Introduction to pyplot

matplotlib.pyplot is a collection of functions that make matplotlib work like MATLAB. Each pyplot function makes some change to a figure: e.e., creates a figure, creates a plotting area in a figure, plots some lines in a plotting area, decorates the plot with labels, etc.

In matplotlib.pyplot various states are preserved across function calls, so that it keeps track of things like the current figure and plotting area, and the plotting functions are directed to the current Axes (please note that we user uppercase Axes to refter to the Axes concept, which is a central part of a figure and not only the plural of axis).

1
2
3
4


import matplotlib.pyplot as plt
plt.plot([1, 3, 3, 4])
plt.ylabel('some numbers')
plt.show()

If your provide a single list or array to plot, matplotlib assumes it i a sequence of y values, and automatically generates the x values for you. Since python ranges start with 0, the default x vector has the same length as y but starts with 0; there fore, the x data are [0, 1, 2, 3].

plot is a versatile function, and will take an arbitrary number of arguments. For example, to plot x versus y, you can write:

1

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])

Formatting the style of you plot

For every x, y pair of arguments, there is an optional third argument which is the format string that indicates the color and line type of the plot. The letters and symbols of the format string are from MATLAB, and you concatenate a color string with a line style string. The default format string is ‘b-’, which is a solid blue line. For example, to plot the above with red circles, you would issue.

1
2
3


plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis((0, 6, 0, 20))
plt.show()

The axis function in the example above takes a list of [xmin, xmax, ymin, ymax] and specifies the viewport of the Axes.

Generally, you will use numpy arrays.

1
2
3
4
5
6


import numpy as np
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Plot with keyword strings

There are some instances where you have data in a format theat lets you access particular variables with strings. For example, with strctured arrays or pandas.DataFrame.

Matplotlib allows you to provide such an object with the data keyword argument. I fprovided, the you may generate plots with the strings corresponding to these variables.

1
2
3
4
5
6
7
8
9


data = {'a': np.arange(50),
 'c': np.random.randint(0, 50, 50),
 'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100
plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Plotting with categorical variables

It is also possible to create a plot using categorical variables. Matplotlib allows you to pass categorical variables directly to many plotting functions. For example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]
plt.figure(figsize=(9, 3))
plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Controlling line properties

Lines have many attributes that you can set: linewidth, dash style, antialiased, etc. There are several ways to set line properties:

Use keyword arguments

1

plt.plot(x, y, linewidth=2.0)

Use the setter methods of a Line2D instance. plot returns a list of Line2D objects; e.g., line1, line2 = plot(x1, y1, x2, y2). In the code below we will suppose that we have only one line so that the list returned is of length 1. We use tuple unpacking with line, to get the first element of that list:

1
2


line, = plt.plot(x, y, '-')
line.set_antialiased(False) # turn off antialiasing

Use setp. The example below uses a MATLAB-style function to set multiple properties on a list of lines. setp works transparently with a list of objects or a single object. You can either use python keyword arguments or MATLAB-style string/value pairs:

1
2
3
4
5


lines = plt.plot(x1, y1, x2, y2)
# use keyword arguments
plt.setp(lines, color='r', linewidth=2.0)
# or MATLAB style string value pairs
plt.setp(lines, 'color', 'r', 'linewidth', 2.0)

Working with multiple figures and Axes

MATLAB, and pyplot, have the concept of the current figure and the current Axes. All plotting functions apply to the current Axes. The gunction gca returns the current figure (A matplotlib.axes.Axes instance), and gcf returns the current figure (a matplotlib.figure.Figure instance). Normally, you don’t have to worry about this, becase it is all taken care of behind the scenes. Below is a script to create two subplots.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def f(t):
 return np.exp(-t) * np.cos(2 * np.pi * t)
t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2 * np.pi * t2), 'r--')
plt.show()

The figure call here is optional because a figure will be created if none exists, just as an Axes will be created (equivalent to an explicit subplot() call) if none exists. The subplot call specifies numrows, numcols, plot_number where plot_number ranges from 1 to numrowsnumcols. The commas in the subplot call are optional if numrowsnumcols<10. So subplot(211) is identical to subplot(2, 1, 1).

1
2
3
4
5


plt.subplot(
 [nrows](n rows of plots will be created),
 [ncols](n cols of plots will be created),
 [index](start from 1, L2R, T2B)
)

You can create an arbitrary number of subplots and Axes. If you want to place an Axes manually, i.e., not on a rectangular grid, use axes, which allows you to specify the location as axes([left, bottom, width, height]) where all values are in fractional (0 to 1) coordinates. See Axes Demo for an example of placing Axes manually and Multiple subplots for an example with lots of subplots.

You can create multiple figures by using multiple figure calls with an increasing figure number. Of course, each figure can contain as many Axes and subplots as your heart desires:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import matplotlib.pyplot as plt
plt.figure(1) # the first figure
plt.subplot(211) # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212) # the second subplot in the first figure
plt.plot([4, 5, 6])

plt.figure(2) # a second figure
plt.plot([4, 5, 6]) # creates a subplot() by default

plt.figure(1) # first figure current;
 # subplot(212) still current
plt.subplot(211) # make subplot(211) in the first figure
 # current
plt.title('Easy as 1, 2, 3') # subplot 211 title

You can clear the current figure with clf and the current Axes with cla. If you find it annoying that states (specifically the current image, figure and Axes) are being maintained for you behind the scenes, don’t despair: this is just a thin stateful wrapper around an object-oriented API, which you can use instead (see Artist tutorial)

If you are making lots of figures, you need to be aware of one more thing: the memory required for a figure is not completely released until the figure is explicitly closed with close. Deleting all references to the figure, and/or using the window manager to kill the window in which the figure appears on the screen, is not enough, because pyplot maintains internal references until close is called.

Working with text

text can be used to add text in an arbitrary location, and xlabel, ylabel and title are used to add text in the indicated locations.

1
2
3


mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)
# the histogram // TODO from here

MATLAB format string

1

plt.plot(x, y, fmt)

here:

1

fmt = '[marker][line][color]'

Marker styles

Code	Marker	Meaning
`.`	point	small dot
`o`	circle	○
`s`	square	□
`^`	triangle up	△
`v`	triangle down	▽
`<`	triangle left
`>`	triangle right
`*`	star	★
`+`	plus	+
`x`	cross	×
`D`	diamond	◇

Line styles

Code	Style	Appearance
`-`	solid	━━━━━
`--`	dashed	- - - -
`-.`	dash-dot	-·-·-
`:`	dotted	·····

Colour codes

Code	Colour	Example
`b`	blue	`'b'`
`g`	green	`'g'`
`r`	red	`'r'`
`c`	cyan	`'c'`
`m`	magenta	`'m'`
`y`	yellow	`'y'`
`k`	black	`'k'`
`w`	white	`'w'`

序列解包

1

line, = plt.plot(x, y, '-')

plt.plot()返回一个列表，其中包含所绘制的line2D对象（即使只有一条线，也是长度为$1$的列表）

line,是一个单元素元组（逗号作为必须的标识符），它要求右侧的可迭代对象恰好有一个元素

解包过程将列表中的唯一一个line2D对象提取出来，赋值给line

等价于：

1

line = plt.plot(x, y, '-')[0]

MCM 常用方法 Python 版

Wed, 02 Sep 2026 21:35:33 +0800

層次分析法 AHP（Analytic Hierarchy Process）

問題背景

決策目標涉及多個難以統一量綱衡量的因素時，需要有一種方法把專家的主管判斷轉化爲客觀權重。

與其直接問某因素的權重，不如讓專家兩兩比較“A比B”重要多少倍。

兩兩比較的結果構成判斷矩陣$(A_{ij}) _ {n\times n}$，其中$a_{ij}$表示因素$i$相對於$j$的重要程度，採用如下標度法：

標度	含義
1	同等重要
3	稍微重要
5	明顯重要
7	強烈重要
9	極端重要
2,4,6,8	中間值

性質

矩陣滿足互反性：$a_{ij}a_{ji}=1$，對角線$a_{ii}=1$

若專家的判斷具有完全一致性，則存在權重向量$(\omega)_n$使得：

$$ a_{ij} = \frac{\omega_i}{\omega_j} $$

此時矩陣$A$可以寫成列向量與行向量的乘積形式。

下面證明權重向量就是特徵向量：

$$ (A\omega)_i=\sum_j{a_{ij}\omega_j}=n\omega_i\space\square $$

現實中專家判斷難免有偏差，矩陣不完全已知，但可以證明此時最大的特徵值$\lambda_{max}\ge n$，且當$\lambda_{max}$越接近$n$，矩陣一致性越好。於是去最大特徵值對應的特徵向量，歸一化後作爲權重。

一致性檢驗

定義一致性指標：

$$ CI=\frac{\lambda_{max}-n}{n-1} $$

再用隨機一致性指標$RI$（查表可知，反映隨機矩陣的平均$CI$）做歸一化：

$$ CR=\frac{CI}{RI} $$

當$CR<0.1$認爲矩陣一致性可以接受。

Python實現

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import numpy as np

def ahp_analysis(A):
 n = A.shape[0]
 eigvals, eigvecs = np.linalg.eig(A) # 計算特徵值和特徵向量
 max_idx = np.argmax(eigvals.real) # 數值計算可能有小虛部，並找到最大特徵值位置
 lambda_max = eigvals[max_idx].real # 提取最大特徵值
 w = eigvecs[:, max_idx].real # 提取對應特徵向量
 weights = w / w.sum() # 歸一化
 # 一致性檢驗：
 CI = (lambda_max - n) / (n - 1)
 RI_table = {1:0, 2:0, 3:0.58, 4:0.90, 5:1.12, 6:1.24, 7:1.32, 9:1.41}
 RI = RI_table[n]
 CR = CI / RI
 # return
 return weights, CR

 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


>>> import numpy as np
>>> A = np.array([[1, 3, 1.0 / 3.0], [1.0 / 3.0, 1\
, 1.0 / 5.0], [3, 5, 1]])
>>> n = A.shape[0]
>>> eigvals, eigvecs = np.linalg.eig(A)
>>> print(eigvals)
[ 3.03851109+0.j -0.01925555+0.34153419j -0.01925555-0.34153419j]
>>> print(eigvecs)
[[ 0.37147738+0.j 0.18573869-0.32170885j 0.18573869+0.32170885j]
 [ 0.1506267 +0.j 0.07531335+0.13044655j 0.07531335-0.13044655j]
 [ 0.916142 +0.j -0.916142 +0.j -0.916142 -0.j ]]
>>> max_idx = np.argmax(eigvals.real)
>>> print(max_idx)
0
>>> lambda_max = eigvals[max_idx].real
>>> print(lambda_max)
3.0385110905581696
>>> w = eigvecs[:, max_idx].real
>>> print(w)
[0.37147738 0.1506267 0.916142 ]
>>> weights = w / w.sum()
>>> print(weights)
[0.25828499 0.10472943 0.63698557]
>>> CI = (lambda_max - n) / (n - 1)
>>> print(CI)
0.019255545279084796
>>> RI_table = {1:0, 2:0, 3:0.58, 4:0.90, 5:1.12, \
6:1.24, 7:1.32, 9:1.41}
>>> RI = RI_table[n]
>>> CR = CI / RI
>>> print(CR)
0.033199215998422064

1

np.argmax(...) // 找到數組中最大值的索引位置

TOPSIS法（逼近理想解排序法）

TOPSIS (Tecnique for Order Preference by Similarity to Ideal Solution)

一個好的方案，應該離最優解情況最近，同時離最差情況最遠。

性質

設有$m$個評價對象，$n$個指標，決策矩陣爲$X=(x_{ij})_{m\times n}$。

正向化：若指標是“越小越好”型，先轉化爲“越大越好”型，常用取倒數或者$max-x$的方式
歸一化（消除兩綱影響），常用向量歸一化：$\displaystyle z_{ij}=\frac{x_{ij}}{\sqrt{\sum_{i=1}^m{x_{ij}^2}}}$。
加權（結合AHP或熵權法得到的權重$\omega_j$）：$v_{ij}=\omega_j z_{ij}$。
確定正負理想解：$Z^+=(\max_iv_{i1},\cdots,\max_iv_{in}$，$Z^+=(\min_iv_{i1},\cdots,\min_iv_{in}$
計算歐氏距離與貼近度：
$$ D_i^+=\sqrt{\sum_j{(v_{ij}-Z_j^+)^2}} $$$$ D_i^-=\sqrt{\sum_j{(v_{ij}-Z_j^-)^2}} $$$$ C_i=\frac{D_i^-}{D_i^++D_i^-}\in[0,1] $$

顯然$C_i$越接近$1$，該方案越優。

Python實現

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


import numpy as np

def topsis(data, weights, indicator_types):
 X = data.astype(float) # 將數據強制轉化成float
 m, n = X.shape
 # 1. 正向化（如果是極小性，則翻轉）
 for j in range(n):
 if indicator_types[j] == 'min':
 X[:, j] = np.max(X[:, j]) - (X[:, j])
 # 2. 向量歸一化（按列歸一化）
 norm-factor = np.sqrt(np.sum(X**2, axis=0)) # axis=0是列，1是行
 Z = X / norm_factor # 廣播
 # 3. 加權
 V = Z * weights # 區別@，這裏是對應元素相乘
 # 4. 正負理想解
 Z_pos = V.max(axis=0)
 Z_neg = V.min(axis=0)
 # 5. 計算歐氏距離
 D_pos = np.sqrt(np.sum((V - Z_pos)**2, axis=1))
 D_neg = np.sqrt(np.sum((V - Z_neg)**2, axis=1))
 # 6. 貼近度
 C = D_neg / (D_pos + D_neg + 1e-8)
 # return
 return C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


>>> import numpy as np
>>> data = np.array([[5, 5, 10], [8, 8, 5]])
>>> weights = [0.25828499, 0.10472943, 0.63698557]
>>> X = data.astype(float)
>>> m, n = X.shape
>>> norm_factor = np.sqrt(np.sum(X**2,axis=0))
>>> Z = X / norm_factor
>>> V = Z * weights
>>> Z_pos = V.max(axis=0)
>>> Z_neg = V.min(axis=0)
>>> D_pos = np.sqrt(np.sum((V - Z_pos)**2, axis=1)\
)
>>> D_neg = np.sqrt(np.sum((V - Z_neg)**2, axis=1)\
)
>>> C = D_neg / (D_pos + D_neg + 1e-8)
>>> print(C)
[0.76270391 0.23729606]

最小二乘擬合與迴歸

性質

設擬合模型爲$\hat{y}=P_k(x)=\sum_i\beta_ix^k$，定義殘差平方和：

$$ S(\beta) = \sum_i(y_i-\hat{y}_i)^2 $$

最小二乘法的目標是找到使$S(\beta)$最小的參數$\beta$。

推導正規方程：將模型寫作$y=X\beta+\varepsilon$，其中$X$是範德蒙德矩陣（每行爲：$[1,x_i,x_i^2,\cdots,x_i^k]$），展開$S(\beta)$：

$$ S(\beta)=(y-X\beta)^T(y-X\beta)=y^Ty-2\beta^TX^Ty+\beta^TX^TX\beta $$

對$\beta$求梯度並令其爲零：

$$ \frac{\partial S}{\partial\beta}=-2X^Ty+2X^TX\beta=0 $$

解得正規方程：

$$ X^TX\beta=X^Ty $$

當$X$列滿秩時，$\beta=(X^TX)^{-1}X^Ty$

證明其最優性（高斯-馬爾可夫定理，BLUE）：略

Python實現

 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


import numpy as np

class LinearRegression:
 def __init__(self):
 self.coef_ = None
 self.intercept_ = None
 self.r2_ = None

 def fit(self, X, y):
 # X: （樣本數，特徵數），y: （樣本數，）
 # 構造增廣矩陣：在X左邊加一列1，用來計算解決
 X_design = np.c_[np.ones(X.shape[0]), X]
 
 beta = np.linalg.inv(X_design.T @ X_design) @ X_design.T @ y
 self.intercept_ = beta[0]
 self.coef_ = beta[1:]
 
 y_pred = self.predict(X)
 ss_res = np.sum((y - y_pred)**2)
 ss_tot = np.sum((y - np.mean(y))**2)
 self.r2_ = 1 - ss_res / ss_tot
 
 return self
 
 def predict(self, X):
 return X @ self.coef_ + self.intercept_

 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
58
59
60
61
62
63
64
65
66
67
68
69


import numpy as np

# 一维数组（形状: (3,) ）
a1 = np.array([1, 2, 3])
b1 = np.array([4, 5, 6])

# 二维数组（形状: (2, 2) ）
a2 = np.array([[1, 2], 
 [3, 4]])
b2 = np.array([[5, 6], 
 [7, 8]])
# 第一部分：按列左右拼接 (Horizontal / 增加列数)
# np.hstack —— 对一维数组：保持一维，直接延长（拼接元素）
res_hstack_1d = np.hstack((a1, b1))
# 输出: [1 2 3 4 5 6] (6,)

# np.c_ —— 对一维数组：转成列向量，形成二维矩阵（增加列数）
# 相当于把 a1 和 b1 看作两列特征，形状从 (3,) + (3,) -> (3, 2)
res_c_1d = np.c_[a1, b1]
# 输出: [[1 4] (3, 2)
# [2 5]
# [3 6]]

# np.column_stack —— 和 np.c_ 效果完全一样（一维数组当列处理）
res_col_stack = np.column_stack((a1, b1))
print(f"column_stack 一维结果: \n{res_col_stack}, 形状: {res_col_stack.shape}")

# 针对二维数组：hstack、c_、concatenate(axis=1) 三者等价
res_hstack_2d = np.hstack((a2, b2))
res_c_2d = np.c_[a2, b2]
res_concat_axis1 = np.concatenate((a2, b2), axis=1) # axis=1 代表列方向
{res_hstack_2d.shape}")
# 输出: [[1 2 5 6] (2, 4)
# [3 4 7 8]]

# 不要对一维数组用 concatenate(axis=1)，因为一维没有 axis=1 维度

# np.vstack —— 对一维数组：转成行向量，上下堆叠（增加行数）
# 相当于把 a1 和 b1 看作两行样本，形状从 (3,) + (3,) -> (2, 3)
res_vstack_1d = np.vstack((a1, b1))
# 输出: [[1 2 3] (2, 3)
# [4 5 6]]

# np.r_ —— 对一维数组：直接合并延长（和 vstack 不同！r_ 对一维是延长）
# r_ 对一维数组的行为是“合并元素”，类似 hstack（特殊）
res_r_1d = np.r_[a1, b1]
# 输出: [1 2 3 4 5 6] (6,)

# 针对二维数组：vstack、r_、concatenate(axis=0) 三者等价
res_vstack_2d = np.vstack((a2, b2))
res_r_2d = np.r_[a2, b2]
res_concat_axis0 = np.concatenate((a2, b2), axis=0) # axis=0行方向（默认值）
# 输出: [[1 2] (4, 2)
# [3 4]
# [5 6]
# [7 8]]

# np.row_stack —— np.vstack 的别名
res_row_stack = np.row_stack((a2, b2))

# 增加新维度拼接 (np.stack)
# np.stack 会在指定位置创建一个新的维
res_stack_axis0 = np.stack((a1, b1), axis=0) # 新维度在第0层（第0轴变成2）
res_stack_axis1 = np.stack((a1, b1), axis=1) # 新维度在第1层（第1轴变成2）
# 输出: [[1 2 3] (2, 3)
# [4 5 6]]
# 输出: [[1 4] (3, 2)
# [2 5]
# [3 6]]

1
2
3


X.T # 转置
np.linalg.inv() # 求逆
x.reshape(-1, 1) # 将一维数组变成二维列向量。`-1`表示自动计算行数

Sudoku Solver: Bitmask & MRV

Wed, 02 Sep 2026 13:28:15 +0800

Sudoku Solver

LeetCode 原题地址：37. Sudoku Solver

狀態壓縮：Bitmask

使用$9$位的二進制整數分別表示$1\to9$。

標記佔用：rows[r] |= (1 << (d - 1))

撤銷佔用：rows[r] ^= (1 << (d - 1))

計算候選數：used = rows[r] | cols[c] | boxes[b]，那麼可用數字：available = (~used) & 0b111111111（取反後保留低$9$位）

MRV(Minimum Remaining Values)：最小剩餘值啓發式

先填最難的。

比如：有一個空格，行裏缺{1, 2}，列裏缺{1, 2, 3}，宮裏缺{1}（唯一解），就優先填它。

這是在“最受限”的位置做決策。如果唯一解的地方都填錯了，說明之前的選擇有無，可以儘早回溯（Fail-First 原則）。反之如果先去填有$9$可能的空格，會浪費大量算力。

實現方法：在每一層遞歸開始時，掃描所有剩餘空格，找出available裏$1$個數最少的，交換到當前處理位置。

遍歷方法：位運算提取候選（Lowbit 技巧）

取最低位的1：bit = available & -available
Count Trailing Zeros：d = __builtin_ctz(bit)

算法流程：DFS 回溯

初始化：掃描整個棋盤，將已填數字更新到rows，cols，boxes中，同時記錄所有空格座標。
遞歸入口（backtrack(idx)）
- 終止條件：如果idx等於空格總數，說明填完了，返回true。
- MRV 選點：從idx到末尾遍歷所有空格，計算每個空格的available掩碼，統計1的個數，選出最小的那個，並交換到empties[idx]位置。
- 嘗試填入：獲取當前空格的available掩碼，利用lowbit去除每一個候選數字。
- 放置並遞歸：修改棋盤，更新rows/cols/boxes掩碼，調用backtrack(idx + 1)。
- 回溯撤銷：如果遞歸返回false，說明這條路走不通，撤銷掩碼，將棋盤改回'.'，嘗試下一個候選。
結果：一旦找到解，遞歸棧層層返回true，完成求解。

實現

emplace_back(r, c)就地構造，push_back(make_pair(r, c))或者push_back({r, c})會產生臨時變量，儘管對於一般的情況會被-O2優化。
function<bool(int)>通用函數包裝器，意爲任意一個接受int參數，並返回bool值的可調用對象（函數、仿函數、Lambda）。
[&]按引用捕獲，[=]按值捕獲。
std::function有微小性能損耗，大約$5%\to10%$，因爲底層使用了類型擦除，調用時會多一次間接尋址。追求極致可使用auto + Y-Combinator（不動點組合子）來替代以消除開銷。
idx表示当前处理到第idx个空格。

 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
58
59
60
61
62
63
64
65
66
67
68
69
70


class solution
{
 public:
 void solveSudoku(vector<vector<char>>& board)
 {
 int rows[9] = {0}, cols[9] = {0}, boxes[9] = {0};
 vector<pair<int, int>> empties;

 for (int r = 0; r < 9; ++r)
 for (int c = 0; c < 9; ++c)
 if (board[r][c] == '.')
 empties.emplace_back(r, c);
 else
 {
 int d = board[r][c] - '1';
 int mask = 1 << d;
 int b = (r / 3) * 3 + (c / 3);
 rows[r] |= mask;
 cols[c] |= mask;
 boxes[b] |= mask;
 }
 
 function<bool(int)> backtrack = [&](int idx) -> bool
 {
 if (idx == empties.size()) return true;

 int bestIdx = idx;
 int minCandidates = 10;
 for (int i = idx; i < empties.size(); ++i)
 {
 int r = empties[i].first, c = empties[i].second;
 int b = (r / 3) * 3 + (c / 3);
 int used = rows[r] | cols[c] | boxes[b];
 int available = (~used) & 0b111111111;
 int cnt = __builtin_popcount(available);
 if (cnt < minCandidates)
 {
 minCandidates = cnt;
 bestIdx = i;
 if (cnt == 1) break;
 }
 }
 if (bestIdx != idx) swap(empties[idx], empties[bestIdx]);
 int r = empties[idx].first, c = empties[idx].second;
 int b = (r / 3) * 3 + (c / 3);
 int used = rows[r] | cols[c] | boxes[b];
 int available = (~used) & 0b111111111;

 while (available)
 {
 int bit = available & -available;
 int d = __builtin_ctz(bit);
 available ^= bit;
 board[r][c] = char('1' + d);
 rows[r] |= bit;
 cols[c] |= bit;
 boxes[b] |= bit;

 if (backtrack(idx + 1)) return true;

 board[r][c] = '.';
 rows[r] ^= bit;
 cols[c] ^= bit;
 boxes[b] ^= bit;
 }
 return false;
 };
 backtrack(0);
 }
};

不動點組合子

經典錯誤寫法：

1
2
3
4


auto backtrack = [&](int idx) -> bool
{
 if (backtrack(idx + 1)) return true;
};

錯誤因爲backtrack還沒有聲明完，不能在內部調用。

普通解決方案，用std::function，但是存在性能損耗。

解決方案核心思想：把自己作爲參數傳遞進去：

1
2
3
4
5


auto backtrack = [](auto&& self, int idx) -> bool
{
 if (self(self, idx + 1)) return true;
 return false;
};

左值、右值和萬能引用`auto&&`

定義

任何一個cpp表達式在編譯器視角都有一下兩個獨立屬性：

擁有身份（Has Identity）：這個表達式是否代表一塊具體的內存地址？能否用&取到它的地址？
可被移動（Is Movable）：這個表達式的值是否允許被“竊取”（轉移資源），因爲它馬上就要被銷燬了？

基於以上兩個不二屬性，表達式分爲三大類：

左值：Lvalue，有身份
純右值：Prvalue，沒有（臨時寄存器）
亡值：Xvalue，有（即將被銷燬的對象）
右值：Rvalue，純右值或者亡值（要麼沒有地址，要麼瀕臨死亡）

1
2
3
4
5
6
7


int a = 10;
int b = a; // a 是左值，但是出現在等號右邊
&a; // 合法，取左值的地址
&10; // 非法，取右值的地址
// 但可以將右值轉化爲左值（亡值）：
int&& c = 10; // 將亡值綁定到右值引用上
&c; // 現在 c 有地址，它是亡值，屬於右值但是可取地址

分析

1
2


auto backtrack = [](auto&& self, int idx) { ... };
backtrack(backtrack, 0);

對於這裏的backtrack：

這是一個具名變量，編譯器爲它在棧上分配了內存
它擁有確定的內存地址，可以&backtrack
它不會在函數調用結束時銷燬（它處於外層作用域）

因此backtrack是一個左值，傳給auto&&後，推導爲左值引用Type&

對於0：

它不佔用靜態或棧上的內存，直接作爲立即數編碼在 CPU 的彙編指令集
它沒有任何內存地址
它是一個臨時值，函數調用完就丟棄

因此0是一個純右值，傳給int indx時發生拷貝

`T&&`

情況一：type是具體類型（無推導），這是一個右值引用，會拒絕左值。

情況二：type是推導佔位符（auto或template T），這是轉發引用，如果傳遞左值，摺疊爲T&，傳入右值，摺疊爲T&&。

std::move

std::move(a)是類型強轉，對於基礎類型：

1
2


int a = 1;
int b = std::move(a);

執行第二句時，編譯器查找int的構造函數，發現int沒有移動構造函數，於是移動退化爲拷貝，結果是a和b分別指向兩塊內存都儲存了1

對於資源類型：

1
2


vector<int> a = {1, 2, 3};
vector<int> b = std::move(a);

執行std::move(a)時a並未改變，執行vector<int> b = std::move(a);時，vector的移動構造函數完成三件事：

將b指向a本來指向的地址，並將a設置爲nullptr
將b的大小設置爲a的大小，並將a的大小設置爲0
將b的容量指向a的容量，並將a的容量歸零

構造函數初始化列表

節省先构造一个默认空對象再赋值數據的冗餘操作，const成員、引用成員、無默認構造對象必須使用函數初始化列表

1
2
3
4
5
6
7
8


class Student
{
private:
 string name;
 int age;
public:
 Student(string n, int a) : name(n), age(a) {}
};

Note for Numpy

Mon, 31 Aug 2026 19:27:00 +0800

Very Basics

The basics

NumPy’s array class is called ndarray.

Properties:

ndarray.ndim: dimansions/axes of the arrary.
ndarray.shape: $(x, y, z, t, \cdots) : tuple?$
ndarray.size: the total number of elements of the array.
ndarray.dtype: ?
ndarray.itemsize: ?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0, 1, 2, 3, 4],
 [ 5, 6, 7, 8, 9],
 [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<class 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<class 'numpy.ndarray'>

Array creation

using array():

1
2
3
4


>>> import numpy as np
>>> a = np.arrary([2, 3, 4])
>>> a
array([2, 3, 4])

the type of the array can also be explicitly specified at creation time:

1

>>> c = np.array([[1, 2], [3, 4]], dtype=np.complex128)

Often, the elements of an array are originally unknown, but its size is known. Hence, NumPy offers several functions to create arrays with initial placeholder content. These minimize the necessity of growing arrays, an expensive operation.
the function zeros() creates an array full of zeros, while ones() ones.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


>>> np.zeros((3, 4))
array([[0., 0., 0., 0.],
 [0., 0., 0., 0.],
 [0., 0., 0., 0.]])
>>> np.ones((2, 3, 4), dtype=np.int16)
array([[[1, 1, 1, 1],
 [1, 1, 1, 1],
 [1, 1, 1, 1]],

 [[1, 1, 1, 1],
 [1, 1, 1, 1],
 [1, 1, 1, 1]]], dtype=int16)
>>> np.empty((2, 3)) 
array([[3.73603959e-262, 6.02658058e-154, 6.55490914e-260], # may vary
 [5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])

a sequence of numbers ($arange(m, n, step)([m,n))$):

1
2


>>> np.arange(10, 30, 5)
array([10, 15, 20, 25])

linespace(begin, end, count)$[\text{begin},\space \text{end}]$

1
2
3
4
5
6


x = np.linspace(0, 2, 10)
array(
 [0. , 0.22222222, 0.44444444,
 0.66666667, 0.88888889, 1.11111111, 
 1.33333333, 1.55555556, 1.77777778, 2. ]
 )

Printing arrays

print(nparray)

Basic operations

Arithmetic operators on arrays apply elementwise. A new array is created and filled with the result.

elementwise product:

1

A * B

matrix product:

1

A @ B

When operating with arrays of different types, the type of the resulting array corresponds to the more general or precise one (a behavior known as upcasting).

Universal functions

NumPy provides familiar mathematical functions such as $\sin,\space\cos$, and $\text{exp}$. In NumPy, these are called “universal functions”(ufunc). Within NumPy, these functions operate elementwise on an array, producing an array as output.

1
2
3
4
5


>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([1. , 2.71828183, 7.3890561 ])

Indexing, slicing and iterating

One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python sequences.

 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


>>> a = np.arange(10)**3
>>> a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> # equivalent to a[0:6:2] = 1000;
>>> # from start to position 6, exclusive, set every 2nd element to 1000
>>> a[:6:2] = 1000
>>> a
array([1000, 1, 1000, 27, 1000, 125, 216, 343, 512, 729])
>>> a[::-1] # reversed a
array([ 729, 512, 343, 216, 125, 1000, 27, 1000, 1, 1000])
>>> for i in a:
... print(i**(1 / 3.))
...
9.999999999999998 # may vary
1.0
9.999999999999998
3.0
9.999999999999998
4.999999999999999
5.999999999999999
6.999999999999999
7.999999999999999
8.999999999999998

Multidimensional arrays can have one index per axis. Thesse indices are given in a tuple separated by commas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


>>> def f(x, y):
... return 10 * x + y
...
>>> b = np.fromfuction(f, (5, 4), dtype=np.int_)
>>> b
array([[ 0, 1, 2, 3],
 [10, 11, 12, 13],
 [20, 21, 22, 23],
 [30, 31, 32, 33],
 [40, 41, 42, 43]])
>>> b[2, 3]
23
>>> b[0:5, 1] # each row in the second column of b
array([ 1, 11, 21, 31, 41])
>>> b[:, 1] # equivalent to the previous example
array([ 1, 11, 21, 31, 41])
>>> b[1:3, :] # each column in the second and third row of b
array([[10, 11, 12, 13],
 [20, 21, 22, 23]])

… (skip) (more ways to get a slice)

Shape manipulation

Changing the shape of an array

An array has a shape given by the number o felements along each axis:

1
2
3
4
5
6
7


>>> a = np.floor(10 * rg.random((3, 4)))
>>> a
array([[3., 7., 3., 4.],
 [1., 4., 2., 2.],
 [7., 2., 4., 9.]])
>>> a.shape
(3, 4)

The shape of an array can be changed with various commands. Note that the following three commands all return a modified array, but do not change the original array:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> a.ravel() # returns the flattened array
array([3., 7., 3., 4., 1., 4., 2., 2., 7., 2., 4., 9.])
>>> a.reshape(6, 2) # returns the array with a modified shape
array([[3., 7.],
 [3., 4.],
 [1., 4.],
 [2., 2.],
 [7., 2.],
 [4., 9.]])
>>> a.T # returns the array, transposed
array([[3., 1., 7.],
 [7., 4., 2.],
 [3., 2., 4.],
 [4., 2., 9.]])

By the way: of `np.random`

init the seed:

1

>>> np.random.seed(int(hashlib.sha256("Aminiam".encode()).hexdigest(), 16) % (2**32))

print:

1
2
3
4


>>> print(np.random.random((3,3)))
[[0.59908781 0.55341069 0.73192068]
 [0.61572755 0.97373193 0.27759232]
 [0.53090874 0.57221723 0.63055102]]

By the way: of `random`

1
2
3
4


>>> import random as rd
>>> rd.seed(10086)
>>> rd.random()
0.043562757723543566

View or shallow copy

View() method creates a new array object that looks at the same data.

1
2
3
4
5
6
7


>>> c = a.view()
>>> c is a
False
>>> c.base is a
True
>>> c.flags.owndata
False

Slicing an array returns a view of it.

1
2


>>> s = a[:, 1:3]
s[:] = 10 # s[:]is a view of `s`. Note the difference between `s=10` and `s[:]=10`

Deep copy

The copy() method makes a complete copy f the array and its data.

1
2
3


>>> d = a.copy()
>>> d is a
False

Sometimes copy() should be called after slicing if the original array is not required anymore. For example, suppose a is a huge intermediate result and the final result b only contains a small fraction of a, a deep copy should be made when constructing b with slicing.

Less basic

Broadcasting rules

Broadcasting allows universal functions to deal in a meaningful way with inputs that do not have exactly the same shape.

The first rule of broadcasting is that if all input arrays do not have the same number of dimensions, a “1” will be repeatedly prepended to the shapes of the smaller arrays until all the arrays have the same number of dimensions.

The second rule of broadcasting ensures that arrays with a size of 1 along a particular dimension act as if the had the size of the array with the largest shape along that dimension. The value of the array element is assumed to be the same along that dimension for the “broadcast” array.

After application of the broadcasting rules, the sizes of all arrays must match.

Advanced indexing and index tricks

Indexing with arrays of indices

Note for Python

Mon, 31 Aug 2026 19:27:00 +0800

本體語法

自定義輸出行爲：

方法一：

1
2


import sys
sys.stdout.write("Hello!\n")

方法二：

1
2


def printf(string : str):
 print(string, end='', sep='')

自定義讀入行爲：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> import sys
>>> line = sys.stdin.read()
Hello World!
>>> # line = "Hello World!\n"
>>> line = sys.stdin.readline().rstrip('\n')
Hello World!
>>> # line = "Hello World!"
>>> char = sys.stdin.read(1)
Hello World!
>>> # char = 'H'
>>> all_content = sys.stdin.read()
>>> # read to EOF (suitable for pipe)
>>> for line in sys.stdin:
... print(repr(line)) # to print '\n' explicitly cuz `line` has '\n' surfix

<str>.title() 以首字母大寫返回每一個單詞，<str>.upper()大寫，<str>.lower()小寫
+拼接str
\t製表符
<str>.lstrip(), <str>.rstrip(), <str>.strip()，返回str左右兩端空格，不修改，修改另存儲爲<str> = <str>.strip()
""字符串可以換行，''字符串不可換行
print(a, b)的默認行爲是a,<space>b\n
str拼接需強轉<strA> + str(10086) + <strB>
3 / 2 = 1, 3.0 / 2.0 = 1.5, 3.0 / 2 = 1.5, 3 / 2.0 = 1.5
列表[elementA, elementB, ...]
<list>.append()尾插，<list>.insert(N)索引處插入，索引及右右移一位，<list>.del(N)刪除索引，<list>.pop()彈出隊尾，<list>.pop(N)彈出索引
<list>.remove()根據值刪除元素
<list>.sort()永久排序，<list>.sort(reverse=True)逆序，<list>.sorted()返回臨時排序
<list>.reverse()永久翻轉
<list>.len()長度
for element in list:按引用訪問
range(a,b,c)：$[a,b)(step = c)$
切片<list>[a:b]：$[a,b)$
<listA> = <listB>複製引用

Shallow copy:

1
2
3
4
5
6


import copy
a = [1, 2, [3, 4]]
b = a.copy()
b = a[:]
b = list(a)
b = copy.copy(a)

頂層元素修改不影響，修改嵌套的可變對象（比如a[2].append(5)）b也會改變

Deep copy:

1
2


a = [1, 2, [3, 4]]
b = copy.deepcopy(a)

tuple：(elementA, elementB)，不可以修改元組的元素，但是可以重新定義整個元組（修改元組變量）
not > and > or, ==, !=, >/<(=)

位運算：

運算	名稱
`&`	按位與
`\|`	按位或
`~`	按位非
`^`	按位抑或
`<<` / `>>`	左右位移

位運算 > 比較運算 > 邏輯運算
檢查元素是否在list中：element (not) in <list, array, tuple> ，返回True / False
if-elif-else
檢查列表是否爲空：if <list>，不爲空True，空False（It says this is Pytholic?）
字典：{key : value, key : value, ...}，按key訪問<dict>[key]，添加元素<dict.[new_key] = element，創建空字典dict = {}，刪除元素del <dict>[key]
遍歷字典：for key, value in dict
遍歷字典所有鍵：for key in dict.keys()
遍歷字典所有值：for value in dict.values()
默認值同cpp全部放右側
沒有函數重載
函數傳遞整數、浮點、字符串、元組傳遞地址但是修改時會另外創建新對象，列表、字典、集合傳遞地址，修改時會直接修改元素
禁止函數修改列表：將列表的副本傳遞給函數：func(<list>[:])（潛copy）

傳遞任意數量的實參：

1
2
3
4
5
6
7


>>> def func(*args):
... print(args)
...
>>> func('A')
('A',)
>>> func('B', 'C', 'D')
('B', 'C', 'D')

傳遞任意數量的關鍵字實參：

1
2
3
4
5


>>> def func(**args):
... profile = {}
... for key, value in args:
... dict[key] = value
... return dict

將函數存儲在模塊中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# ./a.py
def func_1():
 return # or `return None`
# ./package/b.py
def func_2():
 return
# ./package/__init__.py
# ./main.py
import a
import package.b

子目錄相對導入：

1
2
3
4
5
6
7
8
9


- PROJETC
- main.py
- c.py
- package
 |- a.py
 |- b.py
# b.py
import .a
import ..c

from module import function
from module import function as func

類：

1
2
3
4
5
6
7


class cls():
 """description"""
 def __init__(a, b):
 	self.a = a
 self.b = b
 def func(self):
 return

繼承：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class A():
 def __init__(a, b):
 self.a = a
 self.b = b
 def func():
 print("A")
 return
class B():
 def __init__(a, b, c):
 super().__init__(a, b)
 self.c = c
 def func(): # super().func() is overrided
 super().func()
 print("B")
 return

讀取文件：

1
2


# hello.txt
Hello World!

1
2
3


with open('hello.txt') as file_object:
 contents = file_object.read()
 print(contents)

1

Hello World!

關鍵字with在不需要訪問文件後將其關閉，也可使用open(), close()来控制儘管這是不推薦的
文件訪問的路徑爲當前相對路徑
逐行讀取：
1 2 3

with open('hello.txt') as file_obj: for line in file_obj: print(line)
這樣會多出空行，因爲line的結尾有換行符，寫爲：print(line.rstrip())即可（？）
創建一個包含文件各行內容的列表（只能在with內訪問文件對象，那麼在with外需要訪問的時候就需要用列表拷貝一份
1 2 3 4

with open('Hello.txt') as f: lines = f.readlines() for line in lines: print(line.rstrip())

寫入文件：

1
2


with open("Bye.txt", 'w') as f:
 f.write("Bye World!")

讀取：'r'，寫入：'w'，追加：'a'

如果寫入的文件不存在，Python 將自動創建它
write()默認不寫入\n
異常（神了，我cpp都沒學異常）

存儲數據（使用json）（JavaScript Object Notation）

使用json.dump(), json.load()：

1
2
3
4


import json
numbers = [1, 0, 0, 8, 6]
with open('data.json', 'w') as f:
 json.dump(numbers, f)

1
2
3
4


import json
with open('data.json') as f:
 numbers = json.load(f)
print(numbers)

列表推导式：

1

list[expr for var in iteratable_obj]

1

a = [x for x in range(5)]

等价于：

1
2
3


a = []
for x in range(5):
 a.append(x)

约定：for _ in range iteratable_object表示不关心循环变量

1

[0] * 3 == [0] + [0] + [0] == [0, 0, 0]

列表相加表示拼接列表

因此创建一个$m\times n$的数组只需要：

1

a = [[0] * n for _ in range(m)]

或者这样定义：

1
2
3


def matrix(m, n, val=0):
 return [val * n for _ in range(m)]
a = matrix(3, 4, 1)

判断值是否在dict中：
1 2

if value in dict.values(): pass

標準庫

math

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from math import *
sqrt(16) == 4.0
floor(3.3) == 3
cell(3.3) == 4
gcd(12, 18) == 6
lcm(4, 6) == 12
log(8, 2) == 3.0
log2(8) == 3.0
pi == 3.1415926...
inf == ∞

还有一些常见函数直接隶属Python：

1
2
3
4
5
6


abs(-3) == 3
pow(2, 3) == 8.0
round(3.14159, 2) = 3.14
min()
max()
sum([1, 2, 3])

random

1
2
3
4
5
6
7
8


from random import *
random() # float in [0, 1)
randint(1, 10) # random integer in [1, 10] # note that it's right closed
randrange(10) # 0 ~ 9 # note that it's right open
choice([0, 1, 2]) # choose from randomly
shuffle(a) # shuffle randomly
sample(a, 3) # get a random sample of 3
seed(10086) # set seed

time

1
2
3


from time import *
t = time() # get UNIX timestamp
print(t)

time a programme

1
2
3
4
5


start = time.perf_counter()
for i in range(1000000):
 pass
end = time.perf_counter()
print(end - start) # seconds

sleep：

1

sleep(1) # sleep for 1s

datetime

1
2
3
4
5
6
7


import datetime
now = datetime.now()
print(now)
print(now.year)
print(now.month)
print(now.day)
print(now.hour)

1
2
3
4
5


2026-09-02 08:43:21.310003
2026
9
2
8

同样还有：now.minute, now.second

创建时间：

1

dt = datetime.datetime(2026, 9, 2, 22, 30)

时间差：

1
2


now = datetime.datetime.now()
tomorrow = now + timedelta(days=1)

格式化：

1

now.strftime("%Y-%m-%d %H:%M:%S")

解析字符串：

1
2
3
4


datetime.strptime(
	"2026-09-02 08:50:29",
 "%Y-%m-%d %H-%M-%S"
)

collections

`deque`

1
2
3
4
5
6


from collections import deque
q = deque([1, 2, 3])
q.append(4)
q.appendleft(0)
q.pop()
q.popleft()

`Counter`

统计元素出现次数：

1
2
3
4


from collections import Counter
cnt = Counter("hello")
print(cnt)
print(cnt["l"])

`defaultdict`

1
2
3
4
5


from collections import defaultdict
d = defaultdict(list)
d["a"].append(1)
d["a"].append(2)
d["b"].append(3)

普通dict访问不存在的key会报错，defaultdict可以自动创建默认值

比如计数：

1
2
3


cnt = defaultdict(int)
for x in [1, 2, 2, 3]:
 cnt[x] += 1

`itertools`

迭代器工具

排列：

1
2
3


>>> from itertools import permutations
>>> list(permutations([1, 2, 3]))
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

组合：

1
2
3


>>> from itertools import combinations
>>> list(combinations([1, 2, 3, 4], 2))
[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

笛卡儿积：

1
2
3


>>> from itertools import product
>>> list(product([0, 1], repeat=3))
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

其他：

1
2
3
4


itertools.chain(...)
itertools.accumulate(...)
itertools.repeat(...)
itertools.count(...)

`heapq`

堆（默认小根堆）

`bisect`

在有序序列中二分

`functools`

函数工具，最常见是缓存：

1
2
3
4
5
6
7


from functools import cache

@cache
def f(n):
 if n <= 1:
 return n
 return f(n - 1) + f(n - 2)

@cache会自动缓存函数结果

operator

操作函数：

1
2


from operator import add
add(2, 3)

常用于排序：

1
2
3
4
5
6
7


from operator import itemgetter
a = [
	("A", 20),
	("B", 18),
	("C", 22)
]
a.sort(key=temgetter(1))

`string`

字符串常量

1
2
3
4


import string
string.ascii_lowercase # abcdefghijklmnopqrstuvwxyz
string.ascii_uppercase # ABCDEFGHIJKLMNOPQRSTUVWXYZ
string.digits # 0123456789

`re`

正则表达式

`os`

操作系统

获取当前目录：

1
2


import os
os.getcwd()

查看文件：

1

os.listdir(".")

创建目录：

1

os.mkdir("hello")

环境变量：

1

os.environ["PATH"]

尽管现代 Python 更推荐用pathlib处理路径

`pathlib`

文件路径

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> from pathlib import Path
>>> p = Path("data/test.txt")
>>> print(p.exists())
True
>>> print(p.name)
test.txt
>>> print(p.stem)
test
>>> print(p.suffix)
.txt

创建路径：

1

p = Path("data") / "test.txt"

遍历文件：

1
2


for p in Path(".").glob("*.py"):
 print(p)

递归查找：

1

Path(".").rglob("*.py")

`sys`

Python 运行环境

命令行参数：

1
2


import sys
print(sys.argv)

标准输入：

1

input = sys.stdin.readline

标准输出：

1

print("Hello", file=sys.stdout)

退出程序：

1

sys.exit()

运行外部程序：

1
2


import subprocess
subprocess.run(["git", "status"])

`copy`

浅复制：copy.copy()，深复制：copy.deepcopy()

多邊形重心

Tue, 25 Aug 2026 23:30:24 +0800

原題

AtCoder 原題：F - Centroid of a Slice

多边形重心坐标

對有$N$個頂點的平面多邊形的每個頂點有$(x_i,y_i)$有：

$$ G_x = \frac{\sum_i{(x_i+x_{i+1})S_i}}{3\sum_i{S_i}} \newline G_y = \frac{\sum_i{(y_i+y_{i+1})S_i}}{3\sum_i{S_i}} $$

其中：

$$ S_i = \frac{1}{2}(x_iy_{i+1}-x_{i+1}y_i) \newline x_{N+1} = x_1 \newline y_{N+1} = y_1 $$

注意事項

使用前綴和時，記得閉合最後一條邊。

AC代碼

 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


#include <cstdio>

const int SIZE = (1e6 + 10);
typedef long double ld;

int main()
{
 //read
 int N, Q; scanf("%d%d", &N, &Q);
 int x[SIZE] = {0}, y[SIZE] = {0};
 ld ax[SIZE] = {0}, ay[SIZE] = {0}, b[SIZE] = {0};
 for (int i = 1; i <= N; i++)
 scanf("%d%d", &x[i], &y[i]);
 x[N + 1] = x[1]; y[N + 1] = y[1];
 for (int i = 1; i <= N; i++)
 {
 ax[i] = ax[i - 1] + ((ld)x[i] + (ld)x[i + 1]) * ((ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i]);
 ay[i] = ay[i - 1] + ((ld)y[i] + (ld)y[i + 1]) * ((ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i]);
 b[i] = b[i - 1] + (ld)x[i] * (ld)y[i + 1] - (ld)x[i + 1] * (ld)y[i];
 }
 //output
 for (int i = 0; i < Q; i++)
 {
 int u, v; scanf("%d%d", &u, &v);
 ld ans_x, ans_y, sb, sax, say;
 if (u < v)
 {
 sb = b[v - 1] - b[u - 1];
 sax = ax[v - 1] - ax[u - 1];
 say = ay[v - 1] - ay[u - 1];
 }
 else
 {
 sb = b[N] - b[u - 1] + b[v - 1];
 sax = ax[N] - ax[u - 1] + ax[v - 1];
 say = ay[N] - ay[u - 1] + ay[v - 1];
 }
 //close
 ld c = (ld)x[v] * (ld)y[u] - (ld)x[u] * (ld)y[v];
 sb += c;
 sax += ((ld)x[v] + (ld)x[u]) * c;
 say += ((ld)y[v] + (ld)y[u]) * c;
 ans_x = sax / sb / 3.0L;
 ans_y = say / sb / 3.0L;
 printf("%.12Lf %.12Lf\n", ans_x, ans_y);
 }
 return 0;
}

tree板子

Sat, 22 Aug 2026 16:18:53 +0800

方案一：vector 鄰接表

使用vector<int> n;，n[i]儲存了第$i$個節點的所有鄰居。

`add(a, b)` (vector)

1
2


a.push_back(b);
b.push_back(a);

DFS (vector)

遞歸實現，首先定義bool st[SIZE] = {false};來記錄節點是否被訪問過。

1
2
3
4
5
6
7
8


void dfs(head)
{
 st[head] = true; //標記當前節點
 run(head); //執行操作
 for (auto v : n[head])
 if (!st[v])
 dfs(v);
}

BFS (vector)

使用隊列queue<int> q;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


st[head] = true; //先記錄head已經被訪問
q.push(head); //將head插入隊尾
while (!q.empty()) //開始循環
{
 int f = q.front();
 q.pop();
 run(f);
 for (auto v : n[f]) 
 if (!st[v])
 {
 st[v] = true;
 q.push(v);
 }
}

方案二：鏈式前向星

定義：

1
2
3
4


int h[N];
int e[2 * N];
int ne[2 * N];
int id = 0;

`add(a, b)` (static)

1
2
3
4
5
6
7
8


id++; //分配內存
e[id] = b; //儲存值
ne[id] = h[a]; //頭插
h[a] = id; //頭插
id++
e[id] = a;
ne[id] = h[b];
h[b] = id;

DFS (static)

遞歸實現：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


void dfs(head)
{
 st[head] = true;
 run(head);
 for (int i = n[head]; i; i = ne[i])
 {
 int v = e[i];
 if (!st[v])
 {
 st[v] = true;
 dfs(v);
 }
 }
}

BFS (static)

使用隊列queue<int> q;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


st[head] = true;
q.push_front(head);
while (!q.empty())
{
 int f = q.front();
 q.pop();
 run(f); //在此處run
 for (int i = n[f]; i; i = ne[i])
 {
 int v = e[i];
 if (!st[v])
 {
 st[v] = true;
 q.push(v); //這裏是push不是run
 }
 }
}

二分板子

Sat, 22 Aug 2026 16:15:06 +0800

檢查左端點

1
2
3
4
5
6
7


int l = 1, r = n;
while (l < r)
{
 int mid = (l + r) / 2;
 if(check(mid)) r = mid;
 else l = mid + 1;
}

檢查右端點

1
2
3
4
5
6
7


int l = 1, r = n;
while (l < r)
{
 int mid = (l + r + 1) / 2;
 if(check(mid)) l = mid;
 else r = mid - 1;
}

筆記 on Aminiam's Blog

C CPP 解包

C可變參數解包

C++ 可變參數模板與遞歸解包

方式一：遞歸解包

方法二：摺疊表達式

完美轉發

Notes for C

C

Notes for Pandas

Pandas Basics

Basic data structures in pandas

Object creation

Notes for Matplotlib

Pyplot Basics

Introduction to pyplot

Formatting the style of you plot

Plot with keyword strings

Plotting with categorical variables

Controlling line properties

Working with multiple figures and Axes

Working with text

MATLAB format string

Marker styles

Line styles

Colour codes

序列解包

MCM 常用方法 Python 版

層次分析法 AHP（Analytic Hierarchy Process）

問題背景

性質

一致性檢驗

Python實現

TOPSIS法（逼近理想解排序法）

性質

Python實現

最小二乘擬合與迴歸

性質

Python實現

Sudoku Solver: Bitmask & MRV

Sudoku Solver

狀態壓縮：Bitmask

MRV(Minimum Remaining Values)：最小剩餘值啓發式

遍歷方法：位運算提取候選（Lowbit 技巧）

算法流程：DFS 回溯

實現

不動點組合子

左值、右值和萬能引用auto&&

定義

分析

T&&

std::move

構造函數初始化列表

Note for Numpy

Very Basics

The basics

Array creation

Printing arrays

Basic operations

Universal functions

Indexing, slicing and iterating

Shape manipulation

Changing the shape of an array

By the way: of np.random

By the way: of random

View or shallow copy

Deep copy

Less basic

Broadcasting rules

Advanced indexing and index tricks

Indexing with arrays of indices

Note for Python

本體語法

標準庫

math

random

time

datetime

collections

deque

`C`可變參數解包

左值、右值和萬能引用`auto&&`

`T&&`

By the way: of `np.random`

By the way: of `random`

`deque`

`Counter`

`defaultdict`

`itertools`

`heapq`

`bisect`

`functools`

`string`

`re`

`os`

`pathlib`

`sys`

`copy`

`add(a, b)` (vector)

`add(a, b)` (static)