leetcode

FranPav

已于 2022-03-02 18:33:12 修改

阅读量4.3k

点赞数 1

分类专栏： lc 文章标签： leetcode 算法职场和发展

于 2021-12-29 22:09:46 首次发布

本文链接：https://blog.csdn.net/weixin_43653681/article/details/122223682

版权

lc 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 两数之和 python

class Solution(object): 我的答案
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(0,len(nums)):
            j=target-i
            if (j in a_list):
                ij=nums1.index(j)
                return[i,ij]
      
class Solution:  官方答案
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

2. 两数相加 c++

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* l3=new ListNode(),*p3; //为了可以直接返回头节点，不用reverse
        p3=l3;
        int jinwei=0,sum=0;
        while(l1&&l2){
            sum=l1->val+l2->val+jinwei;
            jinwei=sum/10;
            
            l3->val=sum%10;
            l1=l1->next;
            l2=l2->next;
            if(l1||l2){                  //为了避免两个一样长多出一个node 的情况
                l3->next=new ListNode();
                l3=l3->next;
            }
            
        }
        ListNode* l4=l1?l1:l2;         //选出还有东西的链表
        if(l4){
        while(l4->next){
            sum=l4->val+jinwei;
            jinwei=sum/10;
            l3->val=sum%10;

            l4=l4->next;
            
            l3->next=new ListNode();
            l3=l3->next;
                       
            }
            sum=l4->val+jinwei;
            jinwei=sum/10;
            l3->val=sum%10;

        }
       
        if(jinwei)                    //最后进位
            l3->next=new ListNode(1);
        return p3;
    }
        
};

大佬答案：


class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        auto head = new ListNode(-1), now = head;
        int t = 0;
        while(l1 || l2 || t) {
            if(l1) t += l1->val, l1 = l1->next;
            if(l2) t += l2->val, l2 = l2->next;

            auto new_Node = new ListNode(t % 10);
            t /= 10;

            now->next = new_Node;
            now = new_Node;
        }
        if(t) {
            auto new_Node = new ListNode(t);
            now->next = new_Node;
        }
        return head->next;
    }
};

3最长unik子串滑动窗口+哈希

#include <vector>

using namespace std;

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> char_counter(256, 0);//总共256种字符 最长unik段为256
        int max_length = 0;
        int current_length = 0;
        int j = -1;
        int i = -1;
        while (++j < s.size()) {
            char_counter[s[j]] += 1; //转换成ascii码
            ++current_length;
            if (char_counter[s[j]] == 1) {
                if (current_length > max_length) {
                    max_length = current_length; //最大长度等于窗口长度
                }
            } else { //counter>1 字符重复过一次
                while (++i < j) { //左端缩进 左端指向重复字符
                    char_counter[s[i]] -= 1;
                    --current_length; //窗口缩小
                    if (s[i] == s[j]) {  //一轮滑动窗口到下一轮滑动窗口[abcd][efe]
                        break;
                    }
                }
            }
        }
        
        return max_length;
    }
};

python top1

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        max=0
        start=-1
        d={}
        for i in range(len(s)):
            if s[i] in d and d[s[i]]>start:
                start=d[s[i]]
                d[s[i]]=i
            else:
                d[s[i]]=i
                if i-start>max:
                    max=i-start
        return max

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        max_s = 0
        d = set()
        for i in range(len(s)):
            if i + max_s == len(s):
                break
            d.clear()
            for j in range(50000):
                if i + j == len(s):
                    break
                if d.__contains__(s[i + j]):
                    break
                else:
                    d.add(s[i + j])
            if len(d) > max_s:
                max_s = len(d)
        return max_s

me:

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:

        """
        :type s: str
        :rtype: int
        """

        suml=0
        maxl=0
        left=-1
        alphabet={}
        ls=len(s)
        if ls==0:
            return 0
        if ls==1:
            return 1
        for i in range(ls):
            alphabet[s[i]]=alphabet.get(s[i], 0)+1
            suml+=1
           
            if alphabet[s[i]]==1:
                if suml>maxl:
                    maxl=suml
                
                
            else:
                for j in range(left+1,i):
                    alphabet[s[j]]-=1 
                    suml-=1
                    
                    if(s[j]==s[i]):
                        left=j
                        
                        break
        return maxl

