[Function add]

17. Letter Combinations of a Phone Number
18. 4Sum
19. Remove Nth Node From End of List

Author: Seanforfun

…rithm(4th_Edition)/leetcode/1.Two Sum.md leetcode/1.Two Sum.mdAlgorithm(4th_Edition)/leetcode/1.Two Sum.md renamed to leetcode/1.Two Sum.md Algorithm(4th_Edition)/leetcode/1.Two Sum.md renamed to leetcode/1.Two Sum.md

@@ -1,4 +1,4 @@
-## 1.Two Sum
+## 15. 3Sum
 ### Thinking:
 * Method1: Two pointer
 iterate the array in order, use left and right pointers to represent the index of the other two numbers.

…dition)/leetcode/12. Integer to Roman.md leetcode/12. Integer to Roman.mdAlgorithm(4th_Edition)/leetcode/12. Integer to Roman.md renamed to leetcode/12. Integer to Roman.md Algorithm(4th_Edition)/leetcode/12. Integer to Roman.md renamed to leetcode/12. Integer to Roman.md

@@ -0,0 +1,61 @@
+## 3Sum Closest
+### Thinking:
+* Method1: Similar to 3Sum Runtime: 30 ms
+```Java
+	class Solution {
+	    public int threeSumClosest(int[] nums, int target) {
+	        int len = nums.length;
+	        int d = Integer.MAX_VALUE;
+	        Arrays.sort(nums);
+	        for(int i = 0; i < len-2; i++){
+	            if(i > 0 && nums[i-1] == nums[i]) continue;
+	            int left = i+1; int right=len-1;
+	            int tempTarget = target - nums[i];
+	            while(left < right){
+	                if(nums[left] + nums[right] == tempTarget) return target;
+	                else if(nums[left] + nums[right] < tempTarget){
+	                    if(Math.abs(target - nums[i] - nums[left] - nums[right]) < Math.abs(d))
+	                        d = target-nums[i] - nums[left] - nums[right];
+	                    left++;
+	                } 
+	                else{
+	                    if(Math.abs(target - nums[i] - nums[left] - nums[right]) < Math.abs(d))
+	                        d = target-nums[i] - nums[left] - nums[right];
+	                    right--;
+	                }
+	            }
+	        }
+	        return target - d;
+	    }
+	}
+```
+
+# Optimization Runtime: 22 ms
+```Java
+	class Solution {
+	    public int threeSumClosest(int[] nums, int target) {
+	        int len = nums.length;
+	        int d = Integer.MAX_VALUE;
+	        Arrays.sort(nums);
+	        for(int i = 0; i < len-2; i++){
+	            if(i > 0 && nums[i-1] == nums[i]) continue;
+	            int left = i+1; int right=len-1;            
+	            while(left < right){
+	                int t = target - nums[i] - nums[left] - nums[right];
+	                if(t == 0) return target;
+	                else if(t > 0){
+	                    if(Math.abs(t) < Math.abs(d))
+	                        d = t;
+	                    left++;
+	                } 
+	                else{
+	                    if(Math.abs(t) < Math.abs(d))
+	                        d = t;
+	                    right--;
+	                }
+	            }
+	        }
+	        return target - d;
+	    }
+	}
+```

…dition)/leetcode/13. Roman to Integer.md leetcode/13. Roman to Integer.mdAlgorithm(4th_Edition)/leetcode/13. Roman to Integer.md renamed to leetcode/13. Roman to Integer.md Algorithm(4th_Edition)/leetcode/13. Roman to Integer.md renamed to leetcode/13. Roman to Integer.md

@@ -0,0 +1,36 @@
+## 18. 4Sum
+### Thinking:
+* Method: 
+It is very similar to 3sum, but we use one more index to iterate.
+It is very important to remove duplicate elements.
+```Java
+	class Solution {
+	    public List<List<Integer>> fourSum(int[] nums, int target) {
+	        List<List<Integer>> result = new ArrayList<List<Integer>>();
+	        if(nums == null || nums.length < 4) return result;
+	        Arrays.sort(nums);
+	        int len = nums.length;
+	        for(int i = 0; i < len - 3; i++){
+	            for(int j = i+1; j < len - 2; j++){
+	                int left = j + 1; int right = len - 1;
+	                while(left < right){
+	                    int temp = nums[i] + nums[j] + nums[left] + nums[right];
+	                    if(temp == target){
+	                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
+	                        left++;right--;
+	                        while(left < right && nums[left-1] == nums[left])   left++;
+	                        while(left < right && nums[right+1] == nums[right]) right--;
+	                    }else if(temp < target){
+	                        left++;   
+	                    }else{
+	                        right--;
+	                    }
+	                }
+	                while(j < len - 2 && nums[j + 1] == nums[j])  j++;//Remove duplicate.
+	            }
+	            while(i < len-3 && nums[i + 1] == nums[i])   i++;//Remove duplicate.
+	        }
+	        return result;
+	    }
+	}
+```

…tion)/leetcode/14.LongestCommonPrefix.md leetcode/14.LongestCommonPrefix.mdAlgorithm(4th_Edition)/leetcode/14.LongestCommonPrefix.md renamed to leetcode/14.LongestCommonPrefix.md Algorithm(4th_Edition)/leetcode/14.LongestCommonPrefix.md renamed to leetcode/14.LongestCommonPrefix.md

@@ -0,0 +1,41 @@
+## 19. Remove Nth Node From End of List
+### Thinking:
+* Method: 
+1. Iterate to get the length of the list.
+2. Iterate again to remove
+3. Trick: Use a dummy node to represent the head.
+```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+	    public ListNode removeNthFromEnd(ListNode head, int n) {
+	        ListNode result = new ListNode(0);
+	        result.next = head;
+	        int len = 0;
+	        ListNode temp = result;
+	        while(temp.next != null){
+	            temp = temp.next;
+	            len ++;
+	        }
+	        if (len < n) return null;
+	        int index = len + 1 - n;
+	        len = 0;
+	        temp = result;
+	        while(temp.next != null){
+	            len ++;
+	            if(len == index){
+	                temp.next = temp.next.next;//Remove
+	                return result.next;
+	            }
+	            temp = temp.next;
+	        }
+	        return result.next;
+	    }
+	}
+```