第二章：双指针

1、两数之和 II - 输入有序数组

问题：给定一个已按照 非递减顺序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。 

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]

package LeetCode.test2_shuangzhizheng;

import java.util.Arrays;

public class ques_167_两数之和II_输入有序数组 {
    public static void main(String[] args) {
        int[] numbers = {2, 7, 11, 15};
//        int[] numbers = {2, 3, 4};
        int target = 9;
//        int target = 6;
        System.out.println(Arrays.toString(twoSum(numbers, target)));
    }

    public static int[] twoSum(int[] numbers, int target) {
        int left = 0;
        int right = numbers.length - 1;
        while (left < right) {
            if (numbers[left] + numbers[right] > target) {
                right--;
            } else if (numbers[left] + numbers[right] < target) {
                left++;
            } else {
                break;
            }
        }
        return new int[]{left + 1, right + 1};
    }
}

2、合并两个有序数组

问题：给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

package LeetCode.test2_shuangzhizheng;

import java.util.Arrays;

/**
 * 两种情况：m>=0,n>=0  n>=0
 * （第一种运行过程中也可能会变为第二种情况）
 */
public class ques_88_合并两个有序数组 {
    public static void main(String[] args) {
//        int[] nums1 = {1, 2, 3, 0, 0, 0};
//        int m = 3;
//        int[] nums2 = {2, 5, 6};
//        int n = 3;

//        int[] nums1 = {1};
//        int m = 1;
//        int[] nums2 = {};
//        int n = 0;

//        int[] nums1 = {0};
//        int m = 0;
//        int[] nums2 = {1};
//        int n = 1;

        int[] nums1 = {2, 0};
        int m = 1;
        int[] nums2 = {1};
        int n = 1;
        merge(nums1, m, nums2, n);
    }

    public static void merge(int[] nums1, int m, int[] nums2, int n) {
        int pos = m-- + n-- - 1;  // 当前pos = m + n - 1
        while (m >= 0 && n >= 0) {  // 当前m = m-1, n = n-1 (第一种情况)
            nums1[pos--] = nums2[n] > nums1[m] ? nums2[n--] : nums1[m--];
        }
        while (n >= 0) {  // (第二种情况)
            nums1[pos--] = nums2[n--];
        }
        System.out.println(Arrays.toString(nums1));
    }
}

3、环形链表II

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。

如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

package LeetCode.test2_shuangzhizheng;

public class ques_142_环形链表II {
    public static class ListNode {
        int value;
        ListNode next;

        ListNode(){

        }

        ListNode(int value) {
            this.value = value;
        }
    }

    public static void main(String[] args) {

    }

    public static ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {  //至少有两个节点
            fast = fast.next.next;
            slow = slow.next;
            //是带环链表
            if (fast == slow) {
                break;
            }
        }
        //不是带环链表(fast==slow==null或者只有一个head节点)
        if (fast == null || fast.next == null) {
            return null;
        }
        fast = head;
        while (fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}

4、最小覆盖子串

问题：给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
示例 2：

输入：s = "a", t = "a"
输出："a"
示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

思路：

/**
 * 思路：以s = "KADOBECODEBANC";t = "ABC"为例。
 *  flag[K]=0 -> flag[K]=-1  count = 3
 *  flag[A]=1 -> flag[A]=0   count = 2
 *              ...... D,O,E=-1
 *  flag[C]=1 -> flag[C]=0   count = 0  此时，left=0,right=6
 *
 *  ans = KADOBEC
 *  flag[K]=-1 -> flag[K]=0  count=0  left = 1
 *  ans = ADOBEC  min = 6
 *
 *  flag[A]=0 -> flag[A]=1  count=1  left = 2
 *  退出while(count==0)循环，此时right=7   字母O位置
 *  flag[O]=-1 -> flag[O]=-2  count = 1
 *              ......  D,E,B = -2,-2,-1
 *  flag[A]=1 -> flag[A]=0   count = 0   此时，left=2,right=11
 *
 *  ans = DOBECODEBA  >  6 ,所以 ans = ADOBEC
 *  flag[D]=-2 -> flag[D]=-1  count=0  left = 3
 *  flag[O]=-2 -> flag[O]=-1  count=0  left = 4
 *  flag[B]=-1 -> flag[B]=0  count=0  left = 5
 *  flag[E]=-2 -> flag[E]=-1  count=0  left = 6
 *  ans = CODEBA = 6 ,所以 ans = ADOBEC    CODEBA
 *
 *  flag[C]=0 -> flag[C]=1  count=1  left = 7
 *  退出while(count==0)循环，此时right=12   字母N位置
 *              ......
 *  ans = BANC
 *
 *  ans变化过程：KADOBEC->ADOBEC->DOBECODEBA->CODEBA->ODEBANC->BANC(ans中最小的)
 */

package LeetCode.test2_shuangzhizheng;

public class ques_76_最小覆盖子串 {
    public static void main(String[] args) {
        String s = "KADOBECODEBANC";
        String t = "ABC";
        System.out.println(minWindow(s, t));
    }

