Q21:Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target.

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

Note: The solution set must not contain duplicate combinations.

Example :

Input: candidates = [10,1,2,7,6,1,5], target = 8
Output: 
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
Solution:
class Solution {
public:
void findCombinations(vector<int>& candidates, int target, int start, vector<int>& current, vector<vector<int>>& result) {
    if (target == 0) {
        result.push_back(current);
        return;
    }
    for (int i = start; i < candidates.size() && candidates[i] <= target; ++i) {
        // Skip duplicates to avoid duplicate combinations
        if (i > start && candidates[i] == candidates[i - 1]) {
            continue;
        }
        current.push_back(candidates[i]);
        findCombinations(candidates, target - candidates[i], i + 1, current, result);
        current.pop_back();
    }
}
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> result;
    vector<int> current;
    // Sort the candidates to handle duplicates
    sort(candidates.begin(), candidates.end());
    findCombinations(candidates, target, 0, current, result);
    return result;      
    }
};
Explantion:
>findCombinations Function:
 .Recursive function aiming to find combinations for the target sum.
 .Base case: If the target becomes zero, the current combination is considered 
  valid and added to the result vector.
 .Iterates through the candidates, avoiding duplicates to prevent redundant combinations.
 .Recursive calls explore combinations with and without the current candidate.

>CombinationSum2 Function:
 .Main function orchestrating the process.
 .Sorts the candidate vector to handle duplicates effectively.
 .Invokes the findCombinations function to discover valid combinations.
 .Returns the resulting vector containing unique combinations.

>Main Function:
 .Demonstrates the usage of the combinationSum2 function with a sample 
  set of candidates and a target sum.
 .Prints the discovered combinations to the console.

>In essence, the code employs a backtracking strategy to exhaustively explore 
 combinations, ensuring uniqueness and avoiding duplicate sets. Sorting is 
 applied to streamline the handling of duplicates, ultimately producing a vector
 of unique combinations.