楠君的小窝 2023-04-25T07:30:00.009Z https://www.nanjun-blog.com/ 楠君的小窝 Hexo 内存空间 https://www.nanjun-blog.com/posts/f9d379e8.html 2023-04-25T07:21:17.000Z 2023-04-25T07:30:00.009Z 这道题在Python B C 组都有，应该属于国赛的打卡题

解题思路

  1. 用哈希表存储内存用量
  2. 判断输入的表达式为数组还是普通表达式
  3. 按照type添加对应量的内存
  4. 将内存从小到大转化
  5. 输出
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
t = eval(input())
memory = {'GB': 0, 'MB': 0, 'KB': 0, 'B': 0}

for _ in range(t):
    s = input()
    if '[]' in s:
        byte = 4
        i = 0
        while i < len(s):
            if s[i] == '[':
                if s[i - 1] == 'g':
                    byte = 8
                else:
                    byte = 4
                i += 1
                num = ""
                while s[i] != ']':
                    num += s[i]
                    i += 1
                if num:
                    memory['B'] += int(num) * byte
            i += 1
    else:
        s = s.split(',')
        if 'int' in s[0]:
            memory['B'] += len(s) * 4
        elif 'long' in s[0]:
            memory['B'] += len(s) * 8
        # string in s[0]
        else:
            for string in s:
                memory['B'] += len(string.split('=')[-1]) - 2
            memory['B'] -= 1

memory['KB'] += memory['B'] // 1024
memory['B'] %= 1024
memory['MB'] += memory['KB'] // 1024
memory['KB'] %= 1024
memory['GB'] += memory['MB'] // 1024
memory['MB'] %= 1024

res = ""
for k, v in memory.items():
    if v > 0:
        res += str(v) + k

print(res)
]]> <p>这道题在Python B C 组都有，应该属于国赛的打卡题</p> <h1 id="解题思路"><a href="#解题思路" class="headerlink" title="解题思路"></a>解题思路</h1><ol> <li>用哈希表存储内存用量</li> <li 2023蓝桥杯总结 https://www.nanjun-blog.com/posts/3922ca2d.html 2023-04-24T05:09:56.000Z 2023-04-24T05:11:58.522Z 奖项

贵州省 Python C 组 省1 第一

全国 Python C 组

省赛

掌握的太少了，对于贪心和DP以及数论是我的薄弱点

国赛

]]> <h1 id="奖项"><a href="#奖项" class="headerlink" title="奖项"></a>奖项</h1><p>贵州省 Python C 组 省1 第一</p> <p>全国 Python C 组 </p> <h1 id="省赛"><a href="#省 2023蓝桥杯省赛 https://www.nanjun-blog.com/posts/53fc994f.html 2023-04-12T09:28:53.000Z 2023-04-13T04:35:10.190Z 题目

三国游戏

这题我一开始只想到了暴力，在赛后根据提示得到正解排序+贪心

一开始使用的是组合+二分查找最大事件，但是肯定会超时。

对x,y,z三个国家进行排序，排序规则是这个国家减去另外两个国家的兵力的降序。最后对三个国家取一个max即可

有一个需要注意的点，在遍历的时候enumerate的start要设置为1，因为事件是从1开始。

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
from sys import stdin

n = eval(input())
x = list(map(int, stdin.readline().split()))
y = list(map(int, stdin.readline().split()))
z = list(map(int, stdin.readline().split()))

sort_x = sorted(range(n), key=lambda i: -(x[i] - y[i] - z[i]))
sort_y = sorted(range(n), key=lambda i: -(y[i] - x[i] - z[i]))
sort_z = sorted(range(n), key=lambda i: -(z[i] - x[i] - y[i]))

vx = vy = vz = 0
res_x = res_y = res_z = -1
for cnt, i in enumerate(sort_x, start=1):
    vx += x[i]
    vy += y[i]
    vz += z[i]
    if vx - vy - vz > 0:
        res_x = cnt

vx = vy = vz = 0
for cnt, i in enumerate(sort_y, start=1):
    vx += x[i]
    vy += y[i]
    vz += z[i]
    if vy - vx - vz > 0:
        res_y = cnt

vx = vy = vz = 0
for cnt, i in enumerate(sort_z, start=1):
    vx += x[i]
    vy += y[i]
    vz += z[i]
    if vz - vx - vy > 0:
        res_z = cnt

print(max(res_x, res_y, res_z))

平均

填充

棋盘

这题我使用的是差分数组，这样可以实现区间加减，最后对2进行取余即可。

1

翻转

异或和之差

小蓝的旅行计划

奇怪的数

]]> <h1 id="题目"><a href="#题目" class="headerlink" title="题目"></a>题目</h1><h2 id="三国游戏"><a href="#三国游戏" class="headerlink" title="三国游戏"></a>三国游戏</h Python类属性与实例属性 https://www.nanjun-blog.com/posts/995a340e.html 2023-03-17T11:32:49.000Z 2023-03-18T02:35:37.857Z 类属性与实例属性

类属性会在程序运行时运行，而实例属性则只会在实例化后运行。

例子：

1
2
3
4
class A:
    print("类属性")
    def __init__(self):
        print("类实例属性")

当我们什么都不做时，python会输出类属性，当我们将A实例赋值给a后，python输出类实例属性，并且python不会再输出一遍类属性。

这是一个值得注意的一个点。

