DFS终于完胜BFS了

xxxxx的办公室非常大，小xx同学的位置坐落在右上角，而大门却在左下角，可以把所有位置抽象为一个网格（门口的坐标为0，0），小xx同学很聪明，每次只向上，或者向右走，因为这样最容易接近目的地，但是小xx同学不想让自己的boss们看到自己经常在他们面前出没，或者迟到被发现。他决定研究一下如果他不通过boss们的位置，他可以有多少种走法？

输入描述:
第一行 x,y,n (0<x<=30, 0<y<=30, 0<=n<= 20) 表示x,y小虾的座位坐标,n 表示boss的数量（ n <= 20）

接下来有n行, 表示boss们的坐标(0<xi<= x, 0<yi<=y，不会和小虾位置重合)

x1, y1
x2, y2
……
xn, yn

输出描述:
输出小虾有多少种走法

输入例子1:
3 3 2
1 1
2 2

输出例子1:
4

此题做法，这一题考察得很细致。如果用BFS，会因为队列塞得太多而超内存，如果直接用DFS暴力搜索也会超时。如果使用BFS，队列存储每一层的坐标是无可避免的，所以无法避免超内存的问题（我没想到可以解决之道）。所以采用DFS，而且必须对搜索树进行剪枝。

注意，规模很大，路径很多，int存不下，必须使用long long （C++11以后保证>64位存储）

#include <iostream>
#include <vector>

using namespace std;

long long DFS(vector<vector<bool>>& board, int px, int py, int x, int y, vector<vector<long long>>& visited) {
    long long count = 0;
    if(px == x && py == y) {
        return 1;
    }
    
    //无路可走返回0
    if((px+1 > x || !board[px+1][py]) && (py+1 > y || !board[px][py+1])) {
        return 0;
    }
    
    if(px+1 <= x && board[px+1][py]) {
        if(visited[px+1][py] != 0) {
            count += visited[px+1][py];
        } else {
            count += DFS(board, px+1, py, x, y, visited);
        }
    }
    
    if(py+1 <= y && board[px][py+1]) {
        if(visited[px][py+1] != 0) {
            count += visited[px][py+1];
        } else {
            count += DFS(board,px, py+1, x, y, visited);
        }
    }
    visited[px][py] = count;
    return count;
    
}
int main() {
    int x, y, n;
    cin >> x >> y >> n;
    vector<vector<bool>> board(x+1, vector<bool>(y+1, true));
    vector<vector<long long>> visited(x+1, vector<long long>(y+1, 0));
    int bx, by;
    for(int i = 0; i < n; i++) {
        cin >> bx >> by;
        board[bx][by] = false;
    }
    
    long long res = DFS(board, 0, 0, x, y, visited);
    
    cout << res << endl;
}

仔细想想，实际上每个坐标能搜索的方向只有上面，和右边，如果把问题倒过来想，从（x,y)–>(0,0）避开Boss的位置，能有多少种可达路径，这样就可以用动态规划的思想来解决这一题。

dp[x][y] = 1 //base case，初始化边界，终点到终点就是 1 种
dp[i][j] = dp[i+1][j] + dp[i][j+1] //当前位置到(x,y)的可达路径来自上、右

按照这个思路重新编码，时间复杂度和空间复杂度都是O(N^2),因为不得不遍历整个坐标图计算每个坐标到(x,y)的可达路径。

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int x, y, n;
    cin >> x >> y >> n;
    vector<vector<long long>> board(x+1, vector<long long>(y+1,0));
    int bx, by;
    for(int i = 0; i < n; i++) {
        cin　>> bx >> by;
        board[bx][by] = -1;
    }
    
    board[x][y] = 1;
    long long up = 0, right = 0;
    for(int i = x; i >= 0; i--) {
        for(int j = y; j >= 0; j--) {
            up = 0, right = 0;
            if(board[i][j] != -1) {
                if(i+1 <= x && board[i+1][j] != -1) {
                    up = board[i+1][j];
                }
                if(j+1 <= y && board[i][j+1] != -1) {
                    right = board[i][j+1];
                }
                board[i][j] = up + right + board[i][j];
            }
        }
    }
    
    cout << board[0][0] << endl;
}