无重复字符的最长子串 动态规划

本文探讨了求解无重复字符最长子串的问题,通过动态规划方法详细解析了算法思路,提供了具体实现代码,旨在帮助读者理解并掌握这一常见算法题的解决策略。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

无重复字符的最长子串

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

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

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

示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”,所以其长度为 3。
请注意,你的答案必须是 子串 的长度,“pwke” 是一个子序列,不是子串。

思路

动态规划:

我看晚上有好多都是用map来保存位置做的,其实这道题目还可以使用动态规划,具体思如下:
//动态规划
//假设当前 i 位置的子串为最长的子串,则 i + 1 位置最长的子串为:
//分情况:
// 1)如果strArr[i]子串不包含字符chars[i + 1], 则 i + 1 位置的最长子串为 strArr[i] + chars[i + 1]
// 2)如果strArr[i]子串包含字符chars[i + 1], 则需要截取strArr[i] 字符串,比如:strArr[i] = “pwck”, chars[i + 1] = ‘c’,则strArr[i + 1] = “k” + ‘c’
//最后遍历strArr数组, 获取最长的数组元素

代码试下如下:

public int lengthOfLongestSubstring(String s) {

    if(null == s || "".equals(s)){
        return 0;
    }
    if(s.length() == 1){
        return 1;
    }
    char[] chars = s.toCharArray();
    int len = chars.length;
    String[] strArr = new String[len];

    strArr[0] = chars[0] + "";
    for(int i = 1; i < len; i++){
        if(strArr[i - 1].contains(chars[i] + "")){
            strArr[i] = strArr[i - 1].substring(strArr[i - 1].indexOf(chars[i] + "") + 1) + chars[i] + "";
        }else{
            strArr[i] = strArr[i - 1] + chars[i];
        }
    }
    int maxLen = 0;

    for(String tmp : strArr){
        if(tmp.length() > maxLen){
            maxLen = tmp.length();
        }
    }
    return maxLen;
}
<think>我们正在解决“无重复字符长子”问题,使用动态规划方法。问题描述:给定一个字符,找出其中不含有重复字符的长子的长度。动态规划思路:定义状态:dp[i]表示以第i个字符结尾的长无重复子的长度。注意:这里第i个字符是指字符中索引为i的字符(索引从0开始)。状态转移:我们需要考虑两种情况:1.当前字符s[i]不在之前的长无重复子中(即不在以s[i-1]结尾的长无重复子中),那么dp[i]=dp[i-1]+1。2.当前字符s[i]出现在之前的长无重复子中,那么我们需要找到该字符上一次出现的位置(在当前的以s[i-1]结尾的子中),然后从该位置之后开始重新计算当前子。具体地,设上一次出现的位置为j(在当前的子中,即从i-dp[i-1]到i-1的范围内),那么当前以s[i]结尾的长子应该从j+1开始,直到i,长度为i-j。但是,我们如何知道上一次出现的位置?我们可以用一个哈希表(或数组)来记录每个字符近一次出现的位置。因此,我们可以优化状态转移:用dp[i]表示以s[i]结尾的长无重复子的长度。同时,我们维护一个变量start,表示当前无重复子的起始位置(初始start=0),或者我们可以不用start,而是用哈希表记录每个字符近一次出现的位置。具体步骤:1.初始化一个哈希表map(或者数组),用于存储每个字符近一次出现的索引。2.初始化dp[0]=1,因为只有一个字符,无重复。同时,map[s[0]]=0。3.初始化一个变量max_len记录大长度,初始为1。4.遍历字符,从i=1到n-1:如果字符s[i]没有出现过,或者近一次出现的位置在当前考虑的子的起始位置之前(即不在当前子中),那么dp[i]=dp[i-1]+1。否则,如果s[i]近一次出现的位置(记为j)在当前子中(即j>=当前子的起始位置),那么当前子的起始位置应该更新为j+1,此时以s[i]结尾的子长度为i-j。但是,我们如何知道当前子的起始位置?实际上,我们可以维护一个起始位置start,它表示当前无重复子的起始索引。那么:如果s[i]在start到i-1的范围内出现过(即上一次出现的位置j>=start),那么我们需要更新start为j+1,然后dp[i]=i-start+1。否则,dp[i]=dp[i-1]+1。然而,我们也可以不显式维护start,而是通过哈希表记录的位置和当前的位置来计算。但是,显式维护start可能更直观。另一种常见的动态规划思路(与上面提到的start方法类似):定义:start:当前无重复子的起始位置(初始为0)max_len:大长度(初始为0)哈希表map:存储字符近出现的位置遍历每个字符(索引为i):如果当前字符s[i]在map中,并且其近出现的位置大于等于start(说明在当前子中重复),那么将start更新为map[s[i]]+1。然后,更新当前无重复子的长度为i-start+1,并更新max_len。更新map中s[i]的位置为i。注意:即使s[i]在map中出现过,但如果其上一次出现的位置小于start,说明这个重复不在当前子中,那么当前子仍然可以包含s[i](即不重复),所以不需要移动start。因此,动态规划的状态转移可以简化为:start=max(start,map.get(s[i],-1)+1)#如果map中没有s[i],则取-1,那么-1+1=0,不会影响startcurrent_len=i-start+1max_len=max(max_len,current_len)map[s[i]]=i这个过程中,我们并没有使用dp数组,而是用了一个变量current_len记录当前长度,以及max_len记录大值。实际上,这是一种空间优化的动态规划(因为每个状态只依赖于前一个状态和start,所以不需要数组)。但是,题目要求动态规划解法,我们可以用dp数组,也可以不用(空间优化)。这里我们按照引用[4]中的方法,使用dp数组,但引用[4]中使用了string的rfind,效率较低,我们可以改进为使用哈希表记录位置。引用[4]的代码思路:dp[i]表示以第i个字符结尾的长无重复子的长度。用一个字符temp来保存当前无重复子(从某个位置到i-1的子),然后对于s[i]:在temp中查找s[i]的位置(从后往前找,即rfind),如果找到(位置为index),那么从index+1开始取子,然后加上s[i],作为新的temp,同时dp[i]=temp的长度(即index+1到i的子长度)。如果没有找到,则temp加上s[i],dp[i]=dp[i-1]+1。但是,在temp中查找字符的时间复杂度为O(n),所以整体时间复杂度为O(n^2)。我们可以用哈希表优化查找过程。因此,我们采用优化后的动态规划(使用哈希表记录字符近出现的位置)来达到O(n)的时间复杂度。步骤(优化后的动态规划):设n为字符长度,如果n==0,返回0。初始化:dp[0]=1max_len=1map={}#字符到索引的映射map[s[0]]=0start=0#当前无重复子的起始位置然后从i=1开始遍历:如果s[i]在map中,并且map[s[i]]>=start(说明这个重复发生在当前子中),那么更新start=map[s[i]]+1计算当前以s[i]结尾的子长度:dp[i]=i-start+1更新max_len=max(max_len,dp[i])更新map中s[i]的位置为i注意:在更新start时,我们取max(start,map[s[i]]+1)是为了确保start不会回退(因为有可能map[s[i]]+1比当前start还小?实际上,如果s[i]不在当前子中,那么map[s[i]]应该小于start,所以我们不需要移动start。因此,我们可以这样写:ifs[i]inmapandmap[s[i]]>=start:start=map[s[i]]+1dp[i]=i-start+1max_len=max(max_len,dp[i])map[s[i]]=i但是,这样写需要先判断,我们可以统一写成:start=max(start,map.get(s[i],-1)+1)#如果s[i]不在map中,则返回-1,那么-1+1=0,但是start至少是0,所以如果start比0大,就不会被更新为0。注意,这里如果s[i]出现过,但是在上一次出现在start之前,那么map[s[i]]+1可能小于start,所以用max保证start不会变小。因此,代码可以写为:ifi>=1:start=max(start,map.get(s[i],-1)+1)dp[i]=i-start+1max_len=max(max_len,dp[i])map[s[i]]=i但是,注意:当s[i]在map中,但位置在start之前,那么start保持不变,dp[i]=i-start+1,这是正确的,因为s[i]不在当前子中。然而,这里有一个问题:当s[i]不在map中时,map.get(s[i],-1)返回-1,那么start=max(start,0)。如果start>=0,那么start不变。但是,如果start是负数?不会,因为start初始为0。因此,我们可以统一使用start=max(start,map.get(s[i],-1)+1)来更新。但是,我们还需要注意:在更新map[s[i]]时,即使之前出现过,我们也要更新为当前的位置,因为我们需要近出现的位置。举例验证:s="abcabcbb"i=0:s[0]='a'->map={'a':0},dp[0]=1,start=0,max_len=1i=1:'b'->map中没有,start=max(0,-1+1)=max(0,0)=0->dp[1]=1-0+1=2->max_len=2,map={'a':0,'b':1}i=2:'c'->同理,dp[2]=3,max_len=3,map={'a':0,'b':1,'c':2}i=3:'a'->map中有,上次位置0,start=max(0,0+1)=1->dp[3]=3-1+1=3,max_len=3,然后更新map['a']=3i=4:'b'->map中有'b',上次位置1,start=max(1,1+1)=2->dp[4]=4-2+1=3,max_len=3,更新map['b']=4i=5:'c'->map中有'c',上次位置2,start=max(2,2+1)=3->dp[5]=5-3+1=3,max_len=3,更新map['c']=5i=6:'b'->map中有'b',上次位置4,start=max(3,4+1)=5->dp[6]=6-5+1=2,max_len=3,更新map['b']=6i=7:'b'->map中有'b',上次位置6,start=max(5,6+1)=7->dp[7]=7-7+1=1,max_len=3,更新map['b']=7结果正确,大长度为3。但是,我们也可以不使用dp数组,因为每次只用到前一个位置?实际上,我们并没有用到dp[i-1],而是直接计算dp[i](通过start和i),所以可以只用一个变量current_len代替dp[i],然后更新max_len。不过题目要求动态规划,我们可以用dp数组,但空间复杂度为O(n)。如果不需要保存每个位置的状态,我们可以只用一个变量记录当前长度。不过,引用[4]中使用了dp数组,我们也按照dp数组的方式写,但实际计算中,dp[i]只依赖于start(而start依赖于之前的状态),所以使用dp数组是可行的。代码实现(使用dp数组):步骤:初始化dp=[0]*ndp[0]=1max_len=1map={s[0]:0}start=0foriinrange(1,n):#更新startifs[i]inmap:#注意:map[s[i]]是上一次出现的位置,可能小于当前的start,所以用maxstart=max(start,map[s[i]]+1)else:#不在map中,start不变(但是我们可以统一用max,所以不需要else)pass#统一写法:无论是否在map中,都可以用start=max(start,map.get(s[i],-1)+1)#所以我们用统一写法start=max(start,map.get(s[i],-1)+1)dp[i]=i-start+1#更新mapmap[s[i]]=iifdp[i]>max_len:max_len=dp[i]返回max_len但是,这里有一个问题:我们在更新map[s[i]]之前,先使用了map.get(s[i],-1),这样在map中可能已经存在s[i](但我们要用更新前的位置),所以正确。注意:在更新start时,我们使用的是更新前map中的位置(即上一次出现的位置)。我们也可以不使用dp数组,而只用一个变量current_len,因为dp[i]只用于更新max_len,且不需要保存整个数组。下面给出两种代码(使用dp数组和不使用dp数组)?由于题目要求动态规划解法,我们可以使用dp数组(尽管空间复杂度为O(n)),但也可以说明动态规划的思想。但是,引用[4]中使用了dp数组,所以我们按照dp数组的方式写。然而,上述过程中,dp[i]并不依赖于dp[i-1],而是直接由start和i计算得到,所以严格来说不是典型的动态规划(状态转移不是从dp[i-1]到dp[i]),但也是动态规划的一种(状态dp[i]表示以i结尾的子长长度,且状态转移通过start来间接实现)。另一种典型的动态规划是:dp[i]表示以第i个字符结尾的长无重复子的长度。那么,设s[i]上一次出现的位置为j(如果没有则为-1),则:dp[i]=min(dp[i-1]+1,i-j)为什么?因为:如果当前字符s[i]与之前子中的字符不重复,那么dp[i]=dp[i-1]+1。如果重复了,那么以i结尾的长子的长度就是i-j(因为重复发生在j位置,所以从j+1到i是无重复的)。但是,这里有一个条件:j必须在[i-dp[i-1],i-1]的范围内,否则这个重复不在当前子中,那么dp[i]还是dp[i-1]+1。然而,我们无法直接知道j是否在当前的子中(即是否在[i-dp[i-1],i-1]范围内)。所以我们可以这样写:dp[i]=min(dp[i-1]+1,i-j)当j>=0时,但这样写不一定正确。例如:s="abba",当i=3(后一个'a')时:i=0:'a'->dp[0]=1,j=-1->dp[0]=1i=1:'b'->dp[1]=2,j=-1->dp[1]=2i=2:'b'->j=1(因为上一个'b'在位置1),那么dp[2]=min(dp[1]+1=3,2-1=1)=1->正确(因为"abb"中,以第二个'b'结尾的长子是"b",长度为1?不对,应该是"ab"已经包含了第一个'b',所以第二个'b'重复了,那么以第二个'b'结尾的长子应该是从上一个'b'后面开始,即位置2开始,长度为1,所以dp[2]=1。i=3:'a'->j=0(第一个'a'),那么dp[3]=min(dp[2]+1=2,3-0=3)->取2。但是,以第三个字符(第二个'b')结尾的长子是"b"(长度为1),那么以第四个字符'a'结尾的子:因为上一个'a'在位置0,而当前子的起始位置应该是上一个重复字符'b'的位置(位置2)和上一个'a'的位置(位置0)中较大的那个?因为当前子必须保证无重复,所以起始位置应该是max(0+1,2+1)=3?不对,应该是从位置2开始(因为位置2是上一个重复的'b'后面,但位置0的'a'在位置2之前,且当前子(从位置2开始)中并没有包含'a',所以可以加入。但实际上,从位置2开始的子是"ba",包含当前字符'a',所以长度应该是2。因此,我们需要知道当前子的起始位置,也就是上一个重复字符出现的位置(但可能有多个重复?)实际上,我们关心的是上一个与当前字符相同的字符的位置,以及上一个重复事件导致的起始位置(即dp[i-1]对应的起始位置)。所以,我们仍然需要记录起始位置。所以,更通用的方法还是用start记录当前无重复子的起始位置。因此,我们采用第一种方法(用start和哈希表)来实现动态规划。总结动态规划思想:我们定义dp[i]为以s[i]结尾的长无重复子的长度。通过维护一个哈希表记录每个字符近出现的位置,以及一个变量start表示当前无重复子的起始位置(这个起始位置是动态更新的)。状态转移方程:start=max(start,last_occurrence.get(s[i],-1)+1)dp[i]=i-start+1然后更新last_occurrence[s[i]]=i后,大长度就是dp数组中的大值。我们也可以不使用dp数组,而用一个变量current_length代替dp[i],然后实时更新大长度。但为了符合动态规划的形式,我们可以保留dp数组。代码实现(Python):deflengthOfLongestSubstring(s:str)->int:n=len(s)ifn==0:return0#初始化dp=[0]*ndp[0]=1#哈希表记录字符近出现的位置last_occurrence={s[0]:0}start=0max_len=1foriinrange(1,n):#计算start#如果s[i]在last_occurrence中,则取last_occurrence[s[i]],否则取-1prev_index=last_occurrence.get(s[i],-1)#更新start:如果prev_index+1大于当前start,则更新,否则不变start=max(start,prev_index+1)dp[i]=i-start+1#更新大长度ifdp[i]>max_len:max_len=dp[i]#更新字符s[i]的位置last_occurrence[s[i]]=ireturnmax_len测试例子:s="abcabcbb"->3s="bbbbb"->1s="pwwkew"->3注意:在遍历过程中,start可能被更新(增大),而dp[i]则计算了以i结尾的子长度。这种动态规划的时间复杂度为O(n),空间复杂度为O(n)(dp数组)和O(字符集大小)(哈希表)。我们也可以不使用dp数组,只用一个变量current_len,因为dp[i]只用于更新max_len,不需要保存所有状态:deflengthOfLongestSubstring(s:str)->int:n=len(s)ifn==0:return0last_occurrence={}start=0max_len=0foriinrange(n):#如果当前字符已经出现过,并且上一次出现的位置大于等于start,则更新startifs[i]inlast_occurrenceandlast_occurrence[s[i]]>=start:start=last_occurrence[s[i]]+1#当前子长度current_len=i-start+1ifcurrent_len>max_len:max_len=current_lenlast_occurrence[s[i]]=ireturnmax_len或者用统一写法(避免if):deflengthOfLongestSubstring(s:str)->int:start=0max_len=0last_occurrence={}fori,cinenumerate(s):ifcinlast_occurrence:#注意,这里必须保证last_occurrence[c]>=start才需要更新start,否则start不变start=max(start,last_occurrence[c]+1)current_len=i-start+1max_len=max(max_len,current_len)last_occurrence[c]=ireturnmax_len这种写法和上面一样,且更简洁。所以,我们通常采用这种空间优化的动态规划(或者称为滑动窗口更合适?)。但是,动态规划的思想体现在我们用状态转移(通过start)来计算当前子的长度。回到问题,用户要求动态规划解决思路,我们可以给出两种形式:使用dp数组和空间优化(不使用dp数组)的形式。但空间优化形式更常用。在回答中,我们将详细解释动态规划的思想和步骤,并给出代码。</think>### 无重复字符长子动态规划解法详解 #### 动态规划思想 解决**无重复字符长子**问题时,动态规划的核心思路是: **定义状态**:$dp[i]$ 表示以字符中第 $i$ 个字符结尾的长无重复子的长度。 **目标**:遍历整个字符,计算所有 $dp[i]$ 的大值,即全局长无重复子的长度。 #### 关键步骤与状态转移 1. **状态初始化**: - $dp[0] = 1$(单个字符无重复) - 哈希表 `last_occurrence` 记录字符近出现的位置(如 `{'a': 0}`) - 维护指针 `start` 表示当前无重复子的起始位置(初始为 0) 2. **状态转移方程**($i \geq 1$): $$ \begin{cases} \text{start} = \max(\text{start}, \text{last\_occurrence}[s[i]] + 1) \\ dp[i] = i - \text{start} + 1 \end{cases} $$ - **`start` 更新逻辑**: - 若 $s[i]$ 未出现过或不在当前子中(`last_occurrence.get(s[i], -1) < start`),`start` 不变。 - 若 $s[i]$ 已在当前子中(`last_occurrence[s[i]] \geq \text{start}`),将 `start` 移到该字符上一次出现位置的下一位。 - **$dp[i]$ 计算**:以 $s[i]$ 结尾的子长度为 $i - \text{start} + 1$。 3. **更新哈希表**: 记录 $s[i]$ 的新位置:`last_occurrence[s[i]] = i`。 4. **更新全局大值**: 比较所有 $dp[i]$,取大值 $\text{max\_len} = \max(\text{max\_len}, dp[i])$。 #### 示例分析($s = \text{"pwwkew"}$) | $i$ | $s[i]$ | `start` 更新 | $dp[i]$ | 当前子 | `last_occurrence` | |-----|--------|--------------|---------|----------|-------------------| | 0 | `'p'` | 0 | 1 | `"p"` | `{'p':0}` | | 1 | `'w'` | 0 | 2 | `"pw"` | `{'p':0, 'w':1}` | | 2 | `'w'` | $\max(0,1+1)=2$ | 1 | `"w"` | `{'p':0, 'w':2}` | | 3 | `'k'` | 2 | 2 | `"wk"` | `{'p':0, 'w':2, 'k':3}` | | 4 | `'e'` | 2 | 3 | `"wke"` | 更新 `'e':4` | | 5 | `'w'` | $\max(2,2+1)=3$ | 3 | `"kew"` | 更新 `'w':5` | 终 $\text{max\_len} = 3$(子 `"wke"` 或 `"kew"`)。 #### 代码实现(Python) ```python def lengthOfLongestSubstring(s: str) -> int: n = len(s) if n == 0: return 0 dp = [0] * n dp[0] = 1 last_occurrence = {s[0]: 0} start = 0 max_len = 1 for i in range(1, n): # 更新子起始位置 start = max(start, last_occurrence.get(s[i], -1) + 1) # 计算dp[i] dp[i] = i - start + 1 # 更新大值和字符位置 if dp[i] > max_len: max_len = dp[i] last_occurrence[s[i]] = i return max_len ``` #### 复杂度分析 - **时间复杂度**:$O(n)$,遍历字符一次。 - **空间复杂度**:$O(|\Sigma|)$($\Sigma$ 为字符集大小),哈希表存储字符位置[^4]。 #### 优化:空间压缩 可省略 $dp$ 数组,仅用变量 `cur_len` 记录当前子长度: ```python def lengthOfLongestSubstring(s: str) -> int: start = 0 max_len = 0 last_occurrence = {} for i, char in enumerate(s): if char in last_occurrence and last_occurrence[char] >= start: start = last_occurrence[char] + 1 cur_len = i - start + 1 max_len = max(max_len, cur_len) last_occurrence[char] = i return max_len ```
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值