当使用Qt之类的时，我们在类属性内实例化窗口会导致程序崩溃。你需要将QApplication置顶实例。

]]> <h1>类属性与实例属性</h1> <p>类属性会在程序运行时运行，而实例属性则只会在实例化后运行。</p> <p>例子：</p> <figure class="highlight python"><table><tr><td class="gutter"><pre><span 蜂巢 https://www.nanjun-blog.com/posts/2406641d.html 2023-02-22T13:38:33.000Z 2023-03-18T02:35:37.858Z 这是蓝桥杯2022年Python的G题，其实这道题我在很久之前看到时被劝退，感觉自己写不出来，今天重新来挑战他，发现这道题没有运用任何变成知识，仅仅运用了直角坐标系(笛卡尔坐标系)。

看到这一题的第一眼肯定不会将他和坐标系联系在一起，第一想到的时DFS和BFS这种搜索算法，但是很可惜，这道题没有这么深。

解题思路

思路

根据图中显示，我们可以发现，从原点O(0, 0)出发，左上、左下、右上、右下，这4个方向每移动一次x +- 0.5, y +- 1

而向左或者向右只有 x +- 1

根据这个想法可以得出[[-1, 0], [-0.5, 1], [0.5, 1], [1, 0], [0.5, -1], [-0.5, -1]]，下标从0开始，每个下标都对应着蜂巢的6个方向。

按照题目给的要求得到点B和点C

计算两点之间的距离，两点之间的路径就是abs(x1 - x2) + abs(y1 - y2)由于蜂巢向上向下移动一次是 ± 0.5，所以得到最终的表达式为abs(x1 - x2) + abs(y1 - y2) * 0.5。

若一个点向上向下移动能直接抵达另一个点，那么直接输出abs(y1- y2) * 0.5

代码

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
import math

# 0, 1, 2, 3, 4, 5
directions = [[-1, 0], [-0.5, 1], [0.5, 1], [1, 0], [0.5, -1], [-0.5, -1]]


def position(d, p, q):
    pos_x = pos_y = 0
    pos_x += (directions[d][0] * p) + (directions[(d + 2) % 6][0] * q)
    pos_y += (directions[d][1] * p) + (directions[(d + 2) % 6][1] * q)
    return pos_x, pos_y


arr = list(map(int, input().split()))
d1, p1, q1 = arr[:3]
d2, p2, q2 = arr[3:]

B = position(d1, p1, q1)
C = position(d2, p2, q2)

x = abs(B[0] - C[0])
y = abs(B[1] - C[1])

if y * 0.5 >= x:
    print(int(y))
else:
    print(int(x + y * 0.5))
]]> <p>这是蓝桥杯2022年Python的G题，其实这道题我在很久之前看到时被劝退，感觉自己写不出来，今天重新来挑战他，发现这道题没有运用任何变成知识，仅仅运用了直角坐标系(笛卡尔坐标系)。</p> <p>看到这一题的第一眼肯定不会将他和坐标系联系在一起，第一想到的时DFS和BFS LC343. 整数拆分 https://www.nanjun-blog.com/posts/10a5a7af.html 2023-02-16T14:18:02.000Z 2023-03-18T02:35:37.824Z 解题思路

按照动规五部曲

  1. 确定dp数组及其下标的含义

    dp[i], i为要被拆分的整数，dp[i]为要被拆分的整数的最大乘积

  2. 确定递推公式

    dp[i] = max(dp[i], j * (i - j), j * dp[i - j])

    j * (i - j)是将数字拆分成两个正整数时的最大值

    j * dp[i - j] 是将数字拆分成两个以上时的最大值，由于dp[i]前面以及被计算过了，所以可以直接得出拆分更多正整数的乘积

  3. 初始化dp数组

    整数拆分0和1没有任何意义，所以只要关注2就行了,dp[2] = 1

  4. 确定遍历顺序

    i从3开始遍历

    j从1开始遍历

  5. 举例推导dp数组

代码

Python

1
2
3
4
5
6
7
8
class Solution:
    def integerBreak(self, n: int) -> int:
        dp = [0 for _ in range(n + 1)]
        dp[2] = 1
        for i in range(3, n + 1):
            for j in range(1, i - 1):
                dp[i] = max(dp[i], (i - j) * j, dp[i - j] * j)
        return dp[n]

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[2] = 1;
        for (int i = 3; i < n + 1; i++) {
            for (int j = 1; j < i - 1; j++) {
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }
};

Go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func integerBreak(n int) int {
    dp := make([]int, n + 1)
    dp[2] = 1
    for i := 3; i < n + 1; i++ {
        for j := 1; j < i - 1; j++ {
            dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
        }
    }
    return dp[n]
}

func max(a int, b int) int {
    if a >= b {return a}
    return b
}
]]> <h1>解题思路</h1> <p>按照动规五部曲</p> <ol> <li> <p>确定dp数组及其下标的含义</p> <p>dp[i], i为要被拆分的整数，dp[i]为要被拆分的整数的最大乘积</p> </li> <li> <p>确定递推公式</p> <p>dp[i] = m LC63. 不同路径 II https://www.nanjun-blog.com/posts/af94e356.html 2023-02-15T14:55:47.000Z 2023-03-18T02:35:37.824Z 解题思路

与LC62大致相似，多了一个路障,遇到路障时候跳过，若上i - 1或者j - 1是路障则不添加路线

