20240304-Day 24-点亮代码技能

Leetcode459(代码随想录:重复的子字符串)

C++:

知识点:

一、vector数据类型: vector<int> nums;

        1. 求vector数组长度:nums.size();

        2. 在数组尾部插入元素elem:nums.push_back(elem);

        3. 删除数组尾部最后一个元素:nums.pop_back();

        4. 删除位置pos的元素:nums.erase(const pos);

        5. 删除位置begin到end之间的元素:nums.erase(const begin, const end);

        6. 创建vector数组:

        (1)一维:vector<int> result(nums.size(), 0);初始化元素值为0,元素个数为nums.size()的一维数组;

        (2)二维:vector<vector<int>> result(row, vector<int>(column, 0));初始化row*column的二维数组,初始化值为0;

        7. 数组第一个元素:nums.begin();

        8. 数组最后一个元素:nums.end();

        9. 使用sort对数组进行排序需要包含头文件#include<algorithm>:

        (1)对数组升序排序:sort(nums.begin(), nums.end());

        (2)对数组降序排序:sort(nums.begin(), nums.end(), greater<int>());

        10. std::cout不能直接输出整个vector数组,需要对vector数组遍历依次输出;

        11. 交换数组元素:swap(nums[i], nums[j]);

        12. 反转:

        (1)字符串:reverse(nums.begin(), nums.end());

        (2)数组:reverse(nums, nums + nums.size());

二、知识:

        1. INT32_MAX:需要#include<limits.h>,是一个宏定义,数值等于2147483647;

        2. for循环的自动迭代:for(int i : nums);

        3. 自动类型匹配:关键字auto;

        4. 与 && 、或 || 、非 !

        5. 按引用传递允许被调用函数能够访问调用函数中的变量

三、unordered_set数据类型:unordered_set<int> set_name;

        1. 求集合大小:set_name.size();

        2. 在集合插入元素elem:set_name.insert(elem);

        3. set_name.begin():返回unordered_set第一个元素的迭代器;

        4. set_name.end():返回unordered_set最后一个元素下一个位置的迭代器;

        5. 查找集合中是否有元素elem,如果找到指定元素,它返回元素的迭代器,如果找不到指定元素,则返回指向set_name.end()的迭代器:set_name.find(elem);

四、unordered_map数据类型:unordered_map<int, int> map_name;

        1. 映射存储结构为 {first:数据元素key,second:数组元素对应的下标value};

        2. 映射是否为空:map_name.empty();

        3. 求映射容量:map_name.size();

        4. map_name.begin():返回unordered_map第一个元素的迭代器;

        5. map_name.end():返回unordered_map最后一个元素下一个位置的迭代器;

        6. 查找映射中是否有数据key为elem的元素,如果找到指定元素,它返回元素的迭代器,如果找不到指定元素,则返回指向map_name.end()的迭代器:map_name.find(elem);

        7. 判断集合中有没有键值k,如果无序map中有key k,那么返回值为1,否则返回值为0:map_name.count(k);

        8. 插入元素:

         (1)实现对应key的value值的覆盖,若是key值是原来不存在的key,那么实现了新的元素的插入:map_name[key_name] = value;

         (2)当容器中没有元素的键与要放置的元素的键相同时进行插入,如果插入会将容器大小增加一个:map_name.emplace(key, value);

         (3)当键是唯一时,才能进行插入,同时size增加,比emplace更灵活:map_name.insert(key, value);

        9. 删除元素:map_name.earse(key)

五、pair数据类型:pair<int, int> pair_name;(默认初始化为0)

        1. 作用:可以将两个数据类型绑定在一起,方便关联数据的输出与提取。存储的值可以是基本数据类型也可以是自定义数据类型。

        2. 访问和修改:pair_name.first; pair_name.second;

六、string数据类型:string str_name;

        1. 求字符串长度:str_name.length(); 或 str_name.size();

        2. str_name.begin():返回str_namep第一个元素的迭代器;

        3. str_name.end():返回str_name最后一个元素下一个位置的迭代器;

        4. 删除下标为 i 的字符:str_name.earse(str_name.begin + i);

        5. str_name.resize(n):改变字符串大小,使其包含n个元素;

        6. str_name.find(s):寻找str_name字符串中是否有s,如果有则返回字符串下标(int类型),如果没有返回std::string::npos;

暴力解法:
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        bool flag;
        for(int i = 1; i <= s.size()/2; i++)    //获取子串终止位置
        {
            if(s.size() % i == 0)
            {
                flag = true;
                for(int j = i; j < s.size(); j++)    //判断子串能否重复构成字符串
                {
                    if(s[j] != s[j-i])
                    {
                        flag = false;
                        break;
                    }
                }
                if(flag) return true;
            } 
        }
        return false;
    }
};
移动匹配: 
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        //移动子串,去掉前后成员,再找s
        string ss = s + s;
        ss.erase(ss.begin());
        ss.erase(ss.end() - 1);
        if(ss.find(s) == string::npos) return false;
        else return true;
    }
};
KMP:

最长相等前后缀不包含的子串就是重复子串的最小单位。

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        if(s.size() == 0)
            return false;
        //KMP
        int next[s.size()];
        get_next(next, s);
        if(next[s.size()-1] != 0 && (s.size() % (s.size() - next[s.size()-1])) == 0)
            return true;
        else
            return false;
    }

    void get_next(int* next, const string &str) {
        //初始化
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < str.size(); i++)
        {
            while(j > 0 && str[i] != str[j])
            {
                j = next[j-1];
            }
            if(str[i] == str[j])
                j++;
            next[i] = j;
        }
    }
};

Python:

知识点:

1. 求数组nums长度:

        len(nums)

