Update code due to update of test cases and interfaces

Author: kfstorm

1.TwoSum.cs

@@ -8,7 +8,7 @@ public int[] TwoSum(int[] nums, int target) {
             int index;
             if (dict.TryGetValue(target - nums[i], out index))
             {
-                return new [] { index + 1, i + 1};
+                return new [] { index, i};
             }
             if (!dict.ContainsKey(nums[i]))
             {

127.WordLadder.cs

@@ -3,65 +3,66 @@
 using System.Linq;
 
 public class Solution {
-    public int LadderLength(string beginWord, string endWord, ISet<string> wordDict) {
-		if (beginWord == endWord) return 1;
-		wordDict.Remove(beginWord);
-		wordDict.Remove(endWord);
-		var words = new [] { beginWord, endWord }.Concat(wordDict.Where(word => word.Length == beginWord.Length)).Select((word, i) => new { Word = word, Index = i }).ToList();
-		
-		var paths = new List<int>[words.Count];
-		for (var i = 0; i < paths.Length; ++i)
-		{
-			paths[i] = new List<int>();
-		}
-		for (var i = 0; i < beginWord.Length; ++i)
-		{
+    public int LadderLength(string beginWord, string endWord, IList<string> wordList) {
+        var words = Enumerable.Repeat(beginWord, 1).Concat(wordList).Select((word, i) => new { Word = word, Index = i }).ToList();
+        var endWordIndex = words.Find(w => w.Word == endWord)?.Index;
+        if (endWordIndex == null) {
+            return 0;
+        }
+
+        var paths = new List<int>[words.Count];
+        for (var i = 0; i < paths.Length; ++i)
+        {
+            paths[i] = new List<int>();
+        }
+        for (var i = 0; i < beginWord.Length; ++i)
+        {
             var hashMap = new Hashtable();
             foreach (var item in words)
             {
                 var newWord = string.Format("{0}_{1}", item.Word.Substring(0, i), item.Word.Substring(i + 1));
-				List<int> similars;
+                List<int> similars;
                 if (!hashMap.ContainsKey(newWord))
-				{
-					similars = new List<int>();
-					hashMap.Add(newWord, similars);
-				}
-				else
-				{
-					similars = (List<int>)hashMap[newWord];
-				}
-				foreach (var similar in similars)
-				{
-					paths[similar].Add(item.Index);
-					paths[item.Index].Add(similar);
-				}
+                {
+                    similars = new List<int>();
+                    hashMap.Add(newWord, similars);
+                }
+                else
+                {
+                    similars = (List<int>)hashMap[newWord];
+                }
+                foreach (var similar in similars)
+                {
+                    paths[similar].Add(item.Index);
+                    paths[item.Index].Add(similar);
+                }
                 similars.Add(item.Index);
             }
-		}
-		
-		var left = words.Count - 1;
-		var lastRound = new List<int> { 0 };
-		var visited = new bool[words.Count];
-		visited[0] = true;
-		for (var result = 2; left > 0; ++result)
-		{
-			var thisRound = new List<int>();
-			foreach (var index in lastRound)
-			{
-				foreach (var next in paths[index])
-				{
-					if (!visited[next])
-					{
-						visited[next] = true;
-						if (next == 1) return result;
-						thisRound.Add(next);
-					}
-				}
-			}
+        }
+
+        var left = words.Count - 1;
+        var lastRound = new List<int> { 0 };
+        var visited = new bool[words.Count];
+        visited[0] = true;
+        for (var result = 2; left > 0; ++result)
+        {
+            var thisRound = new List<int>();
+            foreach (var index in lastRound)
+            {
+                foreach (var next in paths[index])
+                {
+                    if (!visited[next])
+                    {
+                        visited[next] = true;
+                        if (next == endWordIndex) return result;
+                        thisRound.Add(next);
+                    }
+                }
+            }
             if (thisRound.Count == 0) break;
-			lastRound = thisRound;
-		}
-		
-		return 0;
+            lastRound = thisRound;
+        }
+
+        return 0;
     }
 }

130.SurroundedRegions.cs

@@ -2,20 +2,20 @@
 using System.Collections.Generic;
 
 public class Solution {
-    private static readonly int[,] directions = new int[4, 2] { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 }}; 
-    public void Solve(char[,] board) {
-        var lenI = board.GetLength(0);
-        var lenJ = board.GetLength(1);
-        
+    private static readonly int[,] directions = new int[4, 2] { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 }};
+    public void Solve(char[][] board) {
+        var lenI = board.Length;
+        var lenJ = lenI == 0 ? 0 : board[0].Length;
+
         for (var i = 0; i < lenI; ++i)
         {
             for (var j = 0; j < lenJ; ++j)
             {
-                if (board[i, j] == 'O')
+                if (board[i][j] == 'O')
                 {
                     var marked = new List<Tuple<int, int>>();
                     marked.Add(Tuple.Create(i, j));
-                    board[i, j] = 'M';
+                    board[i][j] = 'M';
                     bool escaped = false;
                     for (var m = 0; m < marked.Count; ++m)
                     {
@@ -27,32 +27,32 @@ public void Solve(char[,] board) {
                             {
                                 escaped = true;
                             }
-                            else if (board[newI, newJ] == 'O')
+                            else if (board[newI][newJ] == 'O')
                             {
-                                board[newI, newJ] = 'M';
+                                board[newI][newJ] = 'M';
                                 marked.Add(Tuple.Create(newI, newJ));
                             }
                         }
                     }
-                    
+
                     if (!escaped)
                     {
                         foreach (var item in marked)
                         {
-                            board[item.Item1, item.Item2] = 'X';
+                            board[item.Item1][item.Item2] = 'X';
                         }
                     }
                 }
             }
         }
-        
+
         for (var i = 0; i < lenI; ++i)
         {
             for (var j = 0; j < lenJ; ++j)
             {
-                if (board[i, j] == 'M')
+                if (board[i][j] == 'M')
                 {
-                    board[i, j] = 'O';
+                    board[i][j] = 'O';
                 }
             }
         }

133.CloneGraph.cs

@@ -1,37 +1,34 @@
 using System.Collections.Generic;
 
 public class Solution {
-    public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) {
+    public Node CloneGraph(Node node) {
         if (node == null) return null;
-        var dict = new Dictionary<int, UndirectedGraphNode>();
-        var queue = new Queue<UndirectedGraphNode>();
-        queue.Enqueue(CloneLabel(node));
-        dict.Add(node.label, queue.Peek());
+        var dict = new Dictionary<int, Node>();
+        var queue = new Queue<Node>();
+        queue.Enqueue(CloneVal(node));
+        dict.Add(node.val, queue.Peek());
         while (queue.Count > 0)
         {
             var current = queue.Dequeue();
-            var newNeighbors = new List<UndirectedGraphNode>(current.neighbors.Count);
+            var newNeighbors = new List<Node>(current.neighbors.Count);
             foreach (var oldNeighbor in current.neighbors)
             {
-                UndirectedGraphNode newNeighbor;
-                if (!dict.TryGetValue(oldNeighbor.label, out newNeighbor))
+                Node newNeighbor;
+                if (!dict.TryGetValue(oldNeighbor.val, out newNeighbor))
                 {
-                    newNeighbor = CloneLabel(oldNeighbor);
+                    newNeighbor = CloneVal(oldNeighbor);
                     queue.Enqueue(newNeighbor);
-                    dict.Add(newNeighbor.label, newNeighbor);
+                    dict.Add(newNeighbor.val, newNeighbor);
                 }
                 newNeighbors.Add(newNeighbor);
             }
             current.neighbors = newNeighbors;
         }
-        return dict[node.label];
+        return dict[node.val];
     }
 
-    private UndirectedGraphNode CloneLabel(UndirectedGraphNode node)
+    private Node CloneVal(Node node)
     {
-        return new UndirectedGraphNode(node.label)
-        {
-            neighbors = new List<UndirectedGraphNode>(node.neighbors)
-        };
+        return new Node(node.val, new List<Node>(node.neighbors));
     }
 }

138.CopyListWithRandomPointer.cs

@@ -2,28 +2,30 @@
 using System.Collections.Generic;
 
 public class Solution {
-    public RandomListNode CopyRandomList(RandomListNode head) {
-        var dict = new Dictionary<int, Tuple<int?, int?>>();
+    public Node CopyRandomList(Node head) {
+        if (head == null) {
+            return null;
+        }
+
+        var map = new Dictionary<Node, Node>();
         var current = head;
-        while (current != null)
-        {
-            dict.Add(current.label, Tuple.Create(current.next == null ? (int?) null : current.next.label, current.random == null ? (int?) null : current.random.label));
+        while (current != null) {
+            var newCurrent = new Node(current.val);
+            map.Add(current, newCurrent);
             current = current.next;
         }
 
-        var dict2 = new Dictionary<int, RandomListNode>();
-        foreach (var label in dict.Keys)
-        {
-            dict2.Add(label, new RandomListNode(label));
-        }
-        foreach (var pair in dict)
-        {
-            var next = pair.Value.Item1;
-            if (next.HasValue) dict2[pair.Key].next = dict2[next.Value];
-            var random = pair.Value.Item2;
-            if (random.HasValue) dict2[pair.Key].random = dict2[random.Value];
+        foreach (var entry in map) {
+            var oldNode = entry.Key;
+            var newNode = entry.Value;
+            if (oldNode.next != null) {
+                newNode.next = map[oldNode.next];
+            }
+            if (oldNode.random != null) {
+                newNode.random = map[oldNode.random];
+            }
         }
 
-        return head == null ? null : dict2[head.label];
+        return map[head];
     }
 }

139.WordBreak.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 
 public class Solution {
-    public bool WordBreak(string s, ISet<string> wordDict) {
+    public bool WordBreak(string s, IList<string> wordDict) {
         var f = new bool[s.Length + 1];
         f[0] = true;
         var wordDictGroup = wordDict.GroupBy(word => word.Length);

140.WordBreakII.cs

@@ -10,7 +10,7 @@ class Node
 }
 
 public class Solution {
-    public IList<string> WordBreak(string s, ISet<string> wordDict) {
+    public IList<string> WordBreak(string s, IList<string> wordDict) {
         var paths = new List<Tuple<int, string>>[s.Length + 1];
         paths[s.Length] = new List<Tuple<int, string>> { Tuple.Create(-1, (string)null) };
         var wordDictGroup = wordDict.GroupBy(word => word.Length);
@@ -32,14 +32,14 @@ public IList<string> WordBreak(string s, ISet<string> wordDict) {
                 }
             }
         }
-        
+
         return GenerateResults(paths);
     }
-    
+
     private IList<string> GenerateResults(List<Tuple<int, string>>[] paths)
     {
         var results = new List<string>();
-        var sb = new StringBuilder(); 
+        var sb = new StringBuilder();
         var stack = new Stack<Node>();
         stack.Push(new Node());
         while (stack.Count > 0)

146.LRUCache.cs

@@ -34,7 +34,7 @@ public int Get(int key)
         return -1;
     }
 
-    public void Set(int key, int value)
+    public void Put(int key, int value)
     {
         Node node;
         if (keyMap.TryGetValue(key, out node))