40. Combination Sum II

Author: Kai Yang

40.CombinationSumII.Test.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+[TestFixture]
+public class TestClass : TestClassBase
+{
+    [TestCase("[1,2,3]", 3)]
+    [TestCase("[10,7,4,10,8,4,2,3,9,9]", 55)]
+    public void TestMethod1(string candidatesString, int target)
+    {
+        var candidates = JsonConvert.DeserializeObject<int[]>(candidatesString);
+        var expectedResult = CombinationSum2(candidates, target);
+        var result = new Solution().CombinationSum2(candidates, target);
+        Assert.AreEqual(Serialize(expectedResult), Serialize(result), string.Format("{0}. {1}.", candidatesString, target));
+    }
+
+    [TestCase(10, 10, 100)]
+    public void TestMethod2(int maxLength, int maxValue, int repeatTimes)
+    {
+        Repeat(repeatTimes, () =>
+        {
+            var candidates = GenerateIntegerArray(0, maxLength, 1, maxValue);
+            var candidatesString = JsonConvert.SerializeObject(candidates);
+            var target = Random.Next(1, Math.Max(2, candidates.Sum() + 2));
+            TestMethod1(candidatesString, target);
+        });
+    }
+
+    private IList<IList<int>> CombinationSum2(int[] candidates, int target)
+    {
+        var results = new List<IList<int>>();
+        Search(results, new Stack<int>(), candidates, target, 0);
+        results = results.GroupBy(item => JsonConvert.SerializeObject(item)).Select(g => g.First()).ToList();
+        return results;
+    }
+
+    private void Search(IList<IList<int>> results, Stack<int> temp, int[] candidates, int remaining, int index)
+    {
+        if (remaining == 0)
+        {
+            if (temp.Count > 0)
+            {
+                results.Add(temp.OrderBy(x => x).ToList());
+            }
+            return;
+        }
+        if (remaining < 0 || index >= candidates.Length)
+        {
+            return;
+        }
+        temp.Push(candidates[index]);
+        Search(results, temp, candidates, remaining - candidates[index], index + 1);
+        temp.Pop();
+        Search(results, temp, candidates, remaining, index + 1);
+    }
+
+    private string Serialize(IList<IList<int>> results)
+    {
+        return JsonConvert.SerializeObject(results.OrderBy(item => JsonConvert.SerializeObject(item)).Select(item => item));
+    }
+}

40.CombinationSumII.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class Solution
+{
+    public IList<IList<int>> CombinationSum2(int[] candidates, int target)
+    {
+        var dict = new SortedDictionary<int, int>(candidates.GroupBy(c => c).ToDictionary(g => g.Key, g => g.Count()));
+        var paths = new List<Tuple<int, int>>[target + 1];
+        paths[0] = new List<Tuple<int, int>>();
+        foreach (var pair in dict)
+        {
+            for (var j = target; j >= 0; --j)
+            {
+                for (var k = 1; k <= pair.Value && j - pair.Key * k >= 0; ++k)
+                {
+                    if (paths[j - pair.Key * k] != null)
+                    {
+                        if (paths[j] == null)
+                        {
+                            paths[j] = new List<Tuple<int, int>>();
+                        }
+                        paths[j].Add(Tuple.Create(pair.Key, k));
+                    }
+                }
+            }
+        }
+
+        var results = new List<IList<int>>();
+        if (paths[target] != null) GenerateResults(results, new Stack<int>(), paths, target, paths[target].Count - 1);
+        return results;
+    }
+
+    private void GenerateResults(IList<IList<int>> results, Stack<int> result, List<Tuple<int, int>>[] paths, int remaining,
+        int maxIndex)
+    {
+        if (remaining == 0)
+        {
+            results.Add(new List<int>(result));
+            return;
+        }
+        for (var i = maxIndex; i >= 0; --i)
+        {
+            var path = paths[remaining][i];
+            for (var j = 0; j < path.Item2; ++j)
+            {
+                result.Push(path.Item1);
+            }
+            var nextMaxIndex = paths[remaining - path.Item1 * path.Item2].BinarySearch(Tuple.Create(path.Item1, int.MinValue), Comparer.Instance);
+            nextMaxIndex = ~nextMaxIndex - 1;
+            GenerateResults(results, result, paths, remaining - path.Item1 * path.Item2, nextMaxIndex);
+            for (var j = 0; j < path.Item2; ++j)
+            {
+                result.Pop();
+            }
+        }
+    }
+}
+
+class Comparer : IComparer<Tuple<int, int>>
+{
+    public int Compare(Tuple<int, int> x, Tuple<int, int> y)
+    {
+        if (x.Item1 < y.Item1) return -1;
+        if (x.Item1 > y.Item1) return 1;
+        return x.Item2.CompareTo(y.Item2);
+    }
+
+    public static Comparer Instance = new Comparer();
+}