力扣算法题 Python3实现

无重复字符的最长子串

难度：中等
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

我的办法：滑动窗口+局部最优解

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        subs = ""
        dp1=0
        for each in s:
            if each in subs:
                subs=subs[subs.find(each)+1:]
            subs+=each
            dp1=max(dp1,len(subs))
        return dp1

在排序数组中查找元素的第一个和最后一个位置

难度：中等

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

知识点：二分查找

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        n=len(nums)
        start=end=-1
        if nums==[]:
            return [-1,-1]
        for i in range(n):
            if nums[i]==target:
                start=i
                break
        for i in range(n-1,start-1,-1):
            if nums[i]==target:
                end=i
                break
        return [start,end]

整数转罗马数字

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给你一个整数，将其转为罗马数字。

哈希表：字典

class Solution:
    def intToRoman(self, num: int) -> str:
        res=""
        slist=[(1000,"M"),(900,"CM"),(500,"D"),(400,"CD"),(100,"C"),(90,"XC"),(50,"L"),(40,"XL"),(10,"X"),(9,"IX"),(5,"V"),(4,"IV"),(1,"I")]
        for each in slist:
            for i in range(num//each[0]):
                res+=each[1]
            num = num%each[0]
        return res

最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
示例 2：

输入：nums = [0,0,0], target = 1
输出：0

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        n=len(nums)
        asum = nums[0]+nums[1]+nums[2]
        if asum - target>=0:
            return asum
        asum = nums[n-1]+nums[n-2]+nums[n-3]
        if asum - target<=0:
            return asum
        res=nums[0]+nums[1]+nums[2] # 指定一个初始结果并中途更新
        for i in range(n-2):
            if i>0 and nums[i]==nums[i-1]:
                continue
            j=i+1
            k=n-1
            while j<k:
                asum=nums[i]+nums[j]+nums[k]
                diff=asum-target
                if  diff==0:
                    return asum
                if abs(res-target)>abs(diff):
                    res=asum
                elif diff<0:
                    j+=1
                    while j<k and nums[j]==nums[j-1]:
                        j+=1
                elif diff>0:
                    k-=1
                    while j<k and nums[k]==nums[k+1]:
                        k-=1
        return res

比较含退格的字符串

简单
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = “ab#c”, t = “ad#c”
输出：true
解释：s 和 t 都会变成 “ac”。
示例 2：

输入：s = “ab##”, t = “c#d#”
输出：true
解释：s 和 t 都会变成 “”。
示例 3：

输入：s = “a#c”, t = “b”
输出：false
解释：s 会变成 “c”，但 t 仍然是 “b”。

提示：

1 <= s.length, t.length <= 200
s 和 t 只含有小写字母以及字符 ‘#’
笨办法 思路：完全确定 s,t 最终的输出后比较是否相等

def subfun(st:str):
    n=len(st)
    st=list(st)
    time=0
    for i in range(n-1,-1,-1):
        if st[i]=="#":
            st[i]=""
            time+=1
            continue
        else:
            if time:
                time-=1
                st[i]=""
    return "".join(st)
class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        return subfun(s)==subfun(t)

方法二：勉强跑通了，最终根据状态返回结果逻辑不好分析

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        m=len(s)
        n=len(t)
        i=m-1
        j=n-1
        while (i>=0 or j>=0):
            s_time=0
            t_time=0
            while i>=0:
                if s[i]=="#":
                    s_time+=1
                    i-=1
                else:   
                    if s_time:
                        s_time-=1
                        i-=1
                    else:                   
                        break
            while j>=0:
                if t[j]=="#":
                    t_time+=1
                    j-=1
                else:   
                    if t_time:
                        t_time-=1
                        j-=1
                    else:
                        break
            if i>=0 and j>=0:
                if s[i]!=t[j]:
                    return False
            elif i>=0 or j>=0:
                return False

            i-=1
            j-=1
        return True