LeetCode40 Combination Sum II 解析

详细见：leetcode.com/problems/combination-sum-ii

C和Python的去重算法，应该记住。

Java是很久之前写的，并不好。

规则是：相同数字。

        1，前面选了，后面一定要选。

        2，前面没选，后面可选可不选。

注意一定要选到最后一位，才能判断。

Java Solution: github

package leetcode;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;


public class P040_CombinationSumII {
	public static void main(String[] args) {
//		System.out.println(new Solution2().combinationSum2(new int[] {10, 1, 2, 7, 6, 1, 5}, 8));
//		System.out.println(new Solution2().combinationSum2(new int[] {2, 5, 2, 1, 2}, 5));
		System.out.println(new Solution2().combinationSum2(new int[] {3,1,3,5,1,1}, 8));
	}
	
	/*
	 * 	15 ms
	 * 	26.62%
	 */
	static class Solution2 {
		List<List<Integer>> ans = null;
		boolean[] isAnswer = null;
		int[] index1 = null, index2 = null;
		public List<List<Integer>> combinationSum2(int[] candidates, int target) {
			if (candidates == null || candidates.length == 0)
	    		return ans;
			Arrays.sort(candidates);
			ans = new LinkedList<List<Integer>>();
			isAnswer = new boolean[candidates.length];
			index1 = new int[candidates.length];
			index1[0] = 0;
			for (int i = 1; i != candidates.length; i ++)
				index1[i] = candidates[i] == candidates[i - 1] ? index1[i - 1] : i;
			index2 = new int[candidates.length];
			index2[index2.length - 1] = index2.length - 1;
			for (int i = index2.length - 2; i != -1; i --)
				index2[i] = candidates[i] == candidates[i + 1] ? index2[i + 1] : i;
			searchAllAns(candidates, -1, target);
			return ans;
		}
		private void searchAllAns(int[] candidates, int index, int target) {
			if (target == 0) {
				List<Integer> answer = new LinkedList<Integer>();
				for (int i = 0; i != candidates.length; i ++)
					if (isAnswer[i])
						answer.add(candidates[i]);
				if (answer.size() != 0)
					ans.add(answer);
			}
			if (index == candidates.length || target < 0)
				return;
			for (int i = index + 1; i != candidates.length; i ++) {
				if (isAnswer[i])
					continue;
				if (index1[i] == i && index2[i] == i) {
					isAnswer[i] = true;
					searchAllAns(candidates, i, target - candidates[i]);
					isAnswer[i] = false;
				} else {
					int num = index2[i] - index1[i] + 1;
					i = index2[i];
					for (int j = 1; j <= num; j ++) {
						for (int k = 0; k != j; k ++)
							isAnswer[k + index1[i]] = true;
						searchAllAns(candidates, i, target - j * candidates[i]);
						for (int k = 0; k != j; k ++)
							isAnswer[k + index1[i]] = false;
					}
				}
			}
		}
	}
}

C Solution: github

/*
    url: leetcode.com/problems/combination-sum-ii/
    AC 12ms 27.27%
*/

#include <stdio.h>
#include <stdlib.h>

//array list start

typedef int* T;
typedef struct al sal;
typedef struct al * pal;

struct al {
    int capacity;
    int size;
    T* arr;
};

void al_expand_capacity(pal l) {
    T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));
    int i = 0;
    for (i = 0; i < l->capacity; i ++)
        new_arr[i] = l->arr[i];
    free(l->arr);
    l->arr = new_arr;
    l->capacity = l->capacity * 2 + 1;
}

void al_add_last(pal l, T v) {
    if (l->capacity == l->size) al_expand_capacity(l);
    l->arr[l->size] = v;
    l->size ++;
}

void al_add_first(pal l, T v) {
    int i = 0;
    if (l->capacity == l->size) al_expand_capacity(l);
    for (i = l->size; i > 0; i --)
        l->arr[i] = l->arr[i - 1];
    l->arr[0] = v;
    l->size ++;
}

void al_add_to_index(pal l, T v, int index) {
    int i = 0;
    if (index > l->size) return;
    if (l->capacity == l->size) al_expand_capacity(l);
    for (i = l->size - 1; i >= index; i --) {
        l->arr[i+1] = l->arr[i];
    }
    l->arr[index] = v;
    l->size ++;
}

//if T is ptr, need to free l->size - 1
void al_remove_last(pal l) {
    if (l->size == 0) return;
    l->arr[l->size - 1] = 0; //or NULL and free
    l->size --;
}

