问题：设计一个函数，来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径就不能再次进入该格。

解题思路：这是一个回溯法的应用。首先，在矩阵中任选一个格子作为路径的起点，如果矩阵中某个格子的字符为ch，并且这个格子将对应于路径上的第i个字符。如果路径上的第i个字符不是ch，那么这个格子不可能处在路径上的第i个位置。如果路径上的第i个字符正好是ch，那么到相邻的格子寻找路径上的第i+1个字符。除了矩阵边界上的格子外，其他格子都有4个相邻的格子。重复这个过程，知道路径上的所有字符都在矩阵中找到相应的位置。路径可以被看成一个栈，当在矩阵中定位了路径中前n个字符的位置后，在与第n个字符对应的格子周围都没有找到第n+1个字符，这时候就只好回退到路径的第n-1个字符，重新定位第n个字符。由于不能重复进入一个格子，所以还需要定义和字符矩阵大小一样的bool值来表示该格子是否可以进入。

bool bPathker(const char *matrix, int row, int col, int i, int j, const char *str, int                   
               &pathlen, bool *isvaliable)
{
    if(str[pathlen] == '\0')
        return true;

    bool hasPath = false;
    if(i >= 0 &&  i < row && j >= 0 && j < col 
        && matrix[i * row + j] == str[pathlen]
        && !isvaliable[i * row + j])
    {
        ++pathlen;
        isvaliable[i * row + j] = true;

        hasPath = bPathker(matrix, row, col, i, j-1, str, pathlen, isvaliable)
               || bPathker(matrix, row, col, i-1, j, str, pathlen, isvaliable)
               || bPathker(matrix, row, col, i, j+1, str, pathlen, isvaliable)
               || bPathker(matrix, row, col, i+1, j, str, pathlen, isvaliable);

        if(!hasPath)
        {
            --pathlen;
            isvaliable[i * row + j] =false;
        }
    }


    return hasPath;
}

bool bPath(char *matrix, int row, int col, char *str)
{
    if(matrix == nullptr || row < 1 || col < 1 || str == nullptr)
        return false;

    bool *isvaliable = new bool[row * col];
    memset(isvaliable, 0, row*col);
    
    int pathlen = 0;
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            if(bPathker(matrix, row, col, i, j, str, pathlen, isvaliable))
            {
                return true;
            }
        }
    }

    delete[] isvaliable;

    return false;
}

问题：假设有一个m行n列的方格，一个人从坐标（0，0）的格子开始移动，它每次可以向左，向右，向上，向下移动一格，但不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，这个人能进入方格（35，37），因为3+5+3+7=18，但他不能进入方格（35，38），因为3+5+3+8=19>k，问这个人能到达多少个方格？

解题思路：该问题和上面的问题相似，这个人从（0，0）开始移动，当他准备进入坐标为（i，j）的方格时，通过检查该坐标的数位和来判断这个人能够进入。如果这个人能够进入坐标为（i，j）的方格，则再判断他是否能进入相邻的4个方格，也是一个回溯法的应用。

int getDigitSum(int number)
{
    int sum = 0;
    while(number > 0)
    {
        sum += number % 10;
        number /= 10;
    }

    return sum;
}

bool check(int k, int row, int col, int i, int j, bool *valiable)
{
    if(i >= 0 && i < row && j >= 0 && j < col && 
       getDigitSum(row) + getDigitSum(col) <= k && 
       !valiable[i * row + j])
    {
        return true;
    }

    return false;
}

int moveKer(int k, int row, int col, int i, int j, bool *valiable)
{
    int count = 0;
    if(check(k, row, col, i, j, valiable))
    {
        valiable[i * row + j] = true;

        count = 1 + moveKer(k, row, col, i-1, j, valiable) +
                    moveKer(k, row, col, i, j-1, valiable) +
                    moveKer(k, row, col, i+1, j, valiable) +
                    moveKer(k, row, col, i, j+1, valiable);
    }

    return count;
}

int move(int k, int row, int col)
{
    if(k <= 0 || row <= 0 || col <= 0)
        return 0;

    bool *isvaliable = new bool[row * col];
    for(int i=0; i < row *col; i++)
        isvaliable[i] = false;

    int count = moveKer(k, row, col, 0, 0, isvaliable);

    delete[] isvaliable;

    return count;
}