4 xx

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        num3=nums1+nums2
        num3.sort()
        l3=len(num3)
        if l3==0:
            return 0.0
        if l3==1:
            return num3[0]
        if l3%2==0:

            return float((num3[l3//2]+num3[l3//2-1]))/2
        else:
            return num3[l3//2]

5xxx

class Solution(object):
    def longestPalindrome(self, s):
        if not s or len(s) < 2:
            return s
        # 以left和right为起点，计算回文半径，由于while循环退出后left和right
        # 各多走了一步，所以在返回的总长度时要减去2
        def expand(s, left, right):
            while left >= 0 and right < len(s) and s[left] == s[right]:
                #限制左指针右指针在s的长度范围内且左右对称
                #则左右指针拓展一个
                left -= 1
                right += 1
            return (right - left - 2) // 2
        # 对原始字符串做处理，将abc变成#a#b#c#
        tmp = "#" + "#".join(list(s)) + "#"
        n = len(tmp)#总长
        start = 0
        maxLen = 0
        # right表示目前计算出的最右端范围，right和左边都是已探测过的
        right = 0
        # center最右端位置的中心对称点
        center = 0
        # p数组记录所有已探测过的回文半径，后面我们再计算i时，根据p[i_mirror]计算i
        p = [0] * n
        # 从左到右遍历处理过的字符串，求每个字符的回文半径
        for i in xrange(n):
            # 根据i和right的位置分为两种情况：
            # 1、i<=right利用已知的信息来计算i
            # 2、i>right，说明i的位置时未探测过的，只能用中心探测法
            if right >= i:
                # 减少不必要的探测，必须选择两者中的较小者作为左右探测起点
                #i到右边的距离，对称i的回文半径
                minArmLen = min(right - i, p[2 * center - i])
                p[i] = expand(tmp, i - minArmLen, i + minArmLen)
            else:
                # i落在right右边，是没被探测过的，只能用中心探测法
                p[i] = expand(tmp, i, i)
            # 大于right，说明可以更新最右端范围了，同时更新center    
            if i + p[i] > right:
                center = i
                right = i + p[i]
            # 找到了一个更长的回文半径，更新原始字符串的start位置    
            if p[i] > maxLen:
                start = (i - p[i]) // 2
                maxLen = p[i]
        # 根据start和maxLen，从原始字符串中截取一段返回
        return s[start : start + maxLen]

7

class Solution:
    low=['-', '2', '1', '4', '7', '4', '8', '3', '6', '4', '8']
    high=['2', '1', '4', '7', '4', '8', '3', '6', '4', '7']
    def reverse(self, x: int) -> int:
        ix=list(str(x))

        if not ix[0].isdigit():
            ix.reverse()
            ix.pop()
            ix.insert(0,'-')
            
        else:
            ix.reverse()
        #超出
        
        ix="".join(ix)
        if ix=='0':
            return 0
        if ix[0]=='-' and ix[1] == '0':
            ix1=ix[1:]
            ix1=ix1.lstrip('0')
            rx=eval('-'+ix1)
        elif ix[0]=='0':
            ix=ix.lstrip('0')
            rx=eval(ix)
        else:
            rx=eval(ix)
        if rx<-2147483648:
            return 0
        if rx>2147483647:
            return 0
        return rx

704

"""
二分查找思想：
对于有序列表
每次循环都只比较中间位置，而不需要遍历整个
并同时更新下一次循环需要比较的上下限
"""
class Solution:
    def search(self, nums, target):
        low, high = 0, len(nums) - 1
        while low <= high:
            mid = (high - low) // 2 + low
            #“//”是一个算术运算符，表示整数除法，它可以返回商的整数部分（向下取整）。
            
            num = nums[mid]
            if num == target:
                return mid
            elif num > target:
                high = mid - 1
            else:
                low = mid + 1
        return -1

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if target in nums:
            return nums.index(target)
        else:
            return -1


        # r=len(nums)-1
        # l=0
        # if nums[r] < target or nums[0]>target:
        #     return -1
    
        # while l<=r:
        #     mid=(l+r)//2
        #     if(target==nums[mid]):
        #         return mid
        #     elif nums[mid] < target:
        #         l = mid + 1
        #     else:
        #         r = mid - 1
        # return -1

248

248 分治扩展相等

266

class Solution(object):
    def canPermutePalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        ls=len(s)
        d={}
        ss=set(list(s))
        if ls%2 ==0:
            for i in ss:
                if s.count(i)%2!=0:
                    return False
            return True
        else:
            for i in ss:
                d[i]=s.count(i)%2
                
            a=0
            for j in d:
                a+=d[j]
            if a!=1:
                return False
            else:
                return True

class Solution(object):
    def canPermutePalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        char_dict = defaultdict(int)
        for char in s:
            char_dict[char] += 1
        res = 0
        for char in char_dict:
            if char_dict[char] % 2 == 1:
                res += 1
        return res < 2