1-5两数之和/两数相加/无重复字符的最长子串/寻找两个正序数组的中位数(未完成)/最长回文子串

1.两数之和

• 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

public int[] twoSum(int[] nums, int target) {
    Map<Integer,Integer> map=new HashMap<>();
    for(int i=0;i<nums.length;i++){
        int sub=target-nums[i];
        if(map.containsKey(sub)){
            return new int[]{i,map.get(sub)};
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

2.两数相加

• 初始化一个节点的头dummy，但是这个头不存储数字。并且将 cur 指向它。
• 遍历链表，注意带进位的更新

public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(0);
    ListNode cur = dummy;
    int carry = 0;
    int sum = 0;
    while (l1 != null || l2 != null) {
        int val1 = l1 == null ? 0 : l1.val;
        int val2 = l2 == null ? 0 : l2.val;
        sum = val1 + val2 + carry;
        carry = sum / 10;
        cur.next = new ListNode(sum % 10);
        cur = cur.next;
        if (l1 != null) {
            l1 = l1.next;
        }
        if (l2 != null) {
            l2 = l2.next;
        }
    }
    if (carry == 1) {
        cur.next = new ListNode(carry);
    }
    return dummy.next;
}

3. 无重复字符的最长子串

• 用map存（值，引索）
• left=Math.max(left,map.get(s.charAt(i))+1); 这一句考虑abba 遍历到第二个a的这种情况

public int lengthOfLongestSubstring(String s) {
    if(s==null||s.length()==0) return 0;
    HashMap<Character,Integer> map=new HashMap<>();
    int res=0;
    int left=0;
    for(int i=0;i<s.length();i++){
        if(map.containsKey(s.charAt(i))){
            //由于采取了 i 跳跃的形式，所以 map 之前存的字符没有进行 remove ，
            left=Math.max(left,map.get(s.charAt(i))+1);
        }
        map.put(s.charAt(i),i);
        res=Math.max(res,i-left+1);
    }
    return res;
}

4. 寻找两个正序数组的中位数（困难）

5. 最长回文子串

动态规划

• 申请一个二维boolean数组，若s的第i个字符等于第j个字符，那么dp[i][j]=true，由里到外推回文子串，这里就是子问题
• 我们取两个指针left和right来标记回文串的左右边界index
• 转移方程：
  • 情况1：s.charAt(left)==s.charAt(right)并且dp[left+1][right-1]，有dp[left][right]=true
  • 情况2：s.charAt(left)==s.charAt(right)并且right-left<=2，也有有dp[left][right]=true
• 我们还需要一个变量去不断更新长度
• 时间空间复杂度都是平方级别

public String longestPalindrome(String s) {
    if(s==null||s.length()<2) return s;
    int strLen=s.length();
    int maxLen=1;
    int maxStart=0;
    int maxEnd=0;
    boolean[][] dp=new boolean[strLen][strLen];
    for(int right=1;right<strLen;right++){
        for(int left=0;left<right;left++){
            //空间换时间，记录子串left-right是否是回文，再判断两边
            if(s.charAt(left)==s.charAt(right)&&(dp[left+1][right-1]||right-left<=2)){
                dp[left][right]=true;
                if(right-left+1>maxLen){
                    maxLen=right-left+1;
                    maxStart=left;
                    maxEnd=right;
                }
            }
        }
    }
    return s.substring(maxStart,maxEnd+1);
}

中心扩散

• 可以每次循环选择一个中心，进行左右扩展，判断左右字符是否相等即可。由于存在奇数的字符串和偶数的字符串，所以需要从一个字符开始扩展，或者从两个字符之间开始扩展，所以总共有 n + (n - 1) 个中心位置
• 时间复杂度平方级别，空间常数级别

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expand(s, i, i);
        int len2 = expand(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}
private int expand(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}

Manacher马拉车算法

马拉车算法 Manacher‘s Algorithm 是用来查找一个字符串的最长回文子串的线性方法，由一个叫Manacher的人在1975年发明的，这个方法的最大贡献是在于将时间复杂度提升到了线性。