<p>Given an array of <strong>distinct</strong> integers <code>candidates</code> and a target integer <code>target</code>, return <em>a list of all <strong>unique combinations</strong> of </em><code>candidates</code><em> where the chosen numbers sum to </em><code>target</code><em>.</em> You may return the combinations in <strong>any order</strong>.</p>

<p>The <strong>same</strong> number may be chosen from <code>candidates</code> an <strong>unlimited number of times</strong>. Two combinations are unique if the <span data-keyword="frequency-array">frequency</span> of at least one of the chosen numbers is different.</p>

<p>The test cases are generated such that the number of unique combinations that sum up to <code>target</code> is less than <code>150</code> combinations for the given input.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> candidates = [2,3,6,7], target = 7
<strong>Output:</strong> [[2,2,3],[7]]
<strong>Explanation:</strong>
2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
7 is a candidate, and 7 = 7.
These are the only two combinations.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> candidates = [2,3,5], target = 8
<strong>Output:</strong> [[2,2,2,2],[2,3,3],[3,5]]
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> candidates = [2], target = 1
<strong>Output:</strong> []
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= candidates.length &lt;= 30</code></li>
	<li><code>2 &lt;= candidates[i] &lt;= 40</code></li>
	<li>All elements of <code>candidates</code> are <strong>distinct</strong>.</li>
	<li><code>1 &lt;= target &lt;= 40</code></li>
</ul>

class Solution {
public:
   void combinationSumUtil(vector<int> &A, int sum, 
    vector<vector<int> >&result, vector<int> current, int pos)
    {
    	if(sum==0){ 
    		result.push_back(current);
    		return;
    	}
    	if(sum<0 || pos>=A.size()) 
    		return; 
        
    	current.push_back(A[pos]); 
    	
    	combinationSumUtil(A, sum-A[pos], result,  current, pos );
    	
    	current.pop_back(); 
    	
    	combinationSumUtil(A, sum, result,  current, pos+1 ); 
    	
    }
    
    //Function to return a list of indexes denoting the required 
    //combinations whose sum is equal to given number.
    vector<vector<int> > combinationSum(vector<int> &A, int B)
    {
        sort(A.begin(),A.end());
    	vector<vector<int> > result;
    	vector<int> current, C;
    	int i,j;
    	for(i=0;i<A.size();i++)
    	{
    	    j=i+1;
    	    while(j<A.size()&&A[i]==A[j]){
    	        j++;
    	    }
    	    C.push_back(A[i]);
    	    i=j-1;
    	}
    	combinationSumUtil(C, B, result, current,0);
        
    	return result;

    }
};
62100