首先dp[i][j]肯定是能到这个位置的所有路径

递推公式：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

初始化：dp[i][j] = 0

遍历顺序：顺序遍历

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        if obstacleGrid[0][0] == 1: return 0
        dp = [[0] * n for _ in range(m)]
        dp[0][0] = 1
        for i in range(m):
            for j in range(n):
                if obstacleGrid[i][j] == 1: continue
                if i - 1 >= 0 and obstacleGrid[i - 1][j] != 1:
                    dp[i][j] += dp[i - 1][j]
                if j - 1 >= 0 and obstacleGrid[i][j - 1] != 1:
                    dp[i][j] += dp[i][j - 1]
        return dp[m - 1][n - 1]

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        if (obstacleGrid[0][0] == 1) return 0;
        dp[0][0] = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                if (i - 1 >= 0 && obstacleGrid[i - 1][j] != 1) dp[i][j] += dp[i - 1][j];
                if (j - 1 >= 0 && obstacleGrid[i][j - 1] != 1) dp[i][j] += dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

Go

func uniquePathsWithObstacles(obstacleGrid [][]int) int {    m, n := len(obstacleGrid), len(obstacleGrid[0])    dp := make([][]int, m)    for i := range dp {        dp[i] = make([]int, n)    }    if obstacleGrid[0][0] == 1 {return 0}    dp[0][0] = 1    for i := 0; i < m; i++ {        for j := 0; j < n; j++ {            if obstacleGrid[i][j] == 1 {continue}            if i - 1 >= 0 && obstacleGrid[i - 1][j] != 1 {                dp[i][j] += dp[i - 1][j]            }            if j - 1 >= 0 && obstacleGrid[i][j - 1] != 1 {                dp[i][j] += dp[i][j - 1]            }        }    }    return dp[m - 1][n - 1]}
]]> <h1>解题思路</h1> <p>与LC62大致相似，多了一个路障,遇到路障时候跳过，若上i - 1或者j - 1是路障则不添加路线</p> <p>首先<code>dp[i][j]</code>肯定是能到这个位置的所有路径</p> <p>递推公式：<code>dp[i][j] = LC62. 不同路径 https://www.nanjun-blog.com/posts/636fe572.html 2023-02-14T02:36:59.000Z 2023-03-18T02:35:37.824Z 解题思路

题目给出了一个重要条件“机器人每次只能向下或者向右移动一步”由这个条件可以得出

  1. 当前的路径和与他的左边和上边的路径有关。[i - 1][j] 和 [i][j - 1]
  2. dp使用二维数组,dp[i][j]能到此处的所有路径和
  3. 得出推导公式为: dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
  4. 遍历顺序：顺序遍历
  5. 初始化：dp[0][0] = 1

代码

Python

1
2
3
4
5
6
7
8
9
10
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        box = [[0] * n for _ in range(m)]
        box[0][0] = 1
        for i in range(m):
            for j in range(n):
                if i == j == 0: continue
                if 0 <= i - 1: box[i][j] += box[i - 1][j]
                if 0 <= j - 1: box[i][j] += box[i][j - 1]
        return box[m - 1][n - 1]

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i - 1 >= 0) dp[i][j] += dp[i - 1][j];
                if (j - 1 >= 0) dp[i][j] += dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

Go

func uniquePaths(m int, n int) int {    dp := make([][]int, m)    for i := range dp {        dp[i] = make([]int, n)    }    dp[0][0] = 1    for i := 0; i < m; i++{        for j := 0; j < n; j++ {            if j == 0 && i == 0 {continue}            if 0 <= i - 1 {dp[i][j] += dp[i - 1][j]}            if 0 <= j - 1 {dp[i][j] += dp[i][j - 1]}        }    }    return dp[m - 1][n - 1]}
]]> <h1>解题思路</h1> <p>题目给出了一个重要条件“机器人每次只能向下或者向右移动一步”由这个条件可以得出</p> <ol> <li>当前的路径和与他的左边和上边的路径有关。<code>[i - 1][j] 和 [i][j - 1]</code></li> <li>dp使用 LC746. 使用最小花费爬楼梯 https://www.nanjun-blog.com/posts/67bc6ce2.html 2023-02-13T06:12:13.000Z 2023-03-18T02:35:37.824Z 解题思路

题目说从一个台阶向上爬需要付出cost[i]的费用，而每次只能爬1~2层台阶。

根据示例得出楼顶为cost[len(cost)]也就数组外。

由于每次只能爬1~2层台阶，那么我们可以直接从下标为3的地方开始顺序遍历。

递推公式：dp[i] = min(dp[i - 1], dp[i - 2])

每次取前两个台阶的最小费用，这样就能达到最小费用了。

代码

Python

1
2
3
4
5
6
class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        if len(cost) == 2: return min(cost)
        for i in range(2, len(cost)):
            cost[i] += min(cost[i - 1], cost[i - 2])
        return min(cost[-1], cost[-2])

C++

1
2
3
4
5
6
7
8
9
10
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        if (cost.size() == 2) return min(cost[1], cost[0]);
        for (int i = 2; i < cost.size(); i++) {
            cost[i] += min(cost[i - 1], cost[i - 2]);
        }
        return min(cost[cost.size() - 1], cost[cost.size() - 2]);
    }
};

GO

