week 4 7月26日

串联所有单词的子串

给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

 s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

• 例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。

返回所有串联字串在 s 中的开始索引。你可以以 任意顺序 返回答案。

示例 1：

输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。

示例 2：

输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出：[]
解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。

示例 3：

输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出：[6,9,12]
解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。

提示：

• 1 <= s.length <= 104
• 1 <= words.length <= 5000
• 1 <= words[i].length <= 30
• words[i] 和 s 由小写英文字母组成

关键词：串联子串

一个包含  words 中所有字符串以任意顺序排列连接起来的子串

 对于["foo","bar","man"]，以上6个字符串都属于串联子串。题中的串联子串有特殊性，即列表中的所有字符长度都相等。"foo","bar","man"长度都是3

任务：

判断字符串s中是否有串联子串，若有返回下标索引

该题的解题方法和最长回文子串一样，都是在字符串s中找到一串字符，并判断该子串是否符合条件。

(3条消息) 最长回文子串_盐巴饭团193的博客-CSDN博客https://blog.csdn.net/zhu_ba/article/details/131699736?spm=1001.2014.3001.5502可以分解任务，任务1：找到和串联子串一样的长的子串   任务2：判断子串是否是串联子串

任务1：

找到和串联子串一样长的子串。由于words表中每个单词长度固定，所以子串长度一定是字符个数*单个字符长度

n=len(words)*len(words[0])

利用滑动窗口。如图所示，假设长度为6，从起点i出发，终点是i+6 。每次滑动，判断窗口内的是不是串联子串。判断结束，窗口向右滑动一格。直至窗口右端滑到末端。

for i in range(0,m-n+1):
   #判断子串

任务2：

从任务1中，得到了一个子串str，判断str是否是串联子串

解法1：

串联子串是words中所有单词的自由排序，只要维护一个字典。该字典存储所有单词的自由组合的所有可能。只要str在字典中，那么str就是串联子串

def findSubstring(self, s: str, words: List[str]) -> List[int]:
        wordsdict=[]#自由排列字典
        result=[]#用来存储串联子串的下标
        def permutation(s,i):#自由排列的函数
            if i == len(s):
                st3 = ''.join(s)
                wordsdict.append(st3)#排列结束，加入字典
            else:
                for j in range(i,len(s)):
                    s[j],s[i] = s[i],s[j]
                    permutation(s,i+1)
                    s[j],s[i] = s[i],s[j]
        permutation(words,0)
        m=len(s)
        n=len(words)*len(words[0])
        for i in range(m-n+1):#窗口移动
            if s[i:i+n] in wordsdict:#如果str在字典中
                result.append(i)#存储下标
        
        return result

问题：该解法维护一个所有可能性的字典，当words里单词很多的时候，他的排列组合有n！种，也就需要几何倍数的空间，最终会内存不足

解法2：

采用哈希表。维护一张哈希表counter，存储words中每个单词出现的频率。如果滑动窗口中的str是串联子串的话，他们的单词出现频率是一样的。

也就是说对str子串来说，每截len(words[0])个字符，作为一个单词word。如果这个单词出现在counter中，则counter[word]-1。当counter[word]==0时，删掉counter[word]。当len(counter)为0时，也就是counter被删光时，说明str和串联子串刚好对应上。

以下是匹配成功的流程演示：

 以下是匹配失败的流程演示：

以下是完整代码： 

class Solution:
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        result=[]
        m=len(s)
        n=len(words)*len(words[0])
        for i in range(0,m-n+1):#滑动窗口
            counter = Counter(words)
            for j in range(i,i+n,len(words[0])):#单个比对单词
                word = s[j:j+len(words[0])]
                if word in counter:
                    counter[word]-=1
                    if counter[word]==0:
                        del counter[word]
                if len(counter)==0:
                    result.append(i)
                    break
        return result

 该解法最终会造成时间超时

解法3：

