LeetCode 39: Combination Sum

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
The same repeated number may be chosen from C unlimited number of times.
Note:

• All numbers (including target) will be positive integers.
• Elements in a combination (a₁, a₂, … , a_k) must be in non-descending order. (ie, a₁ ≤ a₂ ≤ … ≤ a_k).
• The solution set must not contain duplicate combinations.

For example, given candidate set 2,3,6,7 and target 7,
A solution set is:
[7]
[2, 2, 3]

public class Solution {
    private List<List<Integer>> result;
    private List<Integer> x;
    private int sum;
    
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        // Backtracking problem
        // Firstly, sort candidates array
        result = new LinkedList<>();
        int n = candidates.length;
        
        if (n == 0)
            return result;
            
        Arrays.sort(candidates);
   
        x = new LinkedList<>();
        
        for (int i = 0; i < n; i++)
        {
            if (i==0 || candidates[i] > candidates[i-1]) // Avoid duplicates
            {
                x.clear();
                sum = 0;
                backTracking(candidates, target, i);
            }
        }
        
        return result;
    }
    
    private void backTracking(int[] cd, int target, int cnt)
    {
        x.add(cd[cnt]);
        sum += cd[cnt];
                
        if (sum < target)
            for (int i = cnt; i < cd.length; i++)
                backTracking(cd, target, i);
        else if (sum == target)
        {
            List<Integer> ret = new LinkedList<>(x);
            
            if (!result.contains(ret)) // Avoid duplicates
                result.add(ret);
        }

        x.remove(x.size()-1);   
        sum -= cd[cnt];
    }
}