LeetCode每日十题---回溯算法（一）

1.题目描述

1.1笔者分析

很经典的一道递归题目，这里比较巧妙的是+256，只要不会影响到结果，可直接在原数组上修改来实现visited数组的功能。

class Solution {
    public boolean exist(char[][] board, String word) {
      for(int i=0;i<board.length;i++){
          for(int j=0;j<board[0].length;j++){
              if(search(board,word,i,j,0)){
                  return true;
              }
          }
      }
      return false;
    }
    boolean search(char[][] board,String word,int i,int j,int k){
        if(k>=word.length())return true;
        if(i<0||i>=board.length||j<0||j>=board[0].length||board[i][j]!=word.charAt(k))return false;
        board[i][j]+=256;
                boolean result = search(board, word, i - 1, j, k + 1) || search(board, word, i + 1, j, k + 1)
                || search(board, word, i, j - 1, k + 1) || search(board, word, i, j + 1, k + 1);
        board[i][j] -= 256;
        return result;
    }
}

2.题目描述

2.1笔者分析

比较巧妙的一种子集去重方法

class Solution {
      public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> retList = new ArrayList<>();
        retList.add(new ArrayList<>());
        if(nums == null || nums.length == 0) return retList;
        Arrays.sort(nums);  
        List<Integer> tmp = new ArrayList<>();
        tmp.add(nums[0]);
        retList.add(tmp);
        if(nums.length == 1) return retList;
        
        int lastLen = 1;
        
        for(int i = 1; i < nums.length; i++){
            int size = retList.size();
            if(nums[i] != nums[i-1]){
                lastLen = size;
            }
            
            for(int j = size - lastLen; j < size; j++){
                List<Integer> inner = new ArrayList(retList.get(j));
                inner.add(nums[i]);
                retList.add(inner);
            }
        }
        return retList;
    }
}

总结

相比动态规划，回溯算法简单多了，每日打卡三十七天，以下图为证