2. 取整:

        middle = (left + right) // 2

3. 移除数组nums中的元素val:

        nums.remove(val)

4. 排序:

   (1)python升序排序,列表本身修改:

                nums.sort()

   (2)python升序排序,返回新列表:

                sorted(nums)

5. 复制列表:

   (1)列表地址相同:result = nums

   (2)创建列表副本:result = nums[:]

6.无穷:

   (1)float('inf'):正无穷大

   (2)float('-inf'):负无穷大

7. 建立列表:

   (1)建立二维列表的方法:result = [[0] * n for _ in range(n)]

   (2)建立一维全0列表的方法:result = [0 for _ in range(n)]

8. ord():python内置函数,用于返回字符的Unicode码

9. collections模块中的defaultdict:可以设置默认值的字典dict,defaultdict的第一个参数是一个可调用对象,它用于生成默认值,例如int, list, set等

   (1)初始化:hashmap = defaultdict(int)

   (2)get()方法:hashmap.get(i)查询字典中key为 i 的value值,如果key不存在则返回None

10. collections模块中的Counter:Counter是一个简单的计数器,例如,统计字符出现的个数

   (1)elements()方法:返回一个迭代器,可以通过 list 或者其它方法将迭代器中的元素输出,输出的结果为对应出现次数的元素

   (2)most_common()方法:返回一个出现次数从大到小的前 n 个元素的列表

   (3)Counter减法:substract函数会在两个计数器之间做减法,并且直接返回得出的计数结果;用减号“-”做减法属于集合运算,得出在被减数中原有元素的计数结果

11. python数据类型——集合set:

   (1)定义:集合是不可重复的、无序的、不可改变的类型,a = set()

   (2)添加元素:a.add(elem) 添加单个元素,a.update(elems) 添加多个元素并且自动舍去重复元素

   (3)删除元素:a.pop() 随机删除单个元素,a.remove(elem) 删除指定元素,a.clear() 清空集合,del a 删除集合

   (4)交集:a.intersection(b) 或 a & b

   (5)反交集:a.symmetric_difference(b) 或 a ^ b

   (6)并集:a.union(b) 或 a | b

   (7)差集:a.difference(b) 或 a - b

12. python数据类型——字典dict:

   (1)定义:字典元素以键值对存在:key(键):value(值),d = {}

   (2)d[key] = d.get(key,0)+1:d[key]表示键为key的值value,找不到则报错;d.get(key,0)表示找到键为key的值,找不到则赋值为0

13. enumerate():python内置函数,利用它可以同时获得索引和值,常用在遍历中

14. divmod():python内置函数,可以把除数和余数运算结果结合起来,返回一个包含整商和余数的元组(a // b, a % b)

15. str():将数据类型转化为字符串,比如int转str,float转str, str转str, boolean转str, list转str, dict转str, set转str

16. lambda函数:

   (1)用法:lambda 参数列表 : 表达式

   (2)lambda函数是匿名的,但是有自己的输入输出和名称空间

   (3)举例:lambda x, y : x + y :输入为x值和y值,输出为它们的和x+y的值

17. range()函数:

   (1)用法:range(start, stop[, step])

18. python语法:

   (1)函数需要先定义后调用

   (2)

19.  ' '.join()用法:

   (1)str.join(item):python中字符串是不可变类型,所以经常会将字符串转换成列表,再通过.join函数再将列表转换成字符串

   (2)' '.join(item)含义:将字符串item中的每个成员以空格' '分开再拼接成一个字符串

   (3)','.join(item)含义:将字符串item中的每个成员以逗号','分开再拼接成一个字符串

20. .split()函数:

   (1)含义:拆分字符串,通过指定分隔符对字符串进行切片,并返回分割后的字符串列表(list)

   (2)语法:str.split(str="分隔符,默认为空",num=分割次数))

21. 去除空格:

   (1)str.strip():去除字符串两边空格,括号中也可以指定字符去除

   (2)str.lstrip():去除字符串左边空格

   (3)str.rstrip():去除字符串右边空格

22. all()函数:可以判定一个元组或者列表中的元素是否都为真

23. .find()函数:检测字符串中是否包含子字符串,如果指定开始(beg,默认为0)和结束(end,默认为字符串长度)范围,则检查是否包含在指定范围内,如果包含子字符串返回开始的索引值,否则返回-1

暴力解法:
class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        # 暴力解法
        for i in range(1, len(s)//2 + 1):
            if len(s) % i == 0:
                flag = True
                for j in range(i, len(s)):
                    if s[j] != s[j-i]:
                        flag = False
                        break
                if flag: return True
        return False

这个all函数用的很好,很方便真正体现出了Python的优势,不像我自己写的只不过是C++版本的Python代码。 

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        # 暴力解法
        for i in range(len(s)//2):
            St = s[:i+1]
            if len(s) % len(St) == 0:
                if all(St == s[j: j+len(St)] for j in range(i+1, len(s), len(St))):
                    return True
        return False
移动匹配: 
class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        # 移动子串
        ss = s + s
        return ss.find(s, 1, len(ss)-1) != -1
KMP:

最长相等前后缀不包含的子串就是重复子串的最小单位。

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        def getnext(s):
            j = 0
            nextt = [0 for _ in range(len(s))]
            for i in range(1, len(s)):
                while s[i] != s[j] and j > 0:
                    j = nextt[j-1]
                if s[i] == s[j]:
                    j += 1
                nextt[i] = j
            return nextt
        
        # KMP
        l = len(s)
        if l == 0:
            return False
        nextt = getnext(s)
        if nextt[l-1] != 0 and (l % (l - nextt[l-1])) == 0:
            return True
        else:
            return False
  • 17
    点赞
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值