![在这里插入图片描述](/static/img/images/00424.png)






```csharp
from typing import List
class Solution:
    def dfs(self, grid, cur_i, cur_j) -> int:
        # 超出边界 or 不是陆地  程序靠此结束
        if cur_i < 0 or cur_j < 0 or cur_i == len(grid) or cur_j == len(grid[0]) or grid[cur_i][cur_j] != 1:
            return 0
        grid[cur_i][cur_j] = 0  # 访问过的设置为0,全局的
        ans = 1  # 访问过的陆地，1块
        for di, dj in [[0, 1], [0, -1], [1, 0], [-1, 0]]: # 四个方向
            next_i, next_j = cur_i + di, cur_j + dj
            ans += self.dfs(grid, next_i, next_j) # 这个位置dfs
        return ans
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l): # i,j 遍历每一个位置,在每个位置dfs搜索最大面积
                ans = max(self.dfs(grid, i, j), ans)
        return ans
s=Solution()
print(s.maxAreaOfIsland([[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]))
```

岛屿的最大面积 数据结构与算法 DFS搜索

[https://blog.csdn.net/darkrabbit/article/details/89409548](https://blog.csdn.net/darkrabbit/article/details/89409548)






（1） 出栈序列共有多少种可能？

（2） 求出所有出栈（入栈）序列。

（3） 给出一个出栈序列，问栈的容量最少需要多少？

（4） 给出一个（或多个）出栈序列，问此序列是不是（哪一个序列不是）原序列混洗得到的？


![在这里插入图片描述](/static/img/images/00970.png)

python

题目描述

给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号，火车站只有一个方向进出，同时停靠在火车站的列车中，只有后进站的出站了，先进站的才能出站。

要求输出所有火车出站的方案，以字典序排序输出。
```python
while True:
    try:
        n = int(input())
        trains = [  str(1+i)  for i in range(n)]
        res = []
        def rec_trains(cur_idx, in_trains, out_trains):
            # 如果原始火车列表的最后一个元素已经进站，此时只能出站，将入站列表中的火车倒序加入出站火车中
            if trains[-1] in in_trains:
                res.append(' '.join(out_trains + in_trains[::-1]))
                return
            # 如果进站列表为空，此时只能进站，进站列表加上当前火车，出站列表不变
            elif in_trains == []:
                rec_trains(cur_idx + 1, in_trains + [trains[cur_idx]], out_trains)
            # 否则，就既有可能进站也有可能出站
            else:
                # 出站，当前火车索引不变，进站火车列表减去最后一个元素，出站列表加上进站列表刚刚出站的火车
                rec_trains(cur_idx, in_trains[:-1], out_trains + [in_trains[-1]])
                # 进站，当前火车索引加1，进站列表加上当前火车，出站列表不变
                rec_trains(cur_idx + 1, in_trains + [trains[cur_idx]], out_trains)
        rec_trains(0, [], [])
        res.sort()
        print(len(res))
    except:
        break
```

数据结构 栈混洗 个数 Stack Shuffling 卡特兰数

![在这里插入图片描述](/static/img/images/01120.png)





前序[0, 1, 3, 4, 2]

```python
# Definition for a binary tree node.
from typing import List
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def dfs(root):
            if not root:
                return
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        return res
root = TreeNode(0)
lc = TreeNode(1)
rc = TreeNode(2)
lc_lc = TreeNode(3)
lc_rc = TreeNode(4)
root.left = lc
root.right = rc
lc.left=lc_lc
lc.right=lc_rc
print(Solution().inorderTraversal(root))
```

中序  [3, 1, 4, 0, 2]

```python
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
```

后序  [3, 4, 1, 2, 0]

```python
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)
```

数据结构 python3 二叉树遍历 前序 中序 后序

[https://mp.weixin.qq.com/s?__biz=MzU0ODMyNDk0Mw==&mid=2247487910&idx=1&sn=2670aec7139c6b98e83ff66114ac1cf7&chksm=fb418286cc360b90741ed54fecd62fd45571b2caba3e41473a7ea0934f918d4b31537689c664&token=1327182919&lang=zh_CN#rd](https://mp.weixin.qq.com/s?__biz=MzU0ODMyNDk0Mw==&mid=2247487910&idx=1&sn=2670aec7139c6b98e83ff66114ac1cf7&chksm=fb418286cc360b90741ed54fecd62fd45571b2caba3e41473a7ea0934f918d4b31537689c664&token=1327182919&lang=zh_CN#rd)






递归函数模板：

```c
public void recursion(参数0) {
    if (终止条件) {
        return;
    }
    可能有一些逻辑运算
    recursion(参数1)
    可能有一些逻辑运算
    recursion(参数2)
            ……
    recursion(参数n)
    可能有一些逻辑运算
}
```

递归模板

十大排序算法 python

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。