func minCostClimbingStairs(cost []int) int {    if len(cost) == 2 {return min(cost[0], cost[1])}    n := len(cost)    for i := 2; i < n; i++ {        cost[i] += min(cost[i - 1], cost[i - 2])    }    return min(cost[n - 1], cost[n - 2])}func min(a int, b int) int {    if a <= b {return a}    return b}
]]> <h1>解题思路</h1> <p>题目说从一个台阶向上爬需要付出cost[i]的费用，而每次只能爬1~2层台阶。</p> <p>根据示例得出楼顶为cost[len(cost)]也就数组外。</p> <p>由于每次只能爬1~2层台阶，那么我们可以直接从下标为3的地方开始顺序遍历。< LC70. 爬楼梯 https://www.nanjun-blog.com/posts/965a672a.html 2023-02-13T05:32:14.000Z 2023-03-18T02:35:37.824Z 解题思路

首先顶楼<=2时直接返回n就行了

我们可以这么思考，每个台阶都是由他的前一个台阶和前前一个台阶上来的，而这两个台阶也是同理。

那么我们只要从前往后遍历(下标从3开始)，每次将当前台阶的前两个台阶加起来，那么就是当前台阶的方法

推导公式：dp[i] = dp[i - 1] + dp[i - 2]

代码

Python

1
2
3
4
5
6
7
8
9
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2: return n
        dp = [0 for _ in range(n + 1)]
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n;
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i < n + 1; ++i) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

GO

func climbStairs(n int) int {    if n <= 2 {return n}    dp := make([]int, n + 1, n + 1)    dp[1] = 1    dp[2] = 2    for i := 3; i < n + 1; i++ {        dp[i] = dp[i - 1] + dp[i - 2]    }    return dp[n]}
]]> <h1>解题思路</h1> <p>首先顶楼&lt;=2时直接返回n就行了</p> <p>我们可以这么思考，每个台阶都是由他的前一个台阶和前前一个台阶上来的，而这两个台阶也是同理。</p> <p>那么我们只要从前往后遍历(下标从3开始)，每次将当前台阶的前两个台阶加起来，那么就是当 LC509. 斐波那契数 https://www.nanjun-blog.com/posts/9451dcc4.html 2023-02-13T05:31:34.000Z 2023-03-18T02:35:37.824Z 解题思路

斐波那契数列为前两项的和，第0项和第1项分别为0， 1.

f(0) = 0f(1) = 1 f(2) = f(0) + f(1) = 1f(3) = f(2) + f(1) = 3

下标从2开始，从前往后遍历

f[n] = f[n - 1] + f[n - 2]

代码

Python

1
2
3
4
5
6
7
8
9
10
class Solution:
    def fib(self, n: int) -> int:
        if n <= 1: return n
        MOD = 10 ** 9 + 7
        fib = [0 for _ in range(n + 1)]
        fib[1] = 1
        for i in range(2, n + 1):
            fib[i] = fib[i - 1] + fib[i - 2]
        return fib[-1] % MOD

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    int fib(int n) {
        const int N = 1e9 + 7;
        if (n <= 1) return n;
        vector<int> dp(n + 1);
        dp[1] = 1;
        for (int i = 2; i < n + 1; ++i) {
            dp[i] = dp[i - 1] + dp[i - 2];
            dp[i] %= N;
        }
        return dp[n];
    }
};

GO

func fib(n int) int {    if n <= 1 {return n}    MOD := 1000000007    dp := make([]int, n + 1, n + 1)    dp[1] = 1    for i := 2; i < n + 1; i++ {        dp[i] = dp[i - 1] + dp[i - 2]        dp[i] %= MOD    }    return dp[n]}
]]> <h1>解题思路</h1> <p>斐波那契数列为前两项的和，第0项和第1项分别为0， 1.</p> <p>f(0) = 0 f(1) = 1 f(2) = f(0) + f(1) = 1 f(3) = f(2) + f(1) = 3</p> <p>下标从2开始，从前往后遍历</p 对于回溯的一些理解 https://www.nanjun-blog.com/posts/816d7d9b.html 2023-02-11T11:35:52.000Z 2023-03-18T02:35:37.807Z 个人感觉回溯与递归其实是差不多的，递归是由上到下的，而回溯是由下而上的。

回溯在部分题能变成记忆化搜索如果再得出递推公式就能变成DP(动态规划)了。

回溯主要的几个难点就在于剪枝

树层剪枝、树枝剪枝

数层剪枝我一般都是在每一层中使用一个哈希表，而树枝剪枝类似于有长度限制之类的，可以提前return

这段时间我的码力也是直线上升了，感觉到自己实力在不断的增长，我还自己做了一个小项目。

DataStructView相信不久就能做好

]]> <p>个人感觉回溯与递归其实是差不多的，递归是由上到下的，而回溯是由下而上的。</p> <p>回溯在部分题能变成记忆化搜索如果再得出递推公式就能变成DP(动态规划)了。</p> <p>回溯主要的几个难点就在于剪枝</p> <p>树层剪枝、树枝剪枝</p> <p>数层剪枝我一般都是 LC37. 解数独 https://www.nanjun-blog.com/posts/1ca688a9.html 2023-02-11T11:24:48.000Z 2023-03-18T02:35:37.831Z 解题思路

