LeetCode_39combinationSum2 [Combination Sum II]

#pragma warning(disable:4996)

#include <Windows.h>
#include <tchar.h>
#include <cstdio>
#include <vector>
using namespace std;

/*
	submit time : 3
		1. Runtime Error
			Last executed input:	[5,3], 5
		2. Wrong Answer
			Input:	[2,2,2], 4
			Output:	[[2,2],[2,2]]
			Expected:	[[2,2]]
	request :
		Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

		Each number in C may only be used once in the combination.

		Note:
		All numbers (including target) will be positive integers.
		Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
		The solution set must not contain duplicate combinations.
		For example, given candidate set 10,1,2,7,6,1,5 and target 8,
		A solution set is:
		[1, 7]
		[1, 2, 5]
		[2, 6]
		[1, 1, 6]
*/

//=================QuickSort===================
void Swap(int* data, int i, int j) {
	int temp = data[i];
	data[i] = data[j];
	data[j] = temp;
}

int findpivot(int* data, int i, int j) {
	return (i + j) >> 1;
}

int partition(int* data, int l, int r, int pivot) {
	while (l < r) {
		while (data[++l] < pivot);
		while (l<r && data[--r] > pivot);
		Swap(data, l, r);
	}

	return l;
}

void qsort(int* data, int i, int j) {
	if (j <= i) return;

	int pivotIndex = findpivot(data, i, j);
	Swap(data, pivotIndex, j);
	int k = partition(data, i - 1, j, data[j]);
	Swap(data, k, j);
	qsort(data, i, k - 1);
	qsort(data, k + 1, j);
}
//===================END=======================

void helpCombinationSum2(vector<vector<int> >& result, vector<int>& solution, int* pStart, int* pEnd, int* vernier, int target, bool choose) {
	if (target == 0) {
		result.push_back(solution);
		return;
	}
	if ((vernier <= pEnd && target < *vernier) || (vernier > pEnd))
		return;

	int currValue = *vernier;
	// ignore same number
	if (vernier > pStart && *vernier == *(vernier - 1)) {
		/*
			here "if" is the difference, if the same value number is not chosen,
				then do not choose it neither
		*/
		if (!choose)
			helpCombinationSum2(result, solution, pStart, pEnd, vernier + 1, target, false);
		else {
			helpCombinationSum2(result, solution, pStart, pEnd, vernier + 1, target, false);

			solution.push_back(*vernier);
			helpCombinationSum2(result, solution, pStart, pEnd, vernier + 1, target - *vernier, true);
			solution.pop_back();
		}
	}
	else {
		// does not include current value
		helpCombinationSum2(result, solution, pStart, pEnd, vernier + 1, target, false);

		// include current value
		solution.push_back(currValue);
		helpCombinationSum2(result, solution, pStart, pEnd, vernier + 1, target - currValue, true);
		solution.pop_back();
	}
}

vector<vector<int> > combinationSum2(vector<int> &num, int target) {
	vector<vector<int> > result;
	if (num.size() == 0)
		return result;

	int *vernier = &num[0], *pStart = &num[0];
	int length = num.size();
	int* lastNum = vernier + length - 1;

	// sort num
	qsort(vernier, 0, length - 1);

	vector<int> solution;
	helpCombinationSum2(result, solution, pStart, lastNum, vernier, target, false);

	return result;
}

//======================Test========================
void printVector(vector<int>& num) {
	vector<int>::iterator iter = num.begin();
	printf("[");
	for (; iter != num.end(); ++iter)
		printf("%d ", *iter);
	printf("]");
	printf("\n");
}

void Test() {
	//int data[] = { 10,1,2,7,6,1,5 };
	int data[] = { 2,2,2,2 };
	int target = 6;
	vector<int> candidates(data, data + sizeof(data) / sizeof(int));
	vector<vector<int> > result = combinationSum2(candidates, target);
	vector<vector<int> >::iterator iter = result.begin();
	for (; iter != result.end(); ++iter)
		printVector(*iter);
}

int _tmain(int argc, _TCHAR* argv[]) {
	Test();

	system("pause");
	return 0;
}

LeetCode_39combinationSum2 [Combination Sum II]