【每日一练】

一、矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

 

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false
提示：

1 <= board.length <= 200
1 <= board[i].length <= 200

解题思路：就是枚举所有的开始字符，然后进行搜索，走过的地方标记下，下次不能走就ok了

时间复杂度：O(n^3) n^2枚举加n的dfs

class Solution {
public:
    int ans = false;
    int row,col;
    int len;
    bool exist(vector<vector<char>>& board, string word) {
        row = board.size();
        col = board[0].size();
        len = word.size();
        //如果长度为0，或者长度不足构成word路径 返回false
        if(len==0||row*col<len){
            return ans;
        }
        for(int i=0; i<row && ans==false; i++){
            for(int j=0; j<col; j++){
                //枚举每一个字母成为路径开头字母
                dfs(board,word,i,j,0);
            }
        }
        return ans;
    }
    //传入矩阵，字符串,遍历到的字母位置（i，j）,已经成功匹配到的字符串长度
    void dfs(vector<vector<char>>& board,string word,int i,int j,int index){
        //不相等退出
        if(board[i][j] != word[index]){
            return ;
        }
        if(ans==true || index == len-1){
            ans = true;
            return ;
        }
        //走过的位置随便拿个字符填充表示走过了
        char temp = board[i][j];
        board[i][j] = '&';
        //下
        if(i+1<row && board[i+1][j] != '&') dfs(board,word,i+1,j,index+1);
        //左
        if(j-1>=0 && board[i][j-1] != '&') dfs(board,word,i,j-1,index+1);
        //上
        if(i-1>=0 && board[i-1][j] != '&') dfs(board,word,i-1,j,index+1);
        //右
        if(j+1<col && board[i][j+1] != '&') dfs(board,word,i,j+1,index+1);
        board[i][j] = temp;
    }
};

二、机器人的运动范围

难度中等124收藏分享切换为英文关注反馈

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

 

示例 1：

输入：m = 2, n = 3, k = 1
输出：3
示例 2：

输入：m = 3, n = 1, k = 0
输出：1
提示：

1 <= n,m <= 100
0 <= k <= 20

解题思路：bfs 直接 根据题目给的限制条件进行判断 跑就行了 时间复杂度为O（n^2）

class Solution {
public:
    int getNum(int x){
        int ans = 0;
        while(x){
            ans += x%10;
            x/=10;
        }
        return ans;
    }
    int movingCount(int m, int n, int k) {
        //边界判断
        if(k==0)return 1;
        queue<pair<int,int>>que;
        //创建一个（m,n）的二维数组 标记走过了那些位置
        vector<vector<int> >vis(m,vector<int>(n,0));
        que.push(make_pair(0,0));
        //0,0已经走过了
        vis[0][0] = 1;
        //设计位置走向
        //下 右v
        int fanx[2] = {0,1};
        int fany[2] = {1,0};
        int ans = 1;
        while(!que.empty()){
            pair<int,int> tmp = que.front();
            que.pop();
            for(int i=0; i<2; i++){
                int dx = tmp.first+fanx[i];
                int dy = tmp.second+fany[i];
                //判断
                if(dx >= 0 && dx<m && dy>=0 && dy<n && vis[dx][dy]==0 && (getNum(dx)+getNum(dy))<=k){
                    //加标记
                    vis[dx][dy] = 1;
                    ans ++;
                    que.push(make_pair(dx,dy));
                }
            }
        }
        return ans;
    }
};

三、括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

解题思路：使用dfs 构造，填充左括号，如果右括号个数小于左括号 就填充右括号，时间复杂度O(n^2)

class Solution {
    void dfs(vector<string>&ans,string cur,int l,int r,int len){
        if(cur.size() == 2*len)
        {
            ans.push_back(cur);
            return;
        }
        //如果左括号个数小于 括号总数 添加左括号
        if(l<len)
        {
            cur+='(';
            dfs(ans,cur,l+1,r,len);
            cur.pop_back();
        }
        //右括号个数小于左括号个数 添加右括号
        if(r<l)
        {
            cur+=')';
            dfs(ans,cur,l,r+1,len);
            cur.pop_back();
        }
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string>ans;
        string cur;
        dfs(ans,cur,0,0,n);
        return ans;
    }
};

 

 

来源：力扣（LeetCode）