代码

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
27
28
29
30
31
32
33
class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        def dfs(pos: int):
            nonlocal valid
            if pos == len(spaces):
                valid = True
                return
            
            i, j = spaces[pos]
            for digit in range(9):
                if line[i][digit] == column[j][digit] == block[i // 3][j // 3][digit] == False:
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True
                    board[i][j] = str(digit + 1)
                    dfs(pos + 1)
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = False
                if valid:
                    return
            
        line = [[False] * 9 for _ in range(9)]
        column = [[False] * 9 for _ in range(9)]
        block = [[[False] * 9 for _a in range(3)] for _b in range(3)]
        valid = False
        spaces = list()

        for i in range(9):
            for j in range(9):
                if board[i][j] == ".":
                    spaces.append((i, j))
                else:
                    digit = int(board[i][j]) - 1
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True

        dfs(0)

C++

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
class Solution {
private:
    bool line[9][9];
    bool column[9][9];
    bool block[3][3][9];
    bool valid;
    vector<pair<int, int>> spaces;

public:
    void dfs(vector<vector<char>>& board, int pos) {
        if (pos == spaces.size()) {
            valid = true;
            return;
        }

        auto [i, j] = spaces[pos];
        for (int digit = 0; digit < 9 && !valid; ++digit) {
            if (!line[i][digit] && !column[j][digit] && !block[i / 3][j / 3][digit]) {
                line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = true;
                board[i][j] = digit + '0' + 1;
                dfs(board, pos + 1);
                line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = false;
            }
        }
    }

    void solveSudoku(vector<vector<char>>& board) {
        memset(line, false, sizeof(line));
        memset(column, false, sizeof(column));
        memset(block, false, sizeof(block));
        valid = false;

        for (int i = 0; i < 9; ++i) {
            for (int j = 0; j < 9; ++j) {
                if (board[i][j] == '.') {
                    spaces.emplace_back(i, j);
                }
                else {
                    int digit = board[i][j] - '0' - 1;
                    line[i][digit] = column[j][digit] = block[i / 3][j / 3][digit] = true;
                }
            }
        }

        dfs(board, 0);
    }
};

Go

func solveSudoku(board [][]byte) {    var line, column [9][9]bool    var block [3][3][9]bool    var spaces [][2]int    for i, row := range board {        for j, b := range row {            if b == '.' {                spaces = append(spaces, [2]int{i, j})            } else {                digit := b - '1'                line[i][digit] = true                column[j][digit] = true                block[i/3][j/3][digit] = true            }        }    }    var dfs func(int) bool    dfs = func(pos int) bool {        if pos == len(spaces) {            return true        }        i, j := spaces[pos][0], spaces[pos][1]        for digit := byte(0); digit < 9; digit++ {            if !line[i][digit] && !column[j][digit] && !block[i/3][j/3][digit] {                line[i][digit] = true                column[j][digit] = true                block[i/3][j/3][digit] = true                board[i][j] = digit + '1'                if dfs(pos + 1) {                    return true                }                line[i][digit] = false                column[j][digit] = false                block[i/3][j/3][digit] = false            }        }        return false    }    dfs(0)}
]]> <h1>解题思路</h1> <h1>代码</h1> <h2 id="Python">Python</h2> <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line" LC51. N 皇后 https://www.nanjun-blog.com/posts/cb00c34a.html 2023-02-11T11:17:21.000Z 2023-03-18T02:35:37.839Z 解题思路

首先我们可以确定一下回溯传入值

backtracking(row: int, uMap: defaultdict(int), path:list[str])

这里row是行的意思，我们传入行不断的增加以达到每个皇后不在同一行上

uMap中key是col，value是row。

计算斜角是否在攻击范围内就是当前的row - preRow == col - preCol

代码

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
27
class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        result = []
        
        def backtracking(row: int, umap:defaultdict(int), path:list[str]):
            if row == n:
                result.append(path.copy())
                return
            s = ['.'] * n
            for col in range(0, n):
                flag = False
                for pre_col, pre_row in umap.items():
                    if abs(row - pre_row) == abs(col - pre_col):
                        flag = True
                        break
                if col in umap: continue  # 该列会被攻击到
                if flag: continue  # 会被斜角攻击到
                s[col] = 'Q'
                umap[col] = row
                path.append("".join(s))
                backtracking(row + 1, umap, path)
                s[col] = '.'
                path.pop()
                umap.pop(col)
        
        backtracking(0, defaultdict(int), [])
        return result

C++

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
class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> ans;
        vector<int> col(n), on_path(n), diag1(n * 2 - 1), diag2(n * 2 - 1);
        function<void(int)> dfs = [&](int r) {
            if (r == n) {
                vector<string> board(n);
                for (int i = 0; i < n; ++i)
                    board[i] = string(col[i], '.') + 'Q' + string(n - 1 - col[i], '.');
                ans.emplace_back(board);
                return;
            }
            for (int c = 0; c < n; ++c) {
                int rc = r - c + n - 1;
                if (!on_path[c] && !diag1[r + c] && !diag2[rc]) {
                    col[r] = c;
                    on_path[c] = diag1[r + c] = diag2[rc] = true;
                    dfs(r + 1);
                    on_path[c] = diag1[r + c] = diag2[rc] = false; // 恢复现场
                }
            }
        };
        dfs(0);
        return ans;
    }
};

Go

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
var result [][]string
var path []string
func solveNQueens(n int) [][]string {
    result = [][]string{}
    path = []string{}
    umap := make(map[int]int)
    backtracking(0, umap, n)
    return result
}

