剑指 Offer 13. 机器人的运动范围

采用深度优先遍历：

class Solution {
public:
    void DFS(int i, int j, vector<vector<bool>>& visited, int& num, int k)
    {
        int sum = 0;
        int a = i, b = j;
        while (a != 0)
        {
            int tmp = a % 10;
            sum += tmp;
            a /= 10;
        }

        while (b != 0)
        {
            int tmp = b % 10;
            sum += tmp;
            b /= 10;
        }

        if (sum > k) return;
        else
        {
            int m = visited.size();
            int n = visited[0].size();
            visited[i][j] = true;
            num++;
            if (i + 1 < m && !visited[i + 1][j]) DFS(i + 1, j, visited, num, k);
            if (j + 1 < n && !visited[i][j + 1]) DFS(i, j + 1, visited, num, k);
        }
    }

    int movingCount(int m, int n, int k) {
        int num = 0;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        for (int i = 0; i < m; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                if (!visited[i][j] && i + j <= k)
                {
                    DFS(i, j, visited, num, k);
                }
            }
        }
        return num;
    }
};

        在该程序中，需要注意的是进入递归的判断条件需要 i+j<=k;处理一些特殊情况，比如m=12,n=10,k=5时，(10,0),(10,1),(10,2),(10,3),(10,4),(11,0),(11,1),(11,2),(11,3),这些其实都不行的，但是由于求和时是数位之和所以不加这个判断条件的话以上错误情况都会算。  

    那么有些同学会想题目描述给的35，37，18，如果这样(i+j<=k)判断不就没有算该正确情况，其实不会，因为是深度遍历，所以在递归的时候会遍历到，该程序在力扣上是可以提交通过的。

（本人觉得该题题目描述不太清楚，开始一直不知道错在哪，因为题目描述只是说了位数之和，也可能是我理解有误）

也可以将 visited 数组初始化为 int 类型，0代表未访问，1代表访问，最后将其打印，观察错误：

void DFS(int i, int j, vector<vector<int>>& visited, int& num, int k)
{
    int sum = 0;
    int a = i, b = j;
    while (a != 0)
    {
        int tmp = a % 10;
        sum += tmp;
        a /= 10;
    }
    
    while (b != 0)
    {
        int tmp = b % 10;
        sum += tmp;
        b /= 10;
    }
    
    if (sum > k) return ;
    else
    {
        int m = visited.size();
        int n = visited[0].size();
        visited[i][j] = 1;
        num++;
        /*if (i + 1 < m && !visited[i + 1][j]) DFS(i + 1, j, visited, num, k);
        if (j + 1 < n && !visited[i][j + 1]) DFS(i, j + 1, visited, num, k);*/
        if (i + 1 < m && visited[i + 1][j]==0) DFS(i + 1, j, visited, num, k);
        if (j + 1 < n && visited[i][j + 1]==0) DFS(i, j + 1, visited, num, k);
    }
}

int movingCount(int m, int n, int k) {
    int num = 0;
    vector<vector<int>> visited(m, vector<int>(n, 0));
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            if (visited[i][j]==0 )
            {
                DFS(i, j, visited, num, k);
            }
        }
    }
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cout << visited[i][j] << " ";
        }
        cout << endl;
    }
    return num;
}

int main()
{
    cout << movingCount(12, 10, 5) << endl;//应该是10
    return 0;
}