编写程序，在一个3x3的网格中找到所有路径，以从左上角到右下角。
以下是一个 Python 程序，用深度优先搜索（DFS）算法找到从左上角到右下角的所有路径：

```python
def findPaths(grid):
    def dfs(i, j, path):
        if i == len(grid) - 1 and j == len(grid[0]) - 1:
            paths.append(path + [(i, j)])
            return
        if i < len(grid) - 1 and not visited[i + 1][j]:
            visited[i + 1][j] = True
            dfs(i + 1, j, path + [(i, j)])
            visited[i + 1][j] = False
        if j < len(grid[0]) - 1 and not visited[i][j + 1]:
            visited[i][j + 1] = True
            dfs(i, j + 1, path + [(i, j)])
            visited[i][j + 1] = False

    paths = []
    visited = [[False] * len(grid[0]) for _ in range(len(grid))]
    visited[0][0] = True
    dfs(0, 0, [])
    return paths
```

函数 `findPaths` 的输入为一个二维数组 `grid`，表示一个 $3\times3$ 的网格。例如，`grid = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]` 表示一个未被访问的 $3\times3$ 网格。程序会返回一个表示所有路径的列表，每个路径表示为从左上角到右下角的顶点坐标。例如，路径 `[(0, 0), (1, 0), (1, 1), (2, 1), (2, 2)]` 表示从左上角，经过网格中的 $5$ 个顶点，到达右下角的路径。

以下是一个使用示例：

```python
grid = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
paths = findPaths(grid)
for path in paths:
    print(path)
```

输出：

```
[(0, 0), (1, 0), (1, 1), (2, 1), (2, 2)]
[(0, 0), (0, 1), (1, 1), (2, 1), (2, 2)]
[(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]
```

上述程序的时间复杂度为 $O(2^{n^2})$，其中 $n$ 为网格的大小。在实际应用中，当网格长度增加时，此算法的性能将迅速下降。一个更加高效的算法是使用广度优先搜索（BFS），其时间复杂度为 $O(n^2)$。