func backtracking(row int, umap map[int]int, n int) {
    if row == n {
        t := make([]string, len(path))
        copy(t, path)
        result = append(result, t)
        return
    }
    s := make([]rune, n, n)
    for i, _ := range s {
        s[i] = '.'
    }
    for col := 0; col < n; col++ {
        _, ok := umap[col]
        flag := false
        for pre_col, pre_row := range umap {
            if abs(row - pre_row) == abs(col - pre_col) {
                flag = true
                break
            }
        }
        if flag {continue}
        if ok {continue}
        s[col] = 'Q'
        umap[col] = row
        path = append(path, string(s))
        backtracking(row + 1, umap, n)
        s[col] = '.'
        delete(umap, col)
        path = path[:len(path) - 1]
    }
}

func abs(a int) int{
    if a < 0 {return -a}
    return a
}
]]> <h1>解题思路</h1> <p>首先我们可以确定一下回溯传入值</p> <p>backtracking(row: int, uMap: defaultdict(int), path:list[str])</p> <p>这里row是行的意思，我们传入行不断的增加以达到每个皇后不在 LC491. 递增子序列 https://www.nanjun-blog.com/posts/ad1605e2.html 2023-02-10T15:25:05.000Z 2023-03-18T02:35:37.834Z 解题思路

题目要求子序列至少2个元素且递增，那么我们添加条件可以是当path中有两个元素的时候

使用哈希表记录当前层使用过的元素，若再次碰到直接continue

当nums[i] < path的最后一个元素时则continue

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution:
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        result = []
        
        def backtracking(startIndex: int, path: list[int]) -> None:
            if len(path) >= 2:
                result.append(path.copy())
            uset = set()
            for i in range(startIndex, len(nums)):
                if path and nums[i] < path[-1]: continue
                if nums[i] in uset: continue
                path.append(nums[i])
                uset.add(nums[i])
                backtracking(i + 1, path)
                path.pop()


        backtracking(0, [])
        return result

C++

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
class Solution {
private:
    vector<vector<int>> result;
    vector<int>path;

    void backtracking(int startIndex, vector<int> &nums) {
        unordered_set<int> uset;

        if (path.size() > 1) result.push_back(path);

        for (int i = startIndex; i < nums.size(); ++i) {
            if (!path.empty() && nums[i] < path[path.size() - 1]) continue;
            if (uset.find(nums[i]) != uset.end()) continue;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(i + 1, nums);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(0, nums);
        return result;
    }

};

Go

var result [][]intvar path []intfunc findSubsequences(nums []int) [][]int {    result = [][]int{}    path = []int{}    backtracking(0, nums)    return result}func backtracking(startIndex int, nums []int) {    if len(path) > 1 {        t := make([]int, len(path))        copy(t, path)        result = append(result, t)    }    uset := make(map[int]bool)    for i := startIndex; i < len(nums); i++ {        if len(path) != 0 && nums[i] < path[len(path) - 1] {continue}        if uset[nums[i]] == true {continue}        path = append(path, nums[i])        uset[nums[i]] = true        backtracking(i + 1, nums)        path = path[:len(path) - 1]    }}
]]> <h1>解题思路</h1> <p>题目要求子序列至少2个元素且递增，那么我们添加条件可以是当<code>path</code>中有两个元素的时候</p> <p>使用哈希表记录当前层使用过的元素，若再次碰到直接continue</p> <p>当nums[i] &lt; path的最 LC90. 子集 II https://www.nanjun-blog.com/posts/8d0fcb67.html 2023-02-10T15:24:44.000Z 2023-03-18T02:35:37.836Z 解题思路

与子集(LC79)不同的是数组中有重复的元素，题目要求我们的解集中不包含重复子集，有两种解法。

  1. 哈希表
  2. 排序

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        result = [[]]
        def dfs(startIndex: int, path: list[int]):
            if startIndex == len(nums): return

            for i in range(startIndex, len(nums)):
                if i > startIndex and nums[i - 1] == nums[i]: continue

                path.append(nums[i])
                result.append(path.copy())
                dfs(i + 1, path)
                path.pop()
        
        dfs(0, [])
        return result

C++

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
class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> result;
        vector<int> path;
        result.push_back(path);

        backtracking(0, result, path, nums);
        return result;
    }

    void backtracking(int startIndex, vector<vector<int>> &result, vector<int> &path, vector<int> &nums) {
        if (startIndex == nums.size()) return;

        for (int i = startIndex; i < nums.size(); ++i) {
            if (i > startIndex && nums[i] == nums[i - 1]) continue;

            path.push_back(nums[i]);
            result.push_back(path);
            backtracking(i + 1, result, path, nums);
            path.pop_back();
        }
    }
};

Go

var result [][]intfunc subsetsWithDup(nums []int) [][]int {    result = [][]int{}    result = append(result, []int{})    sort.Ints(nums)    backtracking(0, []int{}, nums)    return result}func backtracking(startIndex int, path []int, nums []int) {    for i := startIndex; i < len(nums); i++ {        if i > startIndex && nums[i] == nums[i - 1] {continue}        path = append(path, nums[i])        t := make([]int, len(path))        copy(t, path)        result = append(result, t)        backtracking(i + 1, path, nums)        path = path[:len(path) - 1]    }}
]]> <h1>解题思路</h1> <p>与子集(LC79)不同的是数组中有重复的元素，题目要求我们的解集中不包含重复子集，有两种解法。</p> <ol> <li>哈希表</li> <li>排序</li> </ol> <h1>代码</h1> <h2 id="Python">Python< LC78. 子集 https://www.nanjun-blog.com/posts/7eb25fda.html 2023-02-10T15:24:18.000Z 2023-03-18T02:35:37.834Z 解题思路

