JAVA dfs

22. 括号生成

 

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

示例 1：

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

示例 2：

输入：n = 1
输出：["()"]

class Solution {
    int n;
    List<String> ret  =new ArrayList();
    public List<String> generateParenthesis(int n) {
     
     this.n  =n;
     StringBuilder ans = new StringBuilder();
     dfs(ans,0,0);
     return ret;
    }
    void dfs(StringBuilder ans,int le,int ri){
           if(ans.length()==2*n){
               ret.add(ans.toString());
               return ;
           }
           if(le<n){
               ans.append('(');
               dfs(ans,le+1,ri);
               ans.deleteCharAt(ans.length()-1);
           }
           if(ri<le){
               ans.append(')');
               dfs(ans,le,ri+1);
               ans.deleteCharAt(ans.length()-1);
           }

    }
}

79. 单词搜索

 

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

 

class Solution {
    boolean vis[][];
    int dir[][]={{0,1},{0,-1},{1,0},{-1,0}};
    StringBuilder str  =new StringBuilder();
    int flag =0;
    int m,n;
    public boolean exist(char[][] board, String word) {
         m  =board.length;
         n  =board[0].length;
             vis =new boolean[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      if(flag==1) {
                          return true;
                      }
                      if(board[i][j]==word.charAt(0)){
                          dfs(i,j,board,word);
                          str.deleteCharAt(0);
                      }
                  }
              }
              return flag==1;
    }
    void  dfs(int x,int y,char [][] board,String word){
          if(flag==1) return ;
          str.append(board[x][y]);
           if(str.charAt(str.length()-1)!=word.charAt(str.length()-1)) 
           {   
                return ;
           }
           vis[x][y]  =true;
          if(str.toString().equals(word)) {
              flag  =1;
              return ;
          }
          for(int i=0;i<4;i++){
              int xx=x+dir[i][0];
              int yy  =y+dir[i][1];
               if(xx<0||xx>=m||yy<0||yy>=n) continue ;         
              if(!vis[xx][yy]){          
                  dfs(xx,yy,board,word);
                  if(flag==1)  return ;
                  str.deleteCharAt(str.length()-1);
              }
          }
           vis[x][y]  =false;
    }
}

 

 由于题目只需要判断是否存在word，不需要记录字符串

class Solution {
    boolean vis[][];
    int dir[][]={{0,1},{0,-1},{1,0},{-1,0}};
    StringBuilder str  =new StringBuilder();
    boolean ret  =false;
    int m,n;
    public boolean exist(char[][] board, String word) {
         m  =board.length;
         n  =board[0].length;
             vis =new boolean[m][n];
              for(int i=0;i<m;i++){
                  for(int j=0;j<n;j++){
                      if(ret==true) {
                          return true;
                      }
                      if(board[i][j]==word.charAt(0)){
                          ret  = dfs(i,j,board,word,0);
                      }
                  }
              }
              return ret;
    }
    boolean  dfs(int x,int y,char [][] board,String word,int num){     
           if(board[x][y]!=word.charAt(num)) 
           {   
                return false;
           }
           vis[x][y]  =true;
          if(num==word.length()-1) {
              return true;
          }
          for(int i=0;i<4;i++){
              int xx=x+dir[i][0];
              int yy  =y+dir[i][1];
               if(xx<0||xx>=m||yy<0||yy>=n) continue ;         
              if(!vis[xx][yy]){          
                 boolean flag =  dfs(xx,yy,board,word,num+1);
                  if(flag)  return true ;
              }
          }
           vis[x][y]  =false;
           return false;
    }
}

剑指 Offer 34. 二叉树中和为某一值的路径

 

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    LinkedList<Integer> l  =new LinkedList();
    List<List<Integer>> ll  =new LinkedList<List<Integer>>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
               
               dfs(root,target);
               return ll;
    }
    void dfs(TreeNode root,int target){
             if(root==null) return ;
               l.add(root.val);
               target-=root.val;
              if(root.left==null&&root.right==null){
                  if(target==0){
                      ll.add(new LinkedList(l));
                 }
              }
              dfs(root.left,target);
              dfs(root.right,target);
              l.removeLast();
    }
}