Leetcode（524最长子序列、142链表环入口）

Leetcode 524

题目描述：给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。如果答案不存在，则返回空字符串。

示例 :

输入:
s = "abpcplea", d = ["a","b","c"]

输出: 
"a"

思路：

问题求解最长子序列。与KMP字符串匹配所解问题不同，此题未要求匹配的字串连续。使用双指针思想，一个指针用以遍历母串，一个指针用以遍历子串。因未要求连续，则在遍历过程中，如若两串指针所指当前字符相同时，成功匹配一个字符，两个指针都后移一位继续遍历；如若不同，则当前字符匹配失败，子串指针不变，母串指针后移，判断下一位字符。重复此过程。

此过程结束时，如果子串的指针仍指在子串的某一字符，则从该字符开始匹配失败；如果子串的指针移动到子串末尾的后一位，则说明所有字符匹配成功。

实现代码如下：

public class Lc524 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("ale", "apple", "monkey", "plea");
        String s = findLongestWord("abpcplea", list);
        System.out.println(s);
    }

    public static String findLongestWord(String s, List<String> d) {
        if (s == null || s.length() == 0) return "";
        if (d == null || d.size() == 0) return "";
        String result = "";

        for (String str : d) {
            if (str.length() < result.length() || (str.length() == result.length()) && (result.compareTo(str) < 0))
                continue;
            int i = 0, j = 0;
            while (i < s.length() && j < str.length()) {
                if (s.charAt(i) == str.charAt(j)) {
                    i++;
                    j++;
                } else i++;
            }
            if (j == str.length()) result = str;
        }
        return result;
    }
}

其中，compareTo函数按字典顺序比较两字符串。如果字典顺序比anotherString小，则返回一个负整数。如果字典顺序比anotherString大，则返回一个正整数。如果这两个字符串相等，则返回0。

public int compareTo(String anotherString)

---

Leetcode 142

题目描述：给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

思路：

双指针思想。是Leetcode141题的进化版，要求在判断是否可以形成环的基础上，寻找到环的入口点。

这道题的解法学习Leetcode中用户Krahets提供解法，解法来自：

作者：Krahets
链接：https://leetcode-cn.com/problems/linked-list-cycle-ii/solution/linked-list-cycle-ii-kuai-man-zhi-zhen-shuang-zhi-/
来源：力扣（LeetCode）

双指针第一次相遇： 设两指针 fast，slow 指向链表头部 head，fast 每轮走 2 步，slow 每轮走 1 步；

• 第一种结果： fast 指针走过链表末端，说明链表无环，直接返回 null；（若有环，两指针一定会相遇。因为每走 1 轮，fast 与 slow 的间距 +1，fast 终会追上 slow）

• 第二种结果： 当fast == slow时， 两指针在环中第一次相遇 。下面分析此时fast 与 slow走过的步数关系

  1.设链表共有a+b个节点，其中链表头部到链表入口有a个节点（不计链表入口节点）， 链表环有 b 个节点（这里需要注意，a 和 b 是未知数）；设两指针分别走了 f，s 步，则有：

  • fast 走的步数是 slow 步数的 2 倍，即 f = 2s；（解析： fast 每轮走 2 步）
  • fast 比 slow 多走了 n 个环的长度，即 f = s + nb；（ 解析： 双指针都走过 a 步，然后在环内绕圈直到重合，重合时 fast 比 slow多走环的长度整数倍 ）；
  • 以上两式相减得：f = 2nb，s = nb，即 fast 和slow 指针分别走了 2n，n 个环的周长 （注意： n 是未知数，不同链表的情况不同）。

目前情况分析：

• 如果让指针从链表头部一直向前走并统计步数k，那么所有走到链表入口节点时的步数是：k=a+nb（先走 a 步到入口节点，之后每绕 1 圈环（ b 步）都会再次到入口节点）。
• 而目前，slow 指针走过的步数为 nb 步。因此，我们只要想办法让 slow 再走 a 步停下来，就可以到环的入口。
• 但是我们不知道 a 的值，该怎么办？依然是使用双指针法。我们构建一个指针，此指针需要有以下性质：此指针和 slow 一起向前走 a 步后，两者在入口节点重合。那么从哪里走到入口节点需要 a 步？答案是链表头部head。

双指针第二次相遇：

• slow 指针位置不变 ，将 fast 指针重新指向链表头部节点 ；slow 和 fast 同时每轮向前走 1 步；（此时 f = 0，s = nb ）
• 当 fast 指针走到f = a 步时，slow 指针走到步s = a+nb，此时两指针重合，并同时指向链表环入口 。
• 返回slow指针指向的节点。

实现代码如下：

class Lc142 {
    public static void main(String[] args) {
        ListNode node1 = new ListNode(3);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(0);
        ListNode node4 = new ListNode(-4);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node2;
        System.out.println(hasCycle(node1));
    }

    public static ListNode hasCycle(ListNode head) {

        if (head == null) return null;
        ListNode p = head;
        ListNode q = head;
        while (q != null && (q.next) != null) {
            p = p.next;
            q = q.next.next;
            if (p == q) {
                q = head;
                while (p != q) {
                    p = p.next;
                    q = q.next;
                }
                return q;
            }
        }
        return null;
    }
}

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}