将nums数组所有子集添加进去就行

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        result = [[]]
        def dfs(startIndex: int, temp: list[int]):
            if startIndex == len(nums): return
            
            for i in range(startIndex, len(nums)):
                temp.append(nums[i])
                result.append(temp.copy())
                dfs(i + 1, temp)
                temp.pop()
        
        dfs(0, [])
        return result

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> result;
        vector<int> temp;
        result.push_back(temp);

        backtracking(0, temp, result, nums);
        return result;
    }
    void backtracking(int startIndex, vector<int> &temp, vector<vector<int>> &result, vector<int> &nums) {
        if (startIndex == nums.size()) return;

        for (int i = startIndex; i < nums.size(); ++i) {
            temp.push_back(nums[i]);
            result.push_back(temp);
            backtracking(i + 1, temp, result, nums);
            temp.pop_back();
        }
    }
};

Go

var result [][]intfunc subsets(nums []int) [][]int {    result = [][]int{}    result = append(result, []int{})    backtracking(0, []int{}, nums)    return result}func backtracking(startIndex int, temp []int, nums []int) {    if startIndex == len(nums) {return}    for i := startIndex; i < len(nums); i++ {        temp = append(temp, nums[i])        t := make([]int, len(temp))        copy(t, temp)        result = append(result, t)        backtracking(i + 1, temp, nums)        temp = temp[:len(temp) - 1]    }}
]]> <h1>解题思路</h1> <p>将<code>nums</code>数组所有子集添加进去就行</p> <h1>代码</h1> <h2 id="Python">Python</h2> <figure class="highlight python"><table><tr><td LC93. 复原 IP 地址 https://www.nanjun-blog.com/posts/8fddc6e7.html 2023-02-10T15:23:58.000Z 2023-03-18T02:35:37.836Z 解题思路

这题考点就是剪枝

  1. 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案

  2. 如果还没有找到 4 段 IP 地址就已经遍历完了字符串，那么提前回溯

  3. 由于不能有前导零，如果当前数字为 0，那么这一段 IP 地址只能为 0

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        # 4 * 3 = 12
        if len(s) > 12: return []
        result = []
        def backtracking(startIndex: int, temp: list[str]):
            if len(temp) == 4:
                if startIndex >= len(s):
                    result.append(".".join(temp))
                return
            c = ""
            for i in range(startIndex, startIndex + 3):
                if i >= len(s): return
                c += s[i]
                if len(c) > 1 and c[0] == '0': return
                if 0 <= int(c) <= 255:
                    temp.append(c)
                    backtracking(i + 1, temp)
                    temp.pop()
        
        backtracking(0, [])
        return result

C++

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
class Solution {
private:
    static constexpr int SEG_COUNT = 4;

private:
    vector<string> ans;
    vector<int> segments;

public:
    void dfs(const string& s, int segId, int segStart) {
        // 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
        if (segId == SEG_COUNT) {
            if (segStart == s.size()) {
                string ipAddr;
                for (int i = 0; i < SEG_COUNT; ++i) {
                    ipAddr += to_string(segments[i]);
                    if (i != SEG_COUNT - 1) {
                        ipAddr += ".";
                    }
                }
                ans.push_back(move(ipAddr));
            }
            return;
        }

        // 如果还没有找到 4 段 IP 地址就已经遍历完了字符串，那么提前回溯
        if (segStart == s.size()) {
            return;
        }

        // 由于不能有前导零，如果当前数字为 0，那么这一段 IP 地址只能为 0
        if (s[segStart] == '0') {
            segments[segId] = 0;
            dfs(s, segId + 1, segStart + 1);
        }

        // 一般情况，枚举每一种可能性并递归
        int addr = 0;
        for (int segEnd = segStart; segEnd < s.size(); ++segEnd) {
            addr = addr * 10 + (s[segEnd] - '0');
            if (addr > 0 && addr <= 0xFF) {
                segments[segId] = addr;
                dfs(s, segId + 1, segEnd + 1);
            } else {
                break;
            }
        }
    }

    vector<string> restoreIpAddresses(string s) {
        segments.resize(SEG_COUNT);
        dfs(s, 0, 0);
        return ans;
    }
};

Go

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
var result []string

func restoreIpAddresses(s string) []string {
    result = []string{}
    backtracking(s, 0, []string{})
    return result

}

func backtracking(s string, startIndex int, temp []string) {
    if len(temp) == 4 {
        if startIndex >= len(s) {
            result = append(result, strings.Join(temp, "."))
        }
        return
    }

    c := ""
    for i := startIndex; i < startIndex + 3; i++ {
        if i == len(s) {return}
        c += string(s[i])
        if len(c) > 1 && c[0] == '0' {return}
        num, _ := strconv.Atoi(c)
        if num >= 0 && num <= 255 {
            temp = append(temp, c)
            backtracking(s, i + 1, temp)
            temp = temp[:len(temp) - 1]
        }
    }
}
]]> <h1>解题思路</h1> <p>这题考点就是剪枝</p> <ol> <li> <p>如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案</p> </li> <li> <p>如果还没有找到 4 段 IP 地址就已经遍历完了字符串，那么提前回溯</p> </li> LC131. 分割回文串 https://www.nanjun-blog.com/posts/c84b6fba.html 2023-02-10T15:23:22.000Z 2023-03-18T02:35:37.830Z 解题思路