对于时间超时的情况，是因为每次比较都做一次counter[word]-1,以及len判断。

我们采用空间换时间的方法，因为哈希表有随机访问的特性，所以我们可以试着维护两个哈希表。其中一个哈希表counter的作用与解法2相同，记录words中各个单词出现的频率。对于任务1得到的字符串str，将其分割为n个单词，用另一个哈希表temp记录str中各个单词出现的频率。

两个哈希表都记录结束，如果两个哈希表相同的话，说明str是串联子串；如果不同，则str不是。

以下是匹配成功的流程演示：

以下是匹配失败的流程演示：

 以下是完整代码：

class Solution:
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        result=[]
        m=len(s)
        n=len(words)*len(words[0])
        wordlen=len(words[0])
        for i in range(0,m-n+1):
            counter = Counter(words)
            temp=[]
            for j in range(i,i+n,wordlen):
                word = s[j:j+wordlen]
                temp.append(word)
            if Counter(temp)==counter:
                result.append(i)       
        return result

---

反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

任务：

将字符串中按照空格分隔出单词，并把单词从后往前输出

分隔字符串只需要spilt函数

注意：split()默认按照空格分隔，并删除掉多余的空格。而spilt(" ")虽然也是按照空格分隔字符串，但是只会删除一个空格

 将分割出来的"hello""world""!"，反转成"!""world""hello"。

最后通过join函数将单词串联起来。并且利用strip函数去除字符串两边的空格

class Solution:
    def reverseWords(self, s: str) -> str:
        a = s.split()
        #默认按照空格分隔 如果spilt(" ")的话，两字符之间只会删除一个空格
        result = []
        n = len(a)
        for i in a[::-1]:
        #从后往前遍历
            result.append(i)
        return ' '.join(result).strip()

---

李沐深度学习笔记

训练集、验证集、测试集

训练误差：模型在训练集上的误差

泛化误差：模型在新数据上的误差（测试集？） 关心的 训练误差不关心

验证数据集（拿出一半的训练集），不参与训练，用于评估模型的好坏。若不好，调一下超参数。

训练集是调神经网络的参数，如w和b等。而验证集是调整超参数，如学习率lr、网络层数、迭代次数等。

测试集，只用一次，最终模型的评估，不会参与调参。

怎么选择验证集？当训练集不够大时，

 迭代3次（k次），每一次选择1块训练数据作为验证集，其余2块（k-1块）作为训练集。

得到3个（k个）验证集误差，求平均

过拟合、欠拟合

第一种过于简单，欠拟合，第二种过于复杂 ，过拟合

模型过于复杂，会过拟合，造成训练集上的精准度很高，但是测试集上的精准度下降

过拟合有时候是好事。首先，我们要模型容量足够大，在够的情况下，通过各种手段，使泛化误差下降。 要是模型太简单，怎么调都没有用。

  统计学提供了数学工具去衡量模型优劣。实际上，是通过观察训练误差（调整参数）和验证误差（调整超参数）。

每个样本的元素个数：每个样本二维？三维？。。。。每个图片大小（3*28*28？3*79*79?）

imagenet最小是256*256

视频：空间轴、时间轴    股票预测：时间轴 

 如果能单拎验证集，得到他的序列号之类的，是可以分开清洗数据的。如果拿不到，就一起清洗。

理论上，k（迭代次数）越大，越精确 。但是，计算成本相对提高。 

选择1、k折交叉验证就是确定超参数，确定后要重新训练整个训练模型 只需要一遍

选择2、可以k次，每次都训练一遍模型。计算很大，但是模型更稳定

选择3、可以k次，直接选择误差最小的模型

模型参数和超参数的区别：

模型参数：神经网络自己产生，并自动优化的参数

超参数：迭代过程中改不了的，也就是可以人工去修改的。如学习率设置等。

如何有效设计超参数？推荐随机。

蒸馏：在一个大模型的监督下，训练一个小模型。比一个野蛮生长的小模型的训练效果好