class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        int row=board.size(),col=board[0].size();
        int index=0,i=0,j=0;
        if(word.size()>row*col) return 0;
        //vector<vector<int>> visit[row][col];//标记当前位置有没有被访问过
        vector<vector<int>> visit(row,vector<int>(col));
        bool flag=1;
        while(i<row&j<col)
        {
                cout<<"board[i][j]: "<<board[i][j]<<endl;
                if(board[i][j]==word[index])
                {
                    flag=1;
                    if(index==word.size()-1) return 1;
                    cout<<word[index]<<endl;
                    index++;
                    visit[i][j]=1;
                    if(i-1>=0&&board[i-1][j]==word[index]&&visit[i-1][j]!=1)
                    {
                        cout<<"上"<<endl;
                        i=i-1;
                        j=j;
                    }
                    else if(i+1<row&&board[i+1][j]==word[index]&&visit[i+1][j]!=1)
                    {
                        cout<<"下"<<endl;
                        i=i+1;
                        j=j;
                    }
                    else if(j-1>=0&&board[i][j-1]==word[index]&&visit[i][j-1]!=1)
                    {
                        cout<<"左"<<endl;
                        i=i;
                        j=j-1;
                    }
                    else if(j+1<col&&board[i][j+1]==word[index]&&visit[i][j+1]!=1)
                    {
                        cout<<"右"<<endl;
                        i=i;
                        j=j+1;
                     }
                 }
                else 
                {
                 if(j==col-1&&i<row)//如果到了一行的最后面就调转到下一行 大前提是找不到word[index]相等
                 {
                     cout<<"最末尾的 "<<board[i][j]<<endl;
                     i++;
                     j=0;
                 }
                 else j++;
                }
        }  
        return 0;
    }
};

//写的有点问题，暂时想不到怎么改，先放着，通过用例71/83 卡住的是abcd 但是改了又有问题
无语 看了 答案 都写不对 在类成员里面定义了row和col 就不要重复定义了 不然不知道为什么就开始发疯

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        rows=board.size();
        cols=board[0].size();
        for(int i=0;i<rows;i++)
        {
            for(int j=0;j<cols;j++)
            {
                if (dfs(board,word,i,j,0)) return true;
            }
        }
        return false;
    }
private:
    int rows,cols;
    bool dfs(vector<vector<char>>& board,string word,int i,int j,int k)
    {
        if(i>=rows||i<0||j>=cols||j<0||board[i][j]!=word[k]) return false;
        if(k==word.size()-1) return true;
        board[i][j]='\0';
        bool res=dfs(board,word,i+1,j,k+1)||dfs(board,word,i-1,j,k+1)
               ||dfs(board,word,i,j+1,k+1)||dfs(board,word,i,j-1,k+1);
        board[i][j]=word[k];
        return res;
    }
};

先贴出蠢货写出来的东西 审题也审不明白 机器人只能上下左右走 不能一行一行遍历 菜鸟总是这样 自己把自己搞破防
通过用列46/51

class Solution {
public:
    int movingCount(int m, int n, int k) {
        int index=0;
        for(int i=0;i<m;i++)
        {
            if(add(i)>k) break;
            for(int j=0;j<n;j++)
            {
                if(add(j)>k) break;
                int sum=add(i)+add(j);
                if(sum<=k) 
                {
                    index++;
                    cout<<sum<<endl;
                }
            }
        }
        return index;
    }
private:
   int add(int x)
   {
       int sum=0,num=0;
       while(x)
       {
           num=x%10;
           x=x/10;
           sum+=num;
       }
       return sum;
   }
};

问题出在哪里呢！！！！ 就是比如【10，0】虽然数位之和等于1，但是无法通过【9，0】或者其他走过去，假设k=1的话，也就是他妈的他有障碍物啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
aaaa继续做就是要判断边界条件啊啊啊啊啊啊啊啊啊啊啊啊就是判断他是否能进入4个相邻的格子
首先0，0必定可以嗷，check[0,0]置为1。0，0能走到0，1和1，0，那对于0，1和1，0两个点来说，就是判断他们的上面i-1和左边j-1是否可以走，如果可以那就可以从左边和上面分别走过来，能走到当前这个点就置为1，然后左边和上面能走的点都走了之后，还有两个方向没有判断 ，再来判断能不能从右边(i+1)走到左边,下面（i+1）走到上面，如果能走到当前点，就置为1，最后有多少个1，就有多少个机器人能走的格子。