首先需要一个check函数用来验证字符串是否为回文串，这里check我们选用双指针。

从下标0开始不断查找回文串，当下标到达s长度时添加进result

代码

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
class Solution:
    def partition(self, s: str) -> List[List[str]]:
        result = []

        def check(s: str):
            l, r = 0, len(s) - 1
            while l <= r:
                if s[l] != s[r]: return False
                l += 1
                r -= 1
            return True

        def backtracking(temp: list[str], start: int):
            if start == len(s):
                result.append(temp.copy())
                return
            sub = ""
            for i in range(start, len(s)):
                sub += s[i]
                if check(sub):
                    temp.append(sub)
                    backtracking(temp, i + 1)
                    temp.pop()

        backtracking([], 0)
        return result

C++

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
class Solution {
private:
    vector<vector<int>> f;
    vector<vector<string>> ret;
    vector<string> ans;
    int n;

public:
    void dfs(const string& s, int i) {
        if (i == n) {
            ret.push_back(ans);
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                ans.pop_back();
            }
        }
    }

    vector<vector<string>> partition(string s) {
        n = s.size();
        f.assign(n, vector<int>(n, true));

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }
};

Go

func partition(s string) (ans [][]string) {    n := len(s)    f := make([][]int8, n)    for i := range f {        f[i] = make([]int8, n)    }    // 0 表示尚未搜索，1 表示是回文串，-1 表示不是回文串    var isPalindrome func(i, j int) int8    isPalindrome = func(i, j int) int8 {        if i >= j {            return 1        }        if f[i][j] != 0 {            return f[i][j]        }        f[i][j] = -1        if s[i] == s[j] {            f[i][j] = isPalindrome(i+1, j-1)        }        return f[i][j]    }    splits := []string{}    var dfs func(int)    dfs = func(i int) {        if i == n {            ans = append(ans, append([]string(nil), splits...))            return        }        for j := i; j < n; j++ {            if isPalindrome(i, j) > 0 {                splits = append(splits, s[i:j+1])                dfs(j + 1)                splits = splits[:len(splits)-1]            }        }    }    dfs(0)    return}
]]> <h1>解题思路</h1> <p>首先需要一个check函数用来验证字符串是否为回文串，这里check我们选用双指针。</p> <p>从下标0开始不断查找回文串，当下标到达s长度时添加进<code>result</code></p> <h1>代码</h1> <h2 id="Pyt LC40. 组合总和 II https://www.nanjun-blog.com/posts/c71a0e34.html 2023-02-10T15:22:58.000Z 2023-03-18T02:35:37.834Z 解题思路

这题与组合总和(LC39)的区别在于给的candidates中有重复的元素，题目要求每个数字在一个组合中只能使用一次，那么这里有两种方法，第一种就是直接使用哈希表记录元素，第二种则比较简单，使用startIndex，由于candidates在开始已经被排序了，那么只要

i > startIndex 且 nums[i] == nums[i - 1]时可以直接continue避免使用重复元素

代码

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        candidates.sort()
        answer = []
        temp = []
        
        def backtracking(start: int, s: int):
            if s == target:
                answer.append(temp.copy())
                return

            for i in range(start, len(candidates)):
                if s + candidates[i] > target: return
                if i > start and candidates[i] == candidates[i -1]: continue
                temp.append(candidates[i])
                backtracking(i + 1, s + candidates[i])
                temp.pop()
        
        backtracking(0, 0)
        return answer

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
private:
    vector<vector<int>> answer;
    vector<int> temp;
    void backtracking(vector<int>& candidates, int target, int start, int sum) {
        if (sum == target) {
            answer.push_back(temp);
            return;
        }
        for (int i = start; i < candidates.size() && sum + candidates[i] <= target; ++i) {
            if (i > start && candidates[i] == candidates[i - 1]) continue;
            temp.push_back(candidates[i]);
            backtracking(candidates, target, i + 1, sum + candidates[i]);
            temp.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return answer;
    }
};

Go

var (    answer [][]int    temp []int)func combinationSum2(candidates []int, target int) [][]int {    answer = [][]int{}    temp = []int{}    sort.Ints(candidates)    backtracking(candidates, target, 0, 0)    return answer}func backtracking(candidates []int, target int, start int, sum int) {    if sum == target {        t := make([]int, len(temp))        copy(t, temp)        answer = append(answer, t)        return    }    for i := start; i < len(candidates) && sum + candidates[i] <= target; i++ {        if i > start && candidates[i] == candidates[i - 1] {continue}        temp = append(temp, candidates[i])        backtracking(candidates, target, i + 1, sum + candidates[i])        temp = temp[:len(temp) - 1]    }}
]]> <h1>解题思路</h1> <p>这题与组合总和(LC39)的区别在于给的<code>candidates</code>中有重复的元素，题目要求每个数字在一个组合中只能使用一次，那么这里有两种方法，第一种就是直接使用哈希表记录元素，第二种则比较简单，使用<code>startIn