解题--＞在线OJ(十二)

1.子集

解题：

class Solution {
   List<List<Integer>> result=new ArrayList<>();
    List<Integer> list=new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        result.add(new ArrayList<>(list));
        backtracking(0,nums);
        return result;
    }
    public void backtracking(int index,int[] nums){
        for(int i=index;i<nums.length;i++){
            list.add(nums[i]);
            result.add(new ArrayList<>(list));
            backtracking(i+1,nums);
            list.remove(list.size()-1);
        }
    }
}

2.单词搜索

解题：

class Solution {
   int m;
    int n;
    char[] letter;
    char[][] board1;
    boolean[][] visited;
    public boolean exist(char[][] board, String word) {
        this.m=board.length;
        this.n=board[0].length;
        this.letter=word.toCharArray();
        this.board1=board;
        this.visited=new boolean[m][n];
        for(int i=0;i<m;i++) {
            for (int j = 0; j < n; j++) {
                boolean result=judge(i,j,0);
                if(result){
                    return true;
                }
            }
        }
        return false;
    }
    public boolean judge(int i,int j,int k){
        if(k>=letter.length){
            return true;
        }
        if(i<0 || j<0 || i>=m || j>=n || visited[i][j] || letter[k]!=board1[i][j]){
            return false;
        }
        visited[i][j]=true;
        boolean res=judge(i+1,j,k+1)||judge(i-1,j,k+1)
                || judge(i,j-1,k+1) || judge(i,j+1,k+1);
        visited[i][j]=false;
        return res;
    }
}

3.不同的二叉搜索树

解题：动态规划

class Solution {
    public int numTrees(int n) {
        int[] result=new int[n+1];
        result[0]=1;
        result[1]=1;
        for(int i=2;i<=n;i++){
            result[i]=0;
            for(int j=1;j<=i;j++){
                result[i]+=result[j-1]*result[i-j];
            }
        }
        return result[n];
    }
}

4.验证二叉搜索树

解题：
二叉搜索树的特点是：左<中<右；
中序遍历===》左，中，右
所以，将树中序遍历，所得结果，遍历一下，如果每个结点都比上一个结点大的话，就证明这棵树是二叉搜索树，如果出现当前结点比上一个结点值小的话，就直接返回false。

class Solution {
  List<Integer> list=new ArrayList<>();
    public boolean isValidBST(TreeNode root) {
       inorderTraversal(root);
       int ret=list.get(0);
       for(int i=1;i<list.size();i++){
           if(list.get(i)<=ret){
               return false;
           }
           ret=list.get(i);
       }
       return true;
    }
    public void inorderTraversal(TreeNode root){
        if(root==null){
            return;
        }
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);
    }
}

5.二叉树展开为链表

解题思路：
递归调用

class Solution {
   public void flatten(TreeNode root) {
        if(root==null){
            return;
        }
       root=flatten2(root);
    }
    public TreeNode flatten2(TreeNode root){
        if(root==null){
            return null;
        }
        TreeNode l=flatten2(root.left);
        TreeNode r=flatten2(root.right);
        if(l==null){
            root.right=r;
        }else{
            root.right=l;
            TreeNode current=l;
            while(current.right!=null){
                current=current.right;
            }
            current.right=r;
        }
         root.left=null;
        return root;
    }
}

6.最长连续序列

解题思路：
1.利用Arrays.sort()，将数组进行排序；
2.从头到尾遍历数组，如果当前元素-前一个数组=1，就证明这两个数数字是连续的,count++,如果结果>1,就证明这两个数字不是连续的，就将count=1;
3.每遍历一次，就更新max，max取max和count的最大值。

class Solution {
   public static int longestConsecutive(int[] nums) {
         if(nums==null || nums.length==0){
            return 0;
        }
         if(nums.length==1){
            return 1;
        }
        Arrays.sort(nums);
        int max=0;
        int ret=nums[0];
        int count=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]-ret==1){
                count++;
            }else if(nums[i]-ret>1){
                count=1;
            }
            ret=nums[i];
            max=Math.max(count,max);
        }
        return max;
    }
}

7.单词拆分（139）

解题：

class Solution {
    public static boolean wordBreak(String s, List<String> wordDict) {
        if(s==null){
            return true;
        }
        if(s!=null && wordDict==null){
            return false;
        }
        boolean[] result=new boolean[s.length()+1];
        result[0]=true;
        for(int i=1;i<=s.length();i++){
            for(int j=0;j<i;j++){
                if(result[j]&& wordDict.contains(s.substring(j,i))){
                    result[i]=true;
                    break;
                }
            }
        }
        return result[s.length()];
    }
}

8. 2的幂

解题思路：
如果一个数字是2的幂次方，这个数有一个特点就是，不断的除以2，最终结果是1，并且，在这个过程中，结果都是偶数。根据这个特点，写循环，最终就能判断一个数字是否是2的幂次方。

class Solution {
      public static boolean isPowerOfTwo(int n) {
        if(n<=0){
            return false;
        }
        if(n==1){
            return true;
        }
        while(n!=1){
            if(n%2!=0){
                return false;
            }
            n=n/2;
        }
        return true;
    }
}

9.反转字符串（344）

解题：

class Solution {
      public void reverseString(char[] s) {
        int left=0;
        int right=s.length-1;
        while(left<right){
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }
}

10.Nim游戏（292）

当n=4或者是4的倍数的时候，此时，你一定是输的，所以在这个题目中，只需要判断n是否为4的倍数即可。

class Solution {
     public boolean canWinNim(int n) {
        if(n%4==0){
            return false;
        }
        return true;
    }
}