LeetCode解题报告—— 4Sum & Remove Nth Node From End of List & Generate Parentheses

1. 4Sum

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note: The solution set must not contain duplicate quadruplets.

For example, given array S = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

思路：将4sum分解为3sum问题即可，其实按照这个思路可以解决k-Sum问题的。

List<List<Integer>> kSum_Trim(int[] a, int target, int k) {
    List<List<Integer>> result = new ArrayList<>();
    if (a == null || a.length < k || k < 2) return result;
    Arrays.sort(a);
    kSum_Trim(a, target, k, 0, result, new ArrayList<>());
    return result;
}

// 这里的path缓存的是迭代到 k=2 之前的候选数字
void kSum_Trim(int[] a, int target, int k, int start, List<List<Integer>> result, List<Integer> path) {
    int max = a[a.length - 1];
    if (a[start] * k > target || max * k < target) return;

    if (k == 2) {                        // 2 Sum
        int left = start;
        int right = a.length - 1;
        while (left < right) {
            if      (a[left] + a[right] < target) left++;
            else if (a[left] + a[right] > target) right--;
            else {
　　　　　　　　// ArrayList(Collection<? extends E> c)，构造一个包含指定 collection 的元素的列表
                result.add(new ArrayList<>(path));
                result.get(result.size() - 1).addAll(Arrays.asList(a[left], a[right]));
                left++;
                right--;
                while (left < right && a[left] == a[left - 1]) left++;    //去重
                while (left < right && a[right] == a[right + 1]) right--;   //去重
            }
        }
    } else {                      // k Sum
        for (int i = start; i < a.length - k + 1; i++) {
            if (i > start && a[i] == a[i - 1]) continue;　　//注意这里的去重逻辑，只计算重复数字中的第一个数字，这样既不会遗漏也不会计算重复
            if (a[i] + max * (k - 1) < target) continue;
            if (a[i] * k > target) break;
            if (a[i] * k == target) {　　//如果是这种情况则不需要继续向下迭代
                if (a[i + k - 1] == a[i]) {
                    result.add(new ArrayList<>(path));
                    List<Integer> temp = new ArrayList<>();
                    for (int x = 0; x < k; x++) temp.add(a[i]);
                    result.get(result.size() - 1).addAll(temp);    // Add result immediately.
                }
                break;
            }
            path.add(a[i]);
            kSum_Trim(a, target - a[i], k - 1, i + 1, result, path);
            path.remove(path.size() - 1);        // 回溯，以k=4为例，固定住a1,a2去后面找完所有可能的kusm=2的情况，再移出a2,固定a1,a3，以此类推。
        }
    }
}

这里难理解的是 result.add(new ArrayList<>(path)); 这段，因为path是缓存向下迭代到k=2之前的数字，所以再正式往result里加数字组的时候还要加上k=2时找到的那两个数字，所以要用一个新的List集合。

第二次来看这题时发现理解不了其中的去重逻辑，再次感叹一下算法真的是好难。计算既不能包含重复，也不能遗漏由相同数字构成的解，所以去重逻辑是这样的，首先对数组排序，这样重复的数字就挨在一起了，只计算这其中的第一个数字，比如 2，2，2........，先固定住第一个数字2，计算它后面和构成-2的数字对(注意这时的计算要考虑第一个2后面的那些重复的2)，那么可以得到的一个结论是，所有包含数字2的解(一个或多个的情况)都被找到了。这样下次寻找解的时候直接跳过后面重复的2即可，因为对于第一个2的计算已经找到了所以含有2的解，而且是包括了一个或多个的情形，所以之后的解肯定是不包含数字2的，否则肯定重复。

2. Remove Nth Node From End of List

Given a linked list, remove the nth node from the end of list and return its head.

For example,

   Given linked list: 1->2->3->4->5, and n = 2.

   After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:
Given n will always be valid.
Try to do this in one pass.

思路：对于链表，要注意头结点的作用。自己试了写下代码，如果不加一个指向链表中第一个节点的空节点，情况会变得较难考虑。这题可以先遍历求链表全长，再减去n。也可以用两个指针first和second，让first先向后移动距离second n个距离后，first和second再一起向后移动直至first指向null为止。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode first = dummy;
    ListNode second = dummy;
    // Advances first pointer so that the gap between first and second is n nodes apart
    for (int i = 1; i <= n + 1; i++) {
        first = first.next;
    }
    // Move first to the end, maintaining the gap
    while (first != null) {
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return dummy.next;
}

3. Generate Parentheses    

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

思路：可以使用穷举的方法，遍历所有可能的组合，对每一组判断是否是合法的括号对。这里难点在于如何遍历所有组合以及如何判断是否合法：

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> combinations = new ArrayList();
        generateAll(new char[2 * n], 0, combinations);
        return combinations;
    }

 // 利用递归的方法求所有组合
    public void generateAll(char[] current, int pos, List<String> result) {
        if (pos == current.length) {
            if (valid(current))
                result.add(new String(current));
        } else {
            current[pos] = '(';
            generateAll(current, pos+1, result);
            current[pos] = ')';
            generateAll(current, pos+1, result);
        }
    }

　// 这里判断括号对是否合法，学到了
    public boolean valid(char[] current) {
        int balance = 0;
        for (char c: current) {
            if (c == '(') balance++;
            else balance--;
            if (balance < 0) return false;
        }
        return (balance == 0);
    }
}

解法2是对1的改进，不需要遍历所有再一个个判断。

Instead of adding '(' or ')' every time as in Approach #1, let's only add them when we know it will remain a valid sequence. We can do this by keeping track of the number of opening and closing brackets we have placed so far.

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList();
        backtrack(ans, "", 0, 0, n);
        return ans;
    }

    public void backtrack(List<String> ans, String cur, int open, int close, int max){
        if (str.length() == max * 2) {
            ans.add(cur);
            return;
        }

        if (open < max)
            backtrack(ans, cur+"(", open+1, close, max);
        if (close < open)
            backtrack(ans, cur+")", open, close+1, max);
    }
}

这个算法我还是花了较长时间来理解的，特别是哪个回溯方法backtrack。如果 str 的长度达到了2n，因为再整个添加括号的过程中都是保证合法的，故可以直接加到List集合中。关键就是为什么能保证每步合法的添加括号。每一步的选择：1.如果当前字符串中 ( 的数量是少于n的，那么下个添加的字符可以是 ( ；2. 如果当前的 ) 符号数小于 (，那么下一个添加的字符可以是 )。 无论选择的是1还是2，它们之后的部分都是相同的递归方法来处理，更改相关参数再直接调用backtrack来处理后面的部分即可。因为要求所有的情况，所以选择1和2都要走一次才能遍历到所有合法的括号对。