    public static String minWindow(String s, String t) {
        int[] flag = new int[128];
        //记录t字符串每个字符出现的次数
        for (int i = 0; i < t.length(); i++) {
            flag[t.charAt(i)]++;
        }

        int left = 0;  // 窗口左边界
        int right = 0; // 窗口右边界
        int count = t.length(); // 需要指定元素的个数
        int min = Integer.MAX_VALUE; // 最下窗口大小
        String ans = ""; // 记录结果

        while (right < s.length()) {
            char ch = s.charAt(right);
            if (flag[ch] > 0) { //如果ch是需要的字符，count减一
                count--;
            }
            flag[ch]--; //如果ch是需要的字符flag[ch]--的值最小为0，如果ch不是需要的字符flag[ch]--的值为负数
            while (count == 0) {
                if (min > right - left + 1) { // 最优字符串
                    min = right - left + 1;
                    ans = s.substring(left, right + 1);
                }
                ch = s.charAt(left);
                if (flag[ch] == 0) { //flag[ch]==0说明这个ch是需要的字符，并且刚好包含一个，把它去除就不能完全覆盖t
                    count++;
                }
                flag[ch]++;  // 需要的ch数量加1
                left++;
            }
            right++;
        }
        return ans;
    }
}

5、平方数之和

问题：给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。

示例 1：

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5
示例 2：

输入：c = 3
输出：false
示例 3：

输入：c = 4
输出：true
示例 4：

输入：c = 2
输出：true
示例 5：

输入：c = 1
输出：true

package LeetCode.test2_shuangzhizheng;

/**
 * 双指针法
 * 如果生成数较大，则大值减小
 * 生成数较小，则小值变大
 */
public class ques_633_平方数之和 {
    public static void main(String[] args) {
        int c = 2147483600;
        System.out.println(judgeSquareSum(c));
    }

    public static boolean judgeSquareSum(int c) {
        if (c < 0) {
            return false;
        }
        double left = 0;
        double right = Math.floor(Math.sqrt(c));
        while (left <= right) {
            double sum = left * left + right * right;
            if (sum > c) {
                right--;
            } else if (sum < c) {
                left++;
            } else {
                return true;
            }
        }
        return false;
    }
}

6、验证回文字符串Ⅱ

问题：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

示例 1:

输入: s = "aba"
输出: true
示例 2:

输入: s = "abca"
输出: true
解释: 你可以删除c字符。
示例 3:

输入: s = "abc"
输出: false

思路：在使用双指针遍历字符串时，如果出现两个指针指向的字符不相等的情况，试着删除一个字符，再判断删除完之后的字符串是否是回文字符串。

在判断是否为回文字符串时，不需要判断整个字符串，因为左指针左边和右指针右边的字符之前已经判断过具有对称性质，所以只需要判断中间的子字符串即可。

在试着删除字符时，既可以删除左指针指向的字符，也可以删除右指针指向的字符.(important)

package LeetCode.test2_shuangzhizheng;

public class ques_680_验证回文字符串Ⅱ {
    public static void main(String[] args) {
//        String s = "aba";
//        String s = "deeee";
        String s = "cupffpucu";
//        String s = "abddca";
//        String s = "cxccxcx";
        System.out.println(validPalindrome(s));
    }

