剑指 Offer 58 - I. 翻转单词顺序 剑指 Offer 12. 矩阵中的路径

#剑指 Offer 58 - I. 翻转单词顺序

class Solution {
    public String reverseWords(String s) {
        //s.trim();
        String t=s.trim();
        //s.split(" ")  只能去除一个空格
        //s.split("\\s+") 去除一个或多个空格
        String[] str=t.split("\\s+");
        String res="";
        for(int i=str.length-1;i>=0;i--){
            res=res+str[i];
            if(i!=0) res=res+" ";
        }
        return res;
    }
}

方法二：

class Solution {
    public String reverseWords(String s) {
        int n=s.length();
        String res="";
        int flag=0;
        int i=0;
        while(i<n){
            if(s.charAt(i)==' '){
                i++;
            }else{
                String temp="";
                while(i<n && s.charAt(i)!=' '){
                    temp=temp+s.charAt(i);
                    i++;
                }
                if(flag==1){
                   temp=temp+" ";
                }
                res=temp+res;
                flag=1;
            }

        }
    return res;
    }
}

方法三：StringBuilder法

class Solution {
    public String reverseWords(String s) {
        String[] strs = s.trim().split(" "); // 删除首尾空格，分割字符串
        StringBuilder res = new StringBuilder();
        for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
            if(strs[i].equals("")) continue; // 遇到空单词则跳过
            res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
        }
        return res.toString().trim(); // 转化为字符串，删除尾部空格，并返回
    }
}

剑指 Offer 12. 矩阵中的路径

class Solution {
    public boolean exist(char[][] board, String word) {
     
      if(board.length==0||board[0].length==0) return false;
        //dfs回溯法
        char[] word1=word.toCharArray();
        boolean[][] used=new boolean[board.length][board[0].length];
        //return dfs(board,word1,used,0,0,0);
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[0].length;j++){
                 // 从 (0, 0) 点开始进行 dfs 操作，不断地去找，
                // 如果以 (0, 0) 点没有对应的路径的话，那么就从 (0, 1) 点开始去找
               if (dfs(board,word1,used,i,j,0)){
                   return true;
               }
            }
        }
        return false;
    }
    public boolean dfs(char[][] board,char[] word1,boolean[][] used,int i,int j,int start){
       // if(start==word1.length-1){
       //     return true;
       // }
        if(i<0||i>board.length-1||j<0||j>board[0].length-1||used[i][j]==true||board[i][j]!=word1[start]){
            return false;
        }
        //注意这个最后一个字符判断正确的前提是前面的条件都满足时，所以要放在后面
        if(start==word1.length-1){
           return true;
        }
        //利用used数组确保字母不能被重复利用
        used[i][j]=true;
        boolean ans=dfs(board,word1,used,i+1,j,start+1) ||
        dfs(board,word1,used,i,j+1,start+1) ||
        dfs(board,word1,used,i,j-1,start+1) ||
        dfs(board,word1,used,i-1,j,start+1) ;
        used[i][j]=false;
        return ans;
    }
}