面试经典150题(88-89)-Toy模板网

这篇具有很好参考价值的文章主要介绍了面试经典150题(88-89)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

leetcode 150道题计划花两个月时候刷完，今天（第四十四天）完成了2道(88-89)150：

88.(22. 括号生成) 题目描述：

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

第一版（没通过，我想法是（）的全排列然后找出来符合的并且去重。。超时了）

class Solution {
    List<String> res=new ArrayList();
    Set<String> set=new HashSet();
    public List<String> generateParenthesis(int n) {
        if(n<1){
            return res;
        }
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<n;i++){
            sb.append("()");
        }
        boolean[] used=new boolean[n*2];
        generateCore(sb.toString(),new StringBuilder(),used);
        return res;
    }
    public void generateCore(String str,StringBuilder sb,boolean[] used){
        if(sb.length()==str.length()){ 
            if(check(sb.toString())&&set.add(sb.toString())){
                res.add(sb.toString()); 
            }
            return ;
        }
        for(int i=0;i<str.length();i++){
            if(used[i]){
                continue;
            }
            sb.append(str.charAt(i));
            used[i]=true;
            generateCore(str,sb,used);
            used[i]=false;
            sb.deleteCharAt(sb.length()-1);
        }
    }

    public boolean check(String str){
        Stack<Character> stack=new Stack();
        for(char ch:str.toCharArray()){
            if(ch=='('){
                stack.push(ch);
            }else{
                if(stack.isEmpty()){
                    return false;
                }
                stack.pop();
            }
        }
        return stack.isEmpty();
    }
}

第二版（看了解题）

class Solution {
    List<String> res=new ArrayList();
    public List<String> generateParenthesis(int n) {
        if(n<1){
            return res;
        }
        generateCore(new StringBuilder(),n,n);
        return res;
    }
    public void generateCore(StringBuilder sb,int left,int right){
        //左边和右边剩余的括号数都等于 0 的时候结算。
        if(left==0&&right==0){ 
            res.add(sb.toString());
            return ;
        }
        //产生左分支的时候，只看当前是否还有左括号可以使用；
        if(left>0){
            sb.append("(");
            generateCore(sb,left-1,right);
            sb.deleteCharAt(sb.length()-1);
            
        }
        //产生右分支的时候，还受到左分支的限制，
        //右边剩余可以使用的括号数量一定得在严格大于左边剩余的数量的时候
        if(right>0&&right>left){
            sb.append(")");
            generateCore(sb,left,right-1);
            sb.deleteCharAt(sb.length()-1);
        }
    }
}

89.（79. 单词搜索）题目描述：

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

第一版（没超时，但是效率垫底，还没来得及看解题。。）

class Solution {
    public boolean exist(char[][] board, String word) {
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                if(board[i][j]==word.charAt(0)){
                    boolean[][] used=new boolean[board.length][board[0].length];
                    if(dfs(board,word,i,j,new StringBuilder(),used))
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    public boolean dfs(char[][] board, String word,int mIndex,int nIndex,StringBuilder sb,boolean[][] used) {
        int m=board.length;
        int n=board[0].length;
        if(mIndex<0||mIndex>=m){
            return false;
        }
        if(nIndex<0||nIndex>=n){
            return false;
        }
        if(used[mIndex][nIndex]){
            return false;
        }
        sb.append(board[mIndex][nIndex]);
        used[mIndex][nIndex]=true;
        if(sb.length()>word.length()){
            sb.deleteCharAt(sb.length()-1);
            used[mIndex][nIndex]=false;
            return false;
        }else if(sb.length()==word.length()){
            if(word.equals(sb.toString())){
                sb.deleteCharAt(sb.length()-1);
                used[mIndex][nIndex]=false;
                return true;
            }else{
                sb.deleteCharAt(sb.length()-1);
                used[mIndex][nIndex]=false;
                return false;
            }
        }else{
            if(!word.substring(0,sb.length()).equals(sb.toString())){
                sb.deleteCharAt(sb.length()-1);
                used[mIndex][nIndex]=false;
                return false;
            }
        }
        
        boolean flag=dfs(board, word, mIndex + 1, nIndex, sb, used) ||
                dfs(board, word, mIndex - 1, nIndex, sb, used) ||
                dfs(board, word, mIndex, nIndex + 1, sb, used) ||
                dfs(board, word, mIndex, nIndex - 1, sb, used);
        if(!flag){
            sb.deleteCharAt(sb.length()-1);
            used[mIndex][nIndex]=false;
        }
        return flag;
    }
}

难啊！！！咋这么难这块。。。后面还有动态规划我咋办。。

加油吧，早日跳槽！！！

-----2024.01.18 看了一下 89.（79. 单词搜索）的解题，发现不需要用 String Builder 去记录遍历的过的字符合只需要每次去将当前遍历和要搜索的对比就行。改了一下效率立马就上去。。

第二版（看了解题）

class Solution {
    public boolean exist(char[][] board, String word) {
         boolean[][] used=new boolean[board.length][board[0].length];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                if(board[i][j]==word.charAt(0)){
                    if(dfs(board,word,i,j,0,used))
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    public boolean dfs(char[][] board, String word,int mIndex,int nIndex,int index,boolean[][] used) {
        if(index>=word.length()){
            return true;
        }
        int m=board.length;
        int n=board[0].length;
        if(mIndex<0||mIndex>=m){
            return false;
        }
        if(nIndex<0||nIndex>=n){
            return false;
        }
        if(used[mIndex][nIndex]){
            return false;
        }
      
        if(board[mIndex][nIndex]!=word.charAt(index))
        {
            return false;
        }
        used[mIndex][nIndex]=true;
        boolean flag=dfs(board, word, mIndex + 1, nIndex, index+1, used)||
        dfs(board, word, mIndex - 1, nIndex, index+1, used)||
        dfs(board, word, mIndex, nIndex + 1, index+1, used)||
        dfs(board, word, mIndex, nIndex - 1, index+1, used);
        if(flag){
            return flag;
        }
        used[mIndex][nIndex]=false;
        return flag;
    }
}