华为OD刷题C卷 - 每日刷题 2

1、（无重复字符的最长子串）：

这段代码是解决“无重复字符的最长子串”问题。它提供了一个Java类Solution，其中包含一个方法lengthOfLongestSubstring，该方法接收一个字符串s，并返回该字符串中无重复字符的最长子串的长度。

代码中使用了一个HashMap<Character, Integer>来存储每个字符及其在字符串中最后出现的位置。同时定义了两个指针left和right，分别代表当前考虑的子串的左边界和右边界。随着right指针的移动，如果遇到重复字符，则将left指针移动到上一次该字符出现位置的右侧。通过这种方式，可以保证[left, right]范围内的子串没有重复字符。

在每次移动right指针时，更新最长子串的长度ans，即right - left。最终返回ans作为结果。

2、（最长回文子串）：

这段代码是解决“最长回文子串”问题。它提供了一个Java类Solution，其中包含一个方法longestPalindrome，该方法接收一个字符串s，并返回该字符串中最长的回文子串。

代码中使用了一个二维布尔数组dp来存储子串是否为回文串。dp[i][j]为true表示从索引i到j的子串是回文串。首先初始化了单个字符都是回文串，然后通过动态规划的方法，逐一检查更长的子串是否为回文。

在动态规划的过程中，如果两端的字符相等，并且剩余的子串（如果长度大于2）也是回文串，则当前子串也是回文串。同时，更新最大回文子串的长度maxLen和对应的起始索引start和结束索引end。

最后，根据start和end返回最长回文子串。

package Code3;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

/**
 * @description 无重复字符的最长子串
 * @level
 * @score
 * @url
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.println(new Solution().lengthOfLongestSubstring(s));

    }
}

class Solution {
    /**
     * 返回无重复字符的最长子串长度
     *
     * @param s
     * @return int
     */
    public int lengthOfLongestSubstring(String s) {
        //存放字符以及出现的下标
        HashMap<Character, Integer> map = new HashMap<>();
        //开始的左边界
        int left = -1;
        //题解
        int ans = 0;
        int len = s.length();
        for (int right = 0; right < len; right++) {
            //[left,right]中无重复字符
            if (map.containsKey(s.charAt(right))) {
                //更新左边界
                left = Math.max(left, map.get(s.charAt(right)));
            }
            //存放右边届
            map.put(s.charAt(right), right);
            //更新长度
            ans = Math.max(ans, right - left);
        }
        return ans;
    }
}

package Code5;

import java.util.Scanner;

/**
 * @description 最长回文子串
 * @level 中等
 * @score
 * @url https://leetcode.cn/problems/longest-palindromic-substring/description/
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);


    }
}

class Solution {
    public String longestPalindrome(String s) {
        //如果s为null或者长度为1，则返回自身
        if (s == null || s.length() == 1) {
            return s;
        }

        //dp[i][j]表示s[i....j]是否是回文子串，动态规划
        int n = s.length();
        boolean[][] dp = new boolean[n][n];

        //初始化所有单个字符都是回文串 后面l,r不会相等，当r-l<=2时且两端相等，就可以判定是回文串了
        //for (int i = 0; i < n; i++){
        //    dp[i][i] = true;
        //}

        //最大回文串的起点、终点
        int start = 0;
        int end = 0;
        int maxLen = 1;

        //动态规划 dp[i][j]是回文串必须dp[i+1][j-1]也是回文串且s[i]==s[j]
        for (int r = 1; r < n; r++) {
            for (int l = 0; l < r; l++) {
                //2个或者3个字符时，如果左右边界相等，则一定是回文即r-l<=2 大于3个字符则需要用dp[l+1][r-1]
                if (s.charAt(l) == s.charAt(r) && (r - l <= 2 || dp[l + 1][r - 1])) {
                    //标记状态
                    dp[l][r] = true;
                    //如果长度大于当前最大回文串，则更新长度和位置
                    if (r - l + 1 > maxLen) {
                        maxLen = r - l + 1;
                        //[l,r]是回文串，闭区间
                        start = l;
                        end = r;
                    }
                }
            }
        }
        //[l,r]闭区间是最大回文串
        return s.substring(start, end + 1);
    }
}