无重复字符的最长字串问题

leetcode3:无重复字符的最长字串问题

问题描述

 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: "pwwkew"
输出: 3

这道题，我自己的思路就是利用双指针保存滑动窗口的上下线。具体利用hashmap保存每一个元素的位置信息，然后取数据的时候，如果hashmap中存在，那么我们可以知道元素的窗口开始变化。

  public int lengthOfLongestSubstring(String s) {

        if (s == null || "".equals(s)) return 0;
        HashMap<String, Integer> maps = new HashMap<>();

        int len = s.length();
        // 表示
        int low = 0, max = 1;
        for (int i = 0; i < len; i++) {
            String dest = s.charAt(i) + "";
            // 注释是自己原本的实现，后面把逻辑简化一下。
            /*int value = maps.getOrDefault(dest, -1);
            // 表明找到元素，元素可能的位置信息
            // tmmzuxt  元素
            if (value != -1) {
                // 分为两种情况 1. value在 low, i之间  2. value在后面
                if (value < low) {
                    max = i - low + 1 > max ? i - low + 1 : max;
                } else {
                    max = i - low > max ? i - low : max;
                    low = value + 1;
                }
            } else if (i == len - 1) {
                max = len - low > max ? len - low : max;
            }
            maps.put(dest, i);*/
            if (maps.containsKey(dest)) {
                low = Math.max(maps.get(dest), low);
            }
            max = Math.max(max, i - low + 1);
            maps.put(dest, i + 1);
        }
        return max;
    }

抓住问题的特殊点，因为表示的是字符串，那么可以用128维的数组来保存字符串中的每一个字符。也就是说可以利用数组替换hashmap.

/**
     * 利用字符串ASCII码来替代hashMap
     * @param s
     * @return
     */
    public int lengthOfLongestSubstringTrick(String s) {

        if(s==null||"".equals(s)) return 0;
        int index[] = new int[128];
        int len = s.length();
        int max = 1, low = 0;
        for (int i = 0; i < len; i++) {
            int asc = s.charAt(i);
            low = Math.max(index[asc], low);
            max = Math.max(max, i - low + 1);
            index[asc] = i + 1;
        }
        return max;
    }

也可以把问题转换为一个dp问题，dp动态方程是，dp[i]表示以位置i上的数据结尾的最长字串的长度。那么dp[i]取值范围，最大为dp[i-1]+1, 最小为1。 当然此方法醉花情况下复杂度为O(n^2)

 /**
     * 状态转移方程  dp[i]表示以i为结尾的连续字符串的最大长度   dp[i]=取值范围{1, dp[i-1]+1}
     *
     * @param s
     * @return
     */
    public int lengthOfLongestSubstringDp(String s) {
        if (s == null || "".equals(s)) return 0;
        int len = s.length();
        char[] sArrays = s.toCharArray();

        int preNum = 1, max = 1;
        int cNum = 0;
        for (int i = 1; i < len; i++) {

            char dest = s.charAt(i);

            cNum = 0;
            for (int j = i - 1; j > i - 1 - preNum; j--) {
                if (s.charAt(j) != dest) cNum++;
                else break;
            }
            preNum = cNum;
            max = max > cNum ? max : cNum;
        }

        return max;
    }