！partition回溯搜索leetcode93_698

93. Restore IP Addresses

给一个数字组成的字符串，按照IP地址的格式返回所有可能的形式。

Input: “25525511135”
Output: [“255.255.11.135”, “255.255.111.35”]

用DFS算法，不过关键点循环次数最多是3:

public List<String> restoreIpAddresses(String s) {
    help(s, 0, new ArrayList<>(), new StringBuffer());
    return res;
}

List<String> res = new ArrayList<>();
public void help(String s, int index, List<String> ip, StringBuffer number) {
    if (ip.size() == 4 && index < s.length()) return;
    if (index == s.length()  && ip.size() == 4) {
        StringBuffer sb = new StringBuffer();
        for (String string : ip) {
            sb.append(string);
            sb.append(".");
        }
        res.add(sb.deleteCharAt(sb.length()-1).toString());
        return;
    }

	//每3个一循环，看当前数字是否合适，合适就进行递归，不合适就回溯，当进行回溯时，前面那个数字的位数就会加一（扩张了）
    for (int i = 0; i < 3; i++) {
        if (index + i >= s.length()) return;
        number.append(s.charAt(index+i));
        if (number.length() > 1 && number.charAt(0) == '0') return;
        if (Integer.parseInt(number.toString()) <= 255) {
            ip.add(number.toString());
			//这里index+i+1是因为在不同循环层数时，使index位置也跟着改变
            help(s, index+i+1, ip, new StringBuffer(""));
            ip.remove(ip.size()-1);
        }
    }
}

698. Partition to K Equal Sum Subsets

给一个数组和一个数字k，问是否可以将这个数组的所有数字分为k组，每组的和相等。

Input: nums = [4, 3, 2, 3, 5, 2, 1], k = 4
Output: True
Explanation: It’s possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.

1. 关键点在于提前算出来每组的和target是多少
2. 然后用DFS，记录当前子数组的和是否等于target，大于就跳过当前元素，小于就继续遍历，同时对用过的元素设置为已访问
3. 不知道为什么我的时间复杂度要大很多，但是代码逻辑和那些很快的一样一样的

public boolean canPartitionKSubsets(int[] nums, int k) {
    int sum = 0;
    for (int i : nums) sum += i;

    if (sum % k != 0 || k <= 0) return false;
    int[] visited = new int[nums.length];
    return help(nums, k, visited, 0, sum/k, 0);

}

public boolean help(int[] nums, int k, int[] visited, int temp, int sum, int index) {
    if (k == 1) return true;
    if (temp == sum) {
        return help(nums, k-1, visited, 0, sum, 0);
    }


    for (int i = index; i < nums.length; i++) {
        if (visited[i] != 1) {
            if (temp + nums[i] <= sum) {
                visited[i] = 1;
                if (help(nums, k, visited, temp + nums[i], sum, index + 1)) return true;
                visited[i] = 0;
            }
        }
    }
    return false;
}