class Solution {
public:
    int movingCount(int m, int n, int k) {
        int index=0;
        int check[m][n];
        //不能直接写check[m][n]也不能check[m][n]={0}，第一次无法保证元素全为0 ，第二个会报错
        memset(check,0,sizeof(check));
        //memset进行内存清零，可以将一块内存设置为指定的值
        check[0][0]=1;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                int sum=add(i)+add(j);
                if(sum<=k) 
                {
                    if(i-1>=0&&check[i-1][j]==1||j-1>=0&&check[i][j-1]==1) check[i][j]=1;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                int sum=add(i)+add(j);
                if(sum<=k) 
                {
                    if(i+1<m&&check[i+1][j]==1||j+1<n&&check[i][j+1]==1) check[i][j]=1;
                }
            }
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                int sum=add(i)+add(j);
                if(check[i][j]) 
                {
                   index++;
                }
            }
        }
        return index;
    }
private:
   int add(int x)
   {
       int sum=0,num=0;
       while(x)
       {
           num=x%10;
           x=x/10;
           sum+=num;
       }
       return sum;
   }
};

和上题目类似，属于典型的搜索&回溯算法
先了解一下BFS模板
不需要当前遍历到哪一层，BFS模板

while queue 不空
   cur=queue.front();
   queue.pop();
   for 结点 in cur的所有相邻节点
     if 该节点有效且没被访问过：
        queue.push(该结点）

需要确定遍历到哪一层，比如之前写过一题打印二叉链表

level=0
while queue不空：
  size=queue.size()
  while(size--){
  cur=queue.pop();
  for 结点 in cur的所有相邻结点：
    if 该节点有效且未被访问过：
       queue.push(该节点）
       }
  level++;

直接使用模板

算了dfs

class Solution {
public:
    int sum(int x){//计算数位和
        int count = 0;
        while(x){
            count += x%10;
            x /= 10;
        }
        return count;
    }
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};//左上右下
    int res = 0;
    int m , n , k;
    vector<vector<bool>>st;
    int movingCount(int _m, int _n, int _k) {
//m行n列
//不能进入行坐标和列坐标的"数位"之和大于k的格子
//          i  +  j             > k
        m = _m, n = _n, k = _k;
        vector<vector<bool>>_st(m,vector<bool>(n));//初始化
        st = _st;
        return dfs(0,0);
    }
    
    int dfs(int x, int y){
        st[x][y]=true;
        res++;
        for(int i = 0 ;i < 4 ; i++){
            int a = x+dx[i] , b = y + dy[i];
            if(a >= 0 && a < m && b >= 0 && b < n && !st[a][b] && sum(a)+sum(b)<=k){
                dfs(a,b);//那么我们就渲染一下
            }
        }
        return res;
    }
    
};

DFS解法

class Solution {
public:
    int movingCount(int m, int n, int k) {
        vector<vector<int>> check(m,vector<int>(n,0));//球球你了祖宗啊记住这个定义方式吧
        dfs(check,m,n,k,0,0);
        return result;
    }

private:
   int result=0;
   int add(int x)
   {
       int sum=0,num=0;
       while(x)
       {
           num=x%10;
           x=x/10;
           sum+=num;
       }
       return sum;
   }
    void dfs(vector<vector<int>> &check,int m, int n, int k,int x,int y)
    {
        int sum=add(x)+add(y);
        if(x<0||x>=m||y<0||y>=n||check[x][y]==1||sum>k) return ;
        result++;
        check[x][y]=1;
        dfs(check,m,n,k,x+1,y);
        dfs(check,m,n,k,x,y+1);
    }
};

BFS解法就见鬼去吧 不想写队列啊啊啊啊

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int target) {
        if(!root) return result;
        dfs(root,target);
        return result;

    }
private:
   vector<vector<int>> result;
   vector<int> subresult;
   void dfs(TreeNode* root,int target)
   {
      if(!root) return ;
       subresult.push_back(root->val);
       target-=root->val;
       if(root->left==nullptr&&root->right==nullptr&&target==0)
       {
           result.push_back(subresult);
       }
       dfs(root->left,target);
       dfs(root->right,target);
       subresult.pop_back();//回溯
   }
};