LeetCode---Backtracking && DP

**322. Coin Change

思路：动态规划，构造一个数组，存入当前index最少需要多少个coin

public int coinChange(int[] coins, int amount) {
    if(coins == null || coins.length == 0 || amount <= 0) return 0;
    //表示Index需要多少个coin
    int[] dp = new int[amount + 1];
    for(int i = 1; i < amount + 1; i++){
        dp[i] = Integer.MAX_VALUE;
        for(int j = 0; j < coins.length; j++){
            if(coins[j] <= i && dp[i - coins[j]] != Integer.MAX_VALUE){
                dp[i] = Math.min(dp[i],dp[i - coins[j]] + 1);
            }
        }
    }
    return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
}

377. Combination Sum IV

思路：构造一个数组，存入当前index能有几种组成方式

public int combinationSum4(int[] nums, int target) {
    if(nums == null || nums.length == 0) return 0;
    int[] dp= new int[target + 1];
    dp[0] = 1;
    for(int i = 1; i < target + 1; i++){
        for(int j = 0; j < nums.length; j++){
            //数组中提供了什么，就将小于target元素的组成种数加起来即可
            if(i >= nums[j]) dp[i] += dp[i - nums[j]];
        }
    }
    return dp[target];
}

51. N-Queens

思路：回溯，构造一个二维数组存solution，同时也判断每一次放Queen是否满足要求

public List<List<String>> solveNQueens(int n) {
    List<List<String>> res = new ArrayList<List<String>>();
    char[][] ans = new char[n][n];
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            ans[i][j] = '.';
        }
    }
    getResult(res,ans,0);
    return res;
}

public void getResult(List<List<String>> res,char[][] ans,int k){
    int n = ans.length;
    if(k == n){
        res.add(construct(ans));
        return;
    }
    
    //k表示列，根据每一列进行搜索，因此列肯定不相同，因此下面不用判断列
    for(int i = 0; i < n; i++){
        if(isValid(i,k,ans)){
            ans[i][k] = 'Q';
            getResult(res,ans,k + 1);
            ans[i][k] = '.';
        }
    }
}

public boolean isValid(int x,int y,char[][] ans){
    for(int i = 0; i < ans.length; i++){
        for(int j = 0; j < ans[0].length; j++){
            if(ans[i][j] == 'Q' && (x - i == y - j || x - i == j - y || x == i)){
                return false;
            }
        }
    }
    return true;
}

public List<String> construct(char[][] ans){
    List<String> res = new ArrayList<String>();
    for(int i = 0; i < ans.length; i++){
        String s = new String(ans[i]);
        res.add(s);
    }
    return res;
}

**131. Palindrome Partitioning

思路：回溯，每趟从start开始，判断若是Palindrome则存入，不是则继续循环

public List<List<String>> partition(String s) {
    List<List<String>> res = new ArrayList<List<String>>();
    List<String> ans = new ArrayList<String>();
    getResult(res,ans,s,0);
    return res;
}

public void getResult(List<List<String>> res,List<String> ans,String s,int start){
    if(start == s.length()){
        res.add(new ArrayList<String>(ans));
        return;
    }
    
    for(int i = start; i < s.length(); i++){
        if(isPalindrome(s,start,i)){
            ans.add(s.substring(start,i + 1));
            getResult(res,ans,s,i + 1);
            ans.remove(ans.size() - 1);
        }
    }
}

public boolean isPalindrome(String s,int low,int high){
    while(low <= high){
        if(s.charAt(low) != s.charAt(high)){
            return false;
        }
        low++;
        high--;
    }
    return true;
}

**416. Partition Equal Subset Sum

思路：首先根据数学关系可以判断sum一定是偶数，然后判断有没有子集之和等于sum / 2

public boolean canPartition(int[] nums) {
    if(nums == null || nums.length == 0) return true;
    int sum = 0;
    for(int i : nums){
        sum += i;
    }
    if(sum % 2 != 0) return false;
    sum /= 2;
    
    //dp[i]表示i是否是数组子集和，若dp[j - nums[i]]是，那么dp[j]一定是
    boolean[] dp = new boolean[sum + 1];
    dp[0] = true;
    for(int i = 0; i < nums.length; i++){
        for(int j = sum; j >= nums[i]; j--){
            dp[j] = dp[j] || dp[j - nums[i]];
        }
    }
    return dp[sum];
}

**494. Target Sum

思路：根据数学关系：若将正数组合和负数组合分别表示为P和N，则P - N = S => P - N + P + N = S + P + N => 2*P = S + sum，转化为有多少个数组子集为P，即同题416

public int findTargetSumWays(int[] nums, int S) {
    //若将正数组合和负数组合分别表示为P和N，则P - N = S => P - N + P + N = S + P + N => 2*P = S + sum，转化为有多少个数组子集为P
    if(nums == null || nums.length == 0) return 0;
    int sum = 0;
    for(int i : nums){
        sum += i;
    }
    return sum < S || (S + sum) % 2 != 0 ? 0 : dfs(nums,(S + sum) / 2);
}

public int dfs(int[] nums,int target){
    int[] dp = new int[target + 1];
    dp[0] = 1;
    for(int i = 0; i < nums.length; i++){
        for(int j = target; j >= nums[i]; j--){
            dp[j] += dp[j - nums[i]];
        }
    }
    return dp[target];
}

139. Word Break

思路：动态规划，构造数组表示从当前分割之前的字符串在dict里是否存在

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

总结

70. Climbing Stairs:动态规划，形成一个斐波那契数列，用递归会超时
77. Combinations:回溯，每趟从头开始循环
357. Count Numbers with Unique Digits:数学规律：一位为10个，两位为9*9个，三位为9*9*8个...
198. House Robber:动态规划，递归方程式：dp[i] = Math.max(nums[i] + dp[i - 2],dp[i - 1]);
343. Integer Break:数学规律：4=2*2 5<2*3...则一定按2或3来分，而6=2+2+2=3+3 3*3>2*2*2，因此按3分直到num小于4
52. N-Queens II：同N-Queens，设置一个全局变量，每次符合则加一，注意不能是static，否则每次运行都会将前面运行过的结果算进去
46. Permutations:回溯，每趟从头开始，需要判断有没有重复
60. Permutation Sequence：同Permutations，只不过会超时，需要用数学手段通过k来判断字符的具体顺序
303. Range Sum Query - Immutable:动态规划：递归方程式为dp[i] = dp[i - 1] + nums[i]
304. Range Sum Query 2D - Immutable：动态规划，先算边界，再算中间

训练

413. Arithmetic Slices:由于等差数列要求必须连续，则每次计算以当前元素结尾的等差数列有几个（比上一次多1），如果不连续则重置，将所有结果相加
213. House Robber II:方法和House Robber一样，只是要分两次求最大值，因为第一家和最后一家不能同时偷，两次调用函数时注意挪位问题
368. Largest Divisible Subset:构造一个数组dp存入当前num结尾时的序列长度，然后取得最大长度的Index，同时判断整除关系和dp[index]是否符合条件依次获得序列的每个元素	
47. Permutations II：同Permutations，只是要去重
**467. Unique Substrings in Wraparound String:动态规划，同413，每次计算以当前字符结尾的连续数列有几个（比上一次多1），如果不连续则重置，将所有结果相加

提示

1.字符运算成整形->'c' - 'a' = 2  整形运算成字符 (char)('0' + 1) = '1'
2.判断字符串中是否含有字符：s.indexOf(char)，不能用s.contains()->参数为charSequence