美文网首页
算法刷题2023-09-20

算法刷题2023-09-20

作者: 晨颜 | 来源:发表于2023-09-19 22:57 被阅读0次

    无重复字符的最长子串

    方法1

    def length_of_longest_substring(s):
        # 创建一个字典来存储字符和它们的索引
        char_index = {}
        max_length = 0
        start = 0
        for end in range(len(s)):
            # 如果字符在字典中并且位于当前子串内,则更新子串的起始位置
            if s[end] in char_index and char_index[s[end]] >= start:
                start = char_index[s[end]] + 1
                print(start,end)
            # 在字典中记录字符的索引
            char_index[s[end]] = end
            print(char_index)
            # 更新最大子串长度
            max_length = max(max_length, end - start + 1)
            print(max_length)
        return max_length
    # 测试示例
    s = "abcabcbbabccdcbbae"
    d = "123456789012345678"
    result = length_of_longest_substring(s)
    print(result)
    #这段代码使用一个滑动窗口,通过移动start和end指针来维护一个不含重复字符的子串。当遇到重复字符时,将start指针移到重复字符的下一个位置,并继续检查。在遍历整个字符串的过程中,不断更新最长子串的长度。
    

    方法2

    class Solution(object):
        def lengthOfLongestSubstring(self, s):
            char_set = set()
            max_length = 0
            start = 0
    
            for end in range(len(s)):
                while s[end] in char_set:
                    # print(' s[end]=',s[end])
                    # print(char_set)
                    char_set.remove(s[start])
                    # print(char_set)
                    start += 1
                    # print(start)
                char_set.add(s[end])
                # print(char_set)
                max_length = max(max_length, end - start + 1)
    
            return max_length
    
    
    s = "abcabcbb"
    S = Solution()
    print(S.lengthOfLongestSubstring(s))
    
    
    # 测试示例
    s = "abcabcbbbbcdeea"
    result = length_of_longest_substring(s)
    print(result)
    #这段代码使用一个集合char_set来存储当前子串内的字符,如果遇到重复字符,就将start指针向右移动,同时从集合中移除重复字符,直到不再有重复字符。这种方法相对更简单,并且仍然具有线性时间复杂度。
    

    寻找两个正序数组的中位数

    我觉得我没错!!!!!

    # 给定两个大小分别为m和n的正序(从小到大)数组nums1和
    # nums2。请你找出并返回这两个正序数组的中位数 。
    # 算法的时间复杂度应该为O(log(m + n)) 。
    
    class Solution(object):
        def findMedianSortedArrays(self, nums1, nums2):
            list=nums1+nums2
            long=len(list)
            list.sort()
            if long%2==0:
                return (list[long//2-1]+list[long//2])/2
            return list[long//2]
    nums1=[1, 2]
    nums2=[3, 4]
    s=Solution()
    res=s.findMedianSortedArrays(nums1,nums2)
    print(res)
    

    最长回文子串

    获得两个字符串的最长公共回文子串,使用你认为的时间复杂度最低的算法。

    例如:输入:参数1: abadefg 参数2: cabadefg 输出:aba

    def longest_common_palindromic_substring(str1, str2):
        def is_palindrome(s):
            return s == s[::-1]  # 检查字符串是否是回文串
    
        def longest_common_substring(s1, s2):
            n1, n2 = len(s1), len(s2)
            dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]  # 创建动态规划表
            max_length = 0  # 最长公共子串的长度
            end = 0  # 最长公共子串的结束位置
    
            for i in range(1, n1 + 1):
                for j in range(1, n2 + 1):
                    if s1[i - 1] == s2[j - 1]:
                        dp[i][j] = dp[i - 1][j - 1] + 1  # 如果字符匹配,则在前一个状态的基础上加1
                        if dp[i][j] > max_length and is_palindrome(s1[i - dp[i][j]:i]):
                            # 如果找到更长的子串,并且是回文串,则更新最长子串信息
                            max_length = dp[i][j]
                            end = i
    
            return s1[end - max_length:end]  # 返回最长公共回文子串
    
        result = ""
        for i in range(len(str1)):
            common = longest_common_substring(str1[i:], str2)  # 在str1的每个子串上查找最长公共子串
            if len(common) > len(result):
                result = common  # 如果找到更长的子串,更新结果
    
        return result
    # 示例输入
    str1 = "abadefg"
    str2 = "cabadefg"
    result = longest_common_palindromic_substring(str1, str2)
    print(result)  # 输出 "aba"
    

    使用json 代表一个有向图,结构如下:

    nodes:[ (id; int, status: int) ].#节点列表
    edges: [(from: int, to: int)]#边列表
    Nodes:是代表点的数组,id 代表 node的 id,status 代表node 的状态 (3种),1是待执行,2是成功,3是失败
    edges:是代表边的数组,代表 to 节点依赖from节点执行成功后才能执行
    dag 执行规则:当一个节点的所有前置节点的执行成功(2) 的时候,该节点才会被执行如果一个节点没有前置节点,那么它可以直接执行,当且仅当不存在可我行节点时,dag 结束,输出空列表

    例如 image.png

    输入:"{
    nodes:[{id:1,status:2},{id:2,status:2},{id:3,status:2},{id:4,status:1},{id:5,status:3},{id:6,status:1}],
    edges:[{from:1,to:2},{from:1,to:3},{from:2,to:4},{from:3,to:5},{from:4,to:6},{from:5,to:6}]
    }"
    输出:[4]

    import json
    
    def execute_dag(dag_json):
        # 解析JSON数据
        dag_data = json.loads(dag_json)  # 将JSON数据解析为Python数据结构
        nodes = dag_data['nodes']  # 从JSON中获取节点列表
        edges = dag_data['edges']  # 从JSON中获取边列表
    
        # 创建字典来存储每个节点的状态
        node_status = {node['id']: node['status'] for node in nodes}  # 创建节点状态字典
    
        # 创建字典来存储每个节点的前置节点
        dependencies = {node['id']: [] for node in nodes}  # 创建依赖关系字典
        for edge in edges:dependencies[edge['to']].append(edge['from'])  # 建立节点之间的依赖关系
    
        # 创建一个空列表来存储可以执行的节点
        executable_nodes = []  # 创建空的可执行节点列表
    
        while True:
            no_executable_nodes = True  # 标记是否没有可执行的节点
    
            for node_id, status in node_status.items():
                if status == 1:  # 如果节点状态为1(待执行)
                    # 获取该节点的前置节点
                    dependent_nodes = dependencies[node_id]
                    # 检查该节点的所有前置节点是否已经成功执行(状态为2)
                    if all(node_status[dep_node] == 2 for dep_node in dependent_nodes):
                        # 如果所有前置节点状态都为2(成功),则可以执行该节点
                        executable_nodes.append(node_id)  # 将该节点添加到可执行节点列表
                        node_status[node_id] = 2  # 更新节点状态为2(成功)
                        no_executable_nodes = False
    
            if no_executable_nodes: break  # 如果没有可执行节点,结束循环
    
        return executable_nodes  # 返回可执行节点列表
    
    # 示例输入
    dag_json = '''
    { "nodes": [{"id": 1, "status": 2}, {"id": 2, "status": 2}, {"id": 3, "status": 2}, {"id": 4, "status": 1},{"id": 5, "status": 3}, {"id": 6, "status": 1}],
      "edges": [{"from": 1, "to": 2},{"from": 1, "to": 3},{"from": 2, "to": 4},{"from": 3, "to": 5},{"from": 4, "to": 6},{"from": 5, "to": 6}]
    }
    '''
    
    result = execute_dag(dag_json)
    print(result)  # 输出 [4]
    
    SELECT c.class_name, 
           MAX(CASE WHEN sc.subject_id = 1 THEN sc.score END) AS subject1_maxscore,
           MAX(CASE WHEN sc.subject_id = 2 THEN sc.score END) AS subject2_maxscore
    FROM class c
    JOIN student s ON c.class_id = s.class_id
    JOIN Score sc ON s.student_id = sc.student_id
    GROUP BY c.class_name
    
    SELECT c.class_name,  -- 选择查询结果中的列,这里选择班级名字
    MAX(CASE WHEN sc.subject_id = 1 THEN sc.score END) AS subject1_maxscore,  -- 计算第一个科目的最高分数
    MAX(CASE WHEN sc.subject_id = 2 THEN sc.score END) AS subject2_maxscore  -- 计算第二个科目的最高分数
    FROM class c  -- 从名为"class"的表中选择数据
    JOIN student s ON c.class_id = s.class_id  -- 将"class"表与"student"表关联,通过"class_id"列连接两个表
    JOIN Score sc ON s.student_id = sc.student_id  -- 将"student"表与"Score"表关联,通过"student_id"列连接两个表
    GROUP BY c.class_name  -- 根据班级名字将结果分组,以获得每个班级的最高分数
    
    

    相关文章

      网友评论

          本文标题:算法刷题2023-09-20

          本文链接:https://www.haomeiwen.com/subject/ikcovdtx.html