//if T is ptr, need to free 0
void al_remove_first(pal l) {
    int i = 0;
    if (l->size == 0) return;
    l->arr[0] = 0; //or NULL and free
    for (i = 1; i < l->size; i ++) {
        l->arr[i - 1] = l->arr[i];
    }
    l->size --;
}

T* al_convert_to_array_free_l(pal l) {
    T* arr = l->arr;
    free(l);
    return arr;
}

T al_access_by_index(pal l, int index) {
    if (index >= l->size || index < 0) return 0;
    return l->arr[index];
}

void al_free_all(pal l) {
    free(l->arr);
    free(l);
}

void al_print(pal l) {
    int i = 0;
    if (l->size == 0) return;
    for (i = 0; i < l->size; i ++)
        printf("%d ", l->arr[i]);
    printf("\r\n");
}

//array list end


//quick srot start

//[l, r]
int _partition(int* n, int l, int r) {
    int s = *(n + l);
    while (l < r) {
        while (l < r && *(n + r) >= s) r --;
        *(n + l) = *(n + r);
        while (l < r && *(n + l) <= s) l ++;
        *(n + r) = *(n + l);
    }
    *(n + l) = s;
    return l;
}

//[l, r)
void _quick_sort(int* n, int l, int r) {
    int p = 0;
    if (l < r) {
        p = _partition(n, l, r - 1);
        _quick_sort(n, l, p);
        _quick_sort(n, p + 1, r);
    }
}

void quick_sort(int* n, int s) {
    _quick_sort(n, 0, s);
}

//quick sort end

void search(pal l, int* c, int ci, int cn, int** rn, int t, int sign, int* s, int si) {
    int* temp = NULL, i = 0;
    if (t == 0 && ci == cn) {
        temp = (int*) malloc(sizeof(int) * si);
        for (i = 0; i < si; i ++)
            temp[i] = s[i];
        (*rn)[l->size] = si;
        al_add_last(l, temp);
        return;
    }
    if (t < 0 || ci == cn) return;
    // sign = 1 and c[ci - 1] == c[ci] : not
    if (!(sign && c[ci - 1] == c[ci])) {
        search(l, c, ci + 1, cn, rn, t, 0, s, si);
    }
    s[si] = c[ci];
    search(l, c, ci+1, cn, rn, t-c[ci], 1, s, si+1);
}

int** combinationSum2(int* c, int cn, int t, int** rn, int* r) {
    int* s = (int*) malloc(sizeof(int) * cn);
    pal l = (pal) malloc(sizeof(sal));
    l->size = 0;
    l->capacity = 16;
    l->arr = (T*) malloc(sizeof(T) * l->capacity);
    quick_sort(c, cn);
    *rn = (int*) malloc(sizeof(int) * (cn*cn));
    search(l, c, 0, cn, rn, t, 0, s, 0);
    *r = l->size;
    free(s);
    return al_convert_to_array_free_l(l);
}

int main() {
    int c[] = {1, 1};
    int cn = 2; 
    int t = 1;
    int* rn = NULL;
    int r = 0;
    int** ans = combinationSum2(c, cn, t, &rn, &r);
    int i = 0, j = 0;
    printf("r is %d\r\n", r);
    for (i = 0; i < r; i ++) {
        for (j = 0; j < rn[i]; j ++)
            printf("%d ", ans[i][j]);
        printf("\r\n");
        free(ans[i]);
    }
    free(ans);
    return 0;
}

Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/combination-sum-ii/
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年4月6日
    @details:    Solution: 286ms 16.23%
'''

class Solution(object):
    def search(self, ans, s, si, c, ci, cn, t, sign):
        if t == 0 and ci == cn:
            ans_t=[0]*si
            for i in range(si):
                ans_t[i] = s[i]
            ans.append(ans_t)
            return
        if t < 0 or ci == cn:
            return
        if not(sign and c[ci - 1] == c[ci]):
            self.search(ans, s, si, c, ci+1, cn, t, False)
        s[si] = c[ci]
        self.search(ans, s, si+1, c, ci+1, cn, t-c[ci], True)
        
                
    def combinationSum2(self, c, t):
        """
        :type c: List[int]
        :type t: int
        :rtype: List[List[int]]
        """
        cn = 0 if c == None else len(c)
        if cn == 0: return []
        c.sort(key=None, reverse=False)
        s, si, ans=[0]*cn, 0, []
        self.search(ans, s, si, c, 0, cn, t, False)
        return ans

if __name__ == "__main__":
    print(Solution().combinationSum2([1,1], 1))