# 日期相关
- 判断是否闰年
```python
import calendar
calendar.isleap(2024) # True
```
- 打印某月日历
```python
import calendar
calendar.prmonth(2023,2)
```

![image.png](https://blog.kevin2li.top/static/img/e85e1a3fa208755a635b9750374a04cf.image.png)

- 查询每月多少天
```python
import calendar
# 返回该月首日星期和天数
calendar.monthrange(2023,2) # (2,28)
```



# 时间相关
- 获取当前时间戳  

方法一：
```python
import time
time.now() # 1680240112.9216447
```
方法二：
```python
import datetime
t = datetime.datetime.now() # datetime.datetime(2023, 3, 31, 13, 17, 55, 211020)
t.timestamp() # 1680239875.21102
```

- 格式化时间输出：`strftime`
```python
import datetime
t = datetime.datetime.now() # datetime.datetime(2023, 3, 31, 13, 17, 55, 211020)
t.strftime("%Y-%m-%d %H:%M:%S") # '2023-03-31 13:17:55'
```

- 提取时间字段信息
```python
import datetime
t = datetime.datetime.now() # datetime.datetime(2023, 3, 31, 13, 17, 55, 211020)
t.year      # 2023
t.month     # 3
t.day       # 31
t.hour      # 13
t.minute    # 17
t.second    # 55
t.weekday() # 4
t.date()    # datetime.date(2023, 3, 31)
t.timestamp() # 1680239875.21102
```

- 从格式字符串构造时间：`strptime`
```python
import datetime
t2 = datetime.datetime.strptime("2022-03-31 13:24:34", "%Y-%m-%d %H:%M:%S")
t2 # datetime.datetime(2022, 3, 31, 13, 24, 34)
```

# 时间增量
- 计算两个日期之间的天数差
```python
import datetime
begin = datetime.datetime(2023,3,1)
end = datetime.datetime(2023,4,1)
(end-begin).days
```

Python日期时间处理

# 读取数据

# 数组

# 栈

# 队列

# 哈希

# 字符串

# 搜索

# 查找

# 排序

# 线段树

# 树状数组


C++算法刷题常用代码片段

# 读取数据
```python
# 输入：3 4 5
a, b, c = list(map(int, input().split()))
```

# 特殊数值
```python
# 无穷大
float('inf')
```


# 数组
- 声明
```python
# 声明一维数组
dp = [0 for i in range(n)]
dp = [0]*n

# 声明二维数组
vis = [[False for j in range(n)] for i in range(m)]

# 获取二维数组长宽
m, n = len(board), len(board[0])
```

- 判断数组元素位于其他对象中
```python
# 判断数组中模式是否位于字符串s中
s = "20220123"
any([k in s for k in ['012', '123', '234', '345', '456', '567', '678', '789']])
```

- 排序/逆序
```python
l = [1, 2, 5, 3, 4]
# 排序
l.sort()      # [1,2,3,4,5]
l = sorted(l) # [1,2,3,4,5]

# 逆序
l.reverse() # [4,3,5,2,1]
l = list(reversed(l)] # [4,3,5,2,1]
```
- 复制列表
```python
nums = [1,2,3]
nums[:]
# or
nums.copy()
```
- 平移n个单位
```python
l = [1,2,3,4,5,6,7,8]
n = 3
# 左移
l = l[n:]+l[:n] # [4,5,6,7,8,1,2,3]
# 右移
l = l[-n:]+l[:-n] # [6,7,8,1,2,3,4,5]
```

# 链表
- 链表反转
```python

```

- 环形链表
```python

```

# 栈
- 基础操作
```python
```
- 单调栈

```python
```
- 用栈实现队列
```python
```

# 队列
- 基础操作
```python
```
- 单调队列
```python
```

# 字符串处理
- 基本操作
```python
s = "123ABC"
str_array = ['a', 'b', 'c']
s2 = "hello world"

# 逆序
s[::-1]

# 排序
sorted(s)

# 分割字符串
s2.split()

# 拼接字符串数组
"".join(str_array)

# 判断是否为字母
'abc123'.isalpha() # False

# 判断是否为数字串
'abc123'.isdigit()

# 大小写转换
'a'.upper() # 'A'
chr(ord('a')-32) # 'A'

# 字符串转整数
int("101", 2) # 5
```

- 下一个字典序
```python

```

# 日期/时间
- 遍历日期
```python
import datetime
begin = datetime.datetime(2022,1,1)
end = datetime.datetime(2023,1,1)
for i in range((end-begin).days):
    day = begin + datetime.timedelta(days=i)
    print(day)
```

# 数学
- 基础运算
```python
# 乘方
10**2 # 100

# 开方
math.sqrt(4) # 2.0
4**0.5       # 2.0

# 上取整
math.ceil(3.7) # 4.0
math.ceil(4)   # 4.0

# 下取整
math.floor(3.7) # 3.0
math.floor(3)   # 3.0

# 四舍五入
round(3.14159)    # 3
round(3.14159, 3) # 3.142

# 取模
5 % 3 # 2
divmod(5, 3) # 0, 3

# 最大公约数
math.gcd(24, 18) # 6

# 最小公倍数
a*b / math.gcd(a, b)

```
- 排列与组合
```python
math.perm(3)   # 6
math.perm(4,2) # 12

math.comb(5,2) # 10
```

```python
import itertools
list(itertools.combinations(range(1,5), 2)) # [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
list(itertools.permutations(range(1,4), 3)) # [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
```
- 最大公约数与最小公倍数
```python
def gcd(a, b):
	a, b = max(a,b), min(a,b)
	r = a%b
	while r:
		a, b = b, r
		r = a % b
	return b

def lcm(a, b):
    return a*b/gcd(a,b)
```

- 素数判断
```python

```

- 回文数判断
```python
def f(n):
    return str(n)==str(n)[::-1]
```

- 进制转换
```python

```

# 位运算
```python

```

# 哈希
```python

```

# 集合
```python

```

# 搜索
- 深度优先搜索DFS

**类型一**：只标记

[leetcode-419. 甲板上的战舰](https://leetcode.cn/problems/battleships-in-a-board/)

![image.png](https://blog.kevin2li.top/static/img/55c0ea1219a591359f06e0c9da40487b.image.png)

目标：搜索战舰数量

```python
class Solution:
    def countBattleships(self, board: List[List[str]]) -> int:
        m, n = len(board), len(board[0])
        vis = [[False for j in range(n)] for i in range(m)]
        def dfs(x, y):
            vis[x][y] = True
            for dx, dy in [(0,1), (1,0), (0, -1), (-1, 0)]:
                tx, ty = x+dx, y+dy
                if 0 <= tx < m and 0 <= ty < n:
                    if board[tx][ty]=='X' and not vis[tx][ty]:
                        dfs(tx, ty)
        ans = 0
        for i in range(m):
            for j in range(n):
                if board[i][j] == 'X' and not vis[i][j]:
                    dfs(i,j,vis)
                    ans += 1
        return ans
```
**类型二：** 需要回溯

[leetcode-面试题 08.12. 八皇后](https://leetcode.cn/problems/eight-queens-lcci/)
```python
class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        def dfs(i):
            if i == n:
                ans.append(cur.copy()) # <== 注意copy
                return
            for j in range(n):
                if j in columns or i+j in diag1 or i-j in diag2:
                    continue
                cur.append(j)
                columns.add(j)
                diag1.add(i+j)
                diag2.add(i-j)
                dfs(i+1)
                cur.pop()
                columns.remove(j)
                diag1.remove(i+j)
                diag2.remove(i-j)

        columns, diag1, diag2 = set(), set(), set()
        cur = []
        ans = []
        dfs(0)
        res = []
        for item in ans:
            t = [["." for j in range(n)] for i in range(n)]
            for i, p in enumerate(item):
                t[i][p] = 'Q'
            t = ["".join(row) for row in t]
            res.append(t)
        return res
```
[leetcode-46. 全排列](https://leetcode.cn/problems/permutations/)
```python
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        def dfs(k):
            if k==n:
                ans.append(cur[:])
                return
            for i in range(n):
                if not used[i]:
                    cur.append(nums[i])
                    used[i] = True
                    dfs(k+1)
                    used[i] = False
                    cur.pop()
        used = [False for i in range(n)]
        cur = []
        ans = []
        dfs(0)
        return ans
```
- 广度优先搜索BFS

```python

```
- 记忆化搜索
> 重点：`@lru_cache(None)`

[leetcode-70. 爬楼梯](https://leetcode.cn/problems/climbing-stairs/)
```python
class Solution:
    @lru_cache(None)
    def climbStairs(self, n: int) -> int:
        if n == 1 or n == 2:
            return n
        else:
            return self.climbStairs(n-1) + self.climbStairs(n-2)
```
# 动态规划
## 背包问题
### 01背包
一般情况：
$$
\begin{equation*}
    dp[i][j]=
    \begin{cases}
    dp[i-1][j], & j<weights[i],\\
    max(dp[i-1][j], dp[i-1][j-weights[i]]+value[i]), & j \ge weights[i]
    \end{cases}
\end{equation*}
$$

[leetcode-416. 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum/)
$$
\begin{equation*}
    dp[i][j]=
    \begin{cases}
    dp[i-1][j], & j<nums[i],\\
    dp[i-1][j] \:\: | \:\:dp[i-1][j-nums[i]], & j \ge nums[i]
    \end{cases}
\end{equation*}
$$
```python
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        n = len(nums)
        s = sum(nums)
        if n<2:
            return False
        if s%2!=0:
            return False
        V = s//2
        dp = [[False for i in range(V+1)] for i in range(n+1)]
        for j in range(n+1):
            dp[j][0] = True
        for i in range(1,n+1):
            for j in range(V+1):
                if j >= nums[i-1]:
                    dp[i][j] = dp[i-1][j] or dp[i-1][j-nums[i-1]]
                else:
                    dp[i][j] = dp[i-1][j]
        return dp[n][V]
```
空间优化：(注意第二层循环逆序)
```python
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        n = len(nums)
        s = sum(nums)
        if n<2:
            return False
        if s%2!=0:
            return False
        V = s//2
        dp = [False for i in range(V+1)]
        dp[0] = True
        for i in range(1,n+1):
            for j in range(V, 0, -1):
                if j >= nums[i-1]:
                    dp[j] = dp[j] or dp[j-nums[i-1]]
        return dp[V]
```

### 完全背包  
- 装满：  

[leetcode-322. 零钱兑换](https://leetcode.cn/problems/coin-change/)

目标：不同面额的硬币，凑出指定金额，所需要的最少硬币数
$$
dp[i] = min(dp[i-c])+1, if \:\: i \ge c
$$
```python
class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        M = float("inf")
        dp = [M]*(amount+1)
        dp[0] = 0
        for i in range(amount+1):
            for c in coins:
                if i>=c:
                    dp[i] = min(dp[i], dp[i-c]+1)
        if dp[amount] != M:
            return dp[amount]
        return -1
```

[leetcode-518. 零钱兑换 II](https://leetcode.cn/problems/coin-change-ii/)  
目标：不同面额的硬币，凑出指定金额的不同方案数

$$
\begin{equation*}
    dp[i][j]=
    \begin{cases}
    dp[i-1][j], & j<coins[i],\\
    dp[i-1][j]+dp[i][j-coins[i-1]], & j \ge coins[i]
    \end{cases}
\end{equation*}
$$
```python
class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        n = len(coins)
        M = float("inf")
        dp = [[0 for i in range(amount+1)] for j in range(n+1)]
        for i in range(n+1):
            dp[i][0] = 1

        for i in range(1,n+1):
            for j in range(amount+1):
                if j >= coins[i-1]:
                    dp[i][j] = dp[i-1][j] + dp[i][j-coins[i-1]]
                else:
                    dp[i][j] = dp[i-1][j]
        return dp[n][amount]
```
空间优化：(注意第二层循环顺序)  
$$
dp[j] = dp[j] + dp[j-coins[i-1]],\: if\: j \ge coins[i-1]
$$

```python
class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        n = len(coins)
        dp = [0 for i in range(amount+1)]
        dp[0] = 1
        for i in range(n):
            for j in range(1, amount+1):
                if j >= coins[i]:
                    dp[j] = dp[j] + dp[j-coins[i]]
        return dp[amount]
```

[leetcode-377. 组合总和 Ⅳ (相当于 零钱兑换 III)](https://leetcode.cn/problems/combination-sum-iv/)  
目标：不同面额的硬币，凑出指定金额的不同方案数，考虑顺序  
（注意循环顺序，先容量再物品）
```python
class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        n = len(nums)
        dp = [1] + [0]*target
        for i in range(target+1):
            for num in nums:
                if i>=num:
                    dp[i] += dp[i-num]
        return dp[target]
```

## 一维DP
```python

```

环形：
```python

```
## 二维DP
```python

```
## 子序列问题
[leetcode-300. 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence/)
$$
dp[i] = max(dp[j])+1,\:\:\: 0 \le j<i \:\: \&\& \:\: nums[j]<nums[i]
$$
```python
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [1] * n
        ans = 1
        for i in range(n):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j]+1)
                ans = max(ans, dp[i])
        return ans
```


[leetcode-1143. 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence/)
$$
\begin{equation*}
    dp[i][j]=
    \begin{cases}
    dp[i-1][j-1]+1, & s_1[i] = s_2[j],\\
    max(dp[i-1][j], dp[i][j-1]), & s_1[i] \ne s_2[j]
    \end{cases}
\end{equation*}
$$
```python
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        n, m = len(text1), len(text2)
        dp = [[0 for i in range(m+1)] for j in range(n+1)]
        for i in range(1, n+1):
            for j in range(1, m+1):
                if text1[i-1] == text2[j-1]:
                    dp[i][j] = dp[i-1][j-1]+1
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        return dp[n][m]
```

## 分割类问题
```python

```
## 其他
```python

```

# 排序
```python
```
# 查找
- 二分查找

```python
```

# 并查集
```python
```
# 二叉树
- 遍历
```python
```
# 堆
```python
```
# 字典树

```python
```
# 线段树

```python
```
# 树形数组
```python
```
# 博弈
```python
```
# 前缀和
- 一维
```python
```
- 二维
```python
```
# 状态机
```python
```

Python算法刷题常用代码片段

# 简介
crontab命令是Unix和Linux用于设置周期性被执行的指令。该命令从标准输入设备读取指令，并将其存放于“crontab”文件中，以供之后读取和执行。crontab命令常见于 Unix 和 类Unix 的操作系统之中。通常，crontab储存的指令被守护进程激活， crond常常在后台运行，每一分钟检查是否有预定的作业需要执行。

该命令依赖于`cron`，可通过下面命令安装和启用：
```bash
# 安装
sudo apt-get install cron

# 启动
systemctl start cron

# 查看状态
systemctl status cron
```



# 基本命令
```bash
# 查看当前用户定时任务
crontab -l

# 指定用户查看
crontab -u root -l

# 编辑当前用户定时任务
crontab -e

# 删除当前用户的定时任务
crontab -r
```


示例：
```bash
# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command
5 * * * *  ddns -c /home/likai/ddns/config.json
```

5个*分别表示：`minute,hour,day,month,weekday`

# 加入日志记录
```bash
# 运行下面命令后找到包含cron的行，就前面的#去掉
sudo vim /etc/rsyslog.d/50-default.conf

# 重启rsyslog
sudo systemctl restart rsyslog

# 日志路径
sudo less /var/log/cron.log
```

Linux设置定时任务

# 常用服务管理命令
```bash
# 重新载入服务
systemctl daemon-reload

# 查看服务状态
systemctl status sshd

# 启动服务
systemctl start sshd

# 停止服务
systemctl stop sshd

# 重启服务
systemctl restart sshd

# 开机自启
systemctl enable sshd

# 取消开机自启
systemctl disable sshd

```



# 自定义服务示例
## Frp客户端(frpc)

1. 编写服务文件

位置：`/etc/systemd/system/frpc.service`，内容如下：

```ini
[Unit]
Description=frpc service
After=network.service

[Service]
Type=simple
User=root
Group=root
WorkingDirectory=/root
ExecStart=sh /home/kevin2li/frp_0.44.0_linux_amd64/frp_start.sh
PrivateTmp=true
Restart=on-failure

[Install]
WantedBy=multi-user.target
```

2. 重新载入文件

`systemctl daemon-reload`

3. 启动服务

`systemctl start frpc`