    public static boolean validPalindrome(String s) {
        for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return isPalindrome(s, i + 1, j) || isPalindrome(s, i, j - 1);
            }
        }
        return true;
    }

    public static boolean isPalindrome(String s, int i, int j) {
        while (i < j) {
            if (s.charAt(i++) != s.charAt(j--)) {
                return false;
            }
        }
        return true;
    }
}

7、通过删除字母匹配到字典里最长单词

问题：给你一个字符串 s 和一个字符串数组 dictionary ，找出并返回 dictionary 中最长的字符串，该字符串可以通过删除 s 中的某些字符得到。

如果答案不止一个，返回长度最长且字母序最小的字符串。如果答案不存在，则返回空字符串。

示例 1：

输入：s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]
输出："apple"
示例 2：

输入：s = "abpcplea", dictionary = ["a","b","c"]
输出："a"

package LeetCode.test2_shuangzhizheng;

import java.util.*;

public class ques_524_通过删除字母匹配到字典里最长单词 {
    public static void main(String[] args) {
        String s = "abpcplea";
        List<String> dictionary = new ArrayList<>();
        dictionary.add("ale");
        dictionary.add("apple");
        dictionary.add("monkey");
        dictionary.add("plea");
        System.out.println(findLongestWord(s, dictionary));

    }

    public static String findLongestWord(String s, List<String> dictionary) {
        String res = "";
        for (String str : dictionary) {
            // 如果结果字符串比当前遍历的字符串更长，那就可以直接跳过
            // 如果两个字符串长度相等，那就比较一下字典顺序，如果当前遍历的字符串更小，就跳过
            if (res.length() > str.length() || (res.length() == str.length() && res.compareTo(str) < 0)) {
                continue;
            }
            // 如果是子序列，就覆盖结果字符串
            if (isSubStr(s, str)) {
                res = str;
            }
        }
        return res;
    }

    public static boolean isSubStr(String s, String str) { // 判断是否是子序列
        int i = 0;
        int j = 0;
        while (i < s.length() && j < str.length()) {
            if (s.charAt(i) == str.charAt(j)) {
                j++;
            }
            i++;
        }
        return j == str.length();
    }
}

8、至多包含K个不同字符的最长子串

问题：给定一个字符串s ，找出至多包含k个不同字符的最长子串T。

示例 1:

输入: s = "eceba", k = 2

输出: 3

解释: 则 T 为 "ece"，所以长度为 3。

示例 2:

输入: s = "aa", k = 1

输出: 2

解释: 则 T 为 "aa"，所以长度为 2。

思路：双指针，指针中间的是可能的答案。符合要求右指针向右扩，否则更新答案，左指针往右缩。

package LeetCode.test2_shuangzhizheng;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * eg:  s = "ecebeea"   k = 2
 * e->0  left=0  right=1  max=(0,1-0)=1
 * e->0 c->1  left=0 right=2  max=(1,2-0)=2
 * e->2 c->1  left=0 right=3  max=(2,3-0)=3
 * e->2 c->1 b->3  (e->2 b->3)  left=2  right=4  max=(3,4-2)=3
 * e->4 b->3  left=2  right=5   max=(3,5-2)=3
 * e->5 b->3  left=2  right=6   max=(3,6-2)=4
 * e->5 b->3 a->6 (e->5 a->6)  left=4  right=7  max=(4,7-24)=4
 */

public class ques_340_至多包含K个不同字符的最长子串 {
    public static void main(String[] args) {
        String s = "eceba";
        int k = 2;
        System.out.println(lengthOfLongestSubstringKDistinct(s, k));
    }

    public static int lengthOfLongestSubstringKDistinct(String s, int k) {
        if (s.length() == k) {
            return s.length();
        }
        int left = 0;
        int right = 0;
        Map<Character, Integer> map = new HashMap<>();
        int max = 0;
        while (right < s.length()) {
            if (map.size() <= k) {
                map.put(s.charAt(right), right);
                right++;
            }
            if (map.size() == k + 1) {
                int index = Collections.min(map.values());
                map.remove(s.charAt(index));
                left = index + 1;
            }
            max = Math.max(max, right - left);
        }
        return max;
    }
}