LeetCode 29~35题

最新推荐文章于 2022-10-18 16:20:03 发布
最新推荐文章于 2022-10-18 16:20:03 发布
阅读量101 收藏
点赞数
分类专栏： 每日算法题目 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44169596/article/details/111662106
版权

第二十九题：

class Solution {
public:
    int divide(int x, int y) {
        typedef long long LL;
        vector<LL> exp;
        bool is_minus = false;
        if (x < 0 && y > 0 || x > 0 && y < 0) is_minus = true;

        LL a = abs((LL)x), b = abs((LL)y);
        for (LL i = b; i <= a; i = i + i) exp.push_back(i);

        LL res = 0;
        for (int i = exp.size() - 1; i >= 0; i -- )
            if (a >= exp[i]) {
                a -= exp[i];
                res += 1ll << i;
            }

        if (is_minus) res = -res;

        if (res > INT_MAX || res < INT_MIN) res = INT_MAX;

        return res;
    }
};


class Solution {
    public int divide(int dividend, int divisor) {
        boolean sign = (dividend > 0) ^ (divisor > 0);
        int result = 0;
        if(dividend>0) {
            dividend = -dividend;
        }
        if(divisor>0) divisor = -divisor;
        while(dividend <= divisor) {
            int temp_result = -1;
            int temp_divisor = divisor;
            while(dividend <= (temp_divisor << 1)) {
                if(temp_divisor <= (Integer.MIN_VALUE >> 1))break;
                temp_result = temp_result << 1;
                temp_divisor = temp_divisor << 1;
            }
            dividend = dividend - temp_divisor;
            result += temp_result;
        }
        if(!sign) {
            if(result <= Integer.MIN_VALUE) return Integer.MAX_VALUE;
            result = - result;
        }
        return result;
    }
}

# 方法1：递归
class Solution:
    def divide(self, dividend: int, divisor: int) -> int:
        MIN_INT, MAX_INT = -2147483648, 2147483647  # [−2**31, 2**31−1]
        flag = 1                                    # 存储正负号，并将分子分母转化为正数
        if dividend < 0: flag, dividend = -flag, -dividend
        if divisor < 0: flag, divisor  = -flag, -divisor 
        
        def div(dividend, divisor):                 # 例：1023 / 1 = 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 1
            if dividend < divisor:
                return 0
            cur = divisor
            multiple = 1
            while cur + cur < dividend:             # 用加法求出保证divisor * multiple <= dividend的最大multiple
                cur += cur                          # 即cur分别乘以1, 2, 4, 8, 16...2^n，即二进制搜索
                multiple += multiple
            return multiple + div(dividend - cur, divisor)
        res = div(dividend, divisor)

        res = res if flag > 0 else -res             # 恢复正负号
        
        if res < MIN_INT:                           # 根据是否溢出返回结果
            return MIN_INT
        elif MIN_INT <= res <= MAX_INT:
            return res
        else:
            return MAX_INT
        

# 方法2：迭代
class Solution:
    def divide(self, dividend: int, divisor: int) -> int:
        MIN_INT, MAX_INT = -2147483648, 2147483647  # [−2**31, 2**31−1]
        flag = 1                                    # 存储正负号，并将分子分母转化为正数
        if dividend < 0: flag, dividend = -flag, -dividend
        if divisor < 0: flag, divisor  = -flag, -divisor 
        
        res = 0
        while dividend >= divisor:                  # 例：1023 / 1 = 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 1
            cur = divisor
            multiple = 1
            while cur + cur < dividend:             # 用加法求出保证divisor * multiple <= dividend的最大multiple
                cur += cur                          # 即cur分别乘以1, 2, 4, 8, 16...2^n，即二进制搜索
                multiple += multiple
            dividend -= cur
            res += multiple
        
        res = res if flag > 0 else -res             # 恢复正负号
        
        if res < MIN_INT:                           # 根据是否溢出返回结果
            return MIN_INT
        elif MIN_INT <= res <= MAX_INT:
            return res
        else:
            return MAX_INT

func divide(dividend int, divisor int) int{
    positive := true
    if dividend < 0 {
        dividend = 0 - dividend
        positive = !positive
    }
    if divisor < 0 {
        divisor = 0 - divisor
        positive = !positive
    }
    if divisor > dividend {
        return 0
    }
    res, mul_divisor := 1, divisor
    for dividend > mul_divisor + mul_divisor {
        res += res
        mul_divisor += mul_divisor
    }
    res += divide(dividend - mul_divisor, divisor)
    if !positive {
        res = 0 - res
    }
    if res > 1<<31 - 1 || 0 - res > 1<<31 {
        return 1<<31 - 1
    }
    return res
}

第三十题：

struct QQ
{
    vector<int> vec;
    int index = 0;
    void push(int val)
    {
        vec.push_back(val);
    }
    int get()
    {
        int res = vec[index];
        index = (index + 1) % vec.size();
        return res;
    }
};
class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
    const int strSz = s.size(), wordSz = words[0].size(), n = words.size();
    if (strSz < wordSz)
    {
        return {};
    }
    int i, j, jl, matched, need;
    unordered_map<string_view, QQ> m;
    for (i = 0; i < n; ++i)
    {
        m[words[i]].push(i);
    }
    vector<int> store(n, 0);
    string_view ss(s);
    vector<int> res;
    for (i = 0; i < wordSz; ++i)
    {
        store.assign(n, 0);
        need = n;
        matched = 0;
        for (j = 0, jl = strSz / wordSz; j < jl - need + matched + 1; ++j)
        {
            auto itr = m.find(ss.substr(j * wordSz + i, wordSz));
            if (itr == m.end())
            {
                if (matched > 0)
                {
                    matched = 0;
                    need = n;
                    store.assign(n, 0);
                }
                continue;
            }
            int &k = store[itr->second.get()];
            ++matched;
            if (k > need - n)
            {
                need = n + k;
            }
            else if (matched == need)
            {
                ++need;
                res.push_back(i + wordSz * (j - n + 1));
            }
            k = matched;
        }
    }
    return res;
    }
};



class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> res;
        if (words.empty()) return res;
        int n = s.size(), m = words.size(), w = words[0].size();
        unordered_map<string, int> tot;
        for (auto& word : words) tot[word] ++ ;

        for (int i = 0; i < w; i ++ ) {
            unordered_map<string, int> wd;
            int cnt = 0;
            for (int j = i; j + w <= n; j += w) {
                if (j >= i + m * w) {
                    auto word = s.substr(j - m * w, w);
                    wd[word] -- ;
                    if (wd[word] < tot[word]) cnt -- ;
                }
                auto word = s.substr(j, w);
                wd[word] ++ ;
                if (wd[word] <= tot[word]) cnt ++ ;
                if (cnt == m) res.push_back(j - (m - 1) * w);
            }
        }

        return res;
    }
};

public List<Integer> findSubstring(String s, String[] words) {
    List<Integer> res = new ArrayList<Integer>();
    int wordNum = words.length;
    if (wordNum == 0) {
        return res;
    }
    int wordLen = words[0].length();
    HashMap<String, Integer> allWords = new HashMap<String, Integer>();
    for (String w : words) {
        int value = allWords.getOrDefault(w, 0);
        allWords.put(w, value + 1);
    }
    //将所有移动分成 wordLen 类情况
    for (int j = 0; j < wordLen; j++) {
        HashMap<String, Integer> hasWords = new HashMap<String, Integer>();
        int num = 0; //记录当前 HashMap2（这里的 hasWords 变量）中有多少个单词
		//每次移动一个单词长度
        for (int i = j; i < s.length() - wordNum * wordLen + 1; i = i + wordLen) {
            boolean hasRemoved = false; //防止情况三移除后，情况一继续移除
            while (num < wordNum) {
                String word = s.substring(i + num * wordLen, i + (num + 1) * wordLen);
                if (allWords.containsKey(word)) {
                    int value = hasWords.getOrDefault(word, 0);
                    hasWords.put(word, value + 1);
                    //出现情况三，遇到了符合的单词，但是次数超了
                    if (hasWords.get(word) > allWords.get(word)) {
                        // hasWords.put(word, value);
                        hasRemoved = true;
                        int removeNum = 0;
                        //一直移除单词，直到次数符合了
                        while (hasWords.get(word) > allWords.get(word)) {
                            String firstWord = s.substring(i + removeNum * wordLen, i + (removeNum + 1) * wordLen);
                            int v = hasWords.get(firstWord);
                            hasWords.put(firstWord, v - 1);
                            removeNum++;
                        }
                        num = num - removeNum + 1; //加 1 是因为我们把当前单词加入到了 HashMap 2 中
                        i = i + (removeNum - 1) * wordLen; //这里依旧是考虑到了最外层的 for 循环，看情况二的解释
                        break;
                    }
                //出现情况二，遇到了不匹配的单词，直接将 i 移动到该单词的后边（但其实这里
                //只是移动到了出现问题单词的地方，因为最外层有 for 循环， i 还会移动一个单词
                //然后刚好就移动到了单词后边）
                } else {
                    hasWords.clear();
                    i = i + num * wordLen;
                    num = 0;
                    break;
                }
                num++;
            }
            if (num == wordNum) {
                res.add(i);

            }
            //出现情况一，子串完全匹配，我们将上一个子串的第一个单词从 HashMap2 中移除
            if (num > 0 && !hasRemoved) {
                String firstWord = s.substring(i, i + wordLen);
                int v = hasWords.get(firstWord);
                hasWords.put(firstWord, v - 1);
                num = num - 1;
            }

        }

    }
    return res;
}

class Solution:
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        if not words:
            return []
        w_len, s_len = len(words[0]), len(s)
        t_len = w_len * len(words)  # 子串的长度

        word_dict = {}  # words的哈希表
        for word in words:
            word_dict[word] = word_dict.get(word, 0) + 1

        ans = []
        for offset in range(w_len):
            lo, lo_max = offset, s_len - t_len
            while lo <= lo_max:
                tmp_dict = word_dict.copy()
                match = True
                for hi in range(lo + t_len, lo, -w_len):    # 从尾到头搜索单词
                    word = s[hi - w_len: hi]
                    if word not in tmp_dict or tmp_dict.get(word, 0) == 0:
                        match = False
                        break   # 当前单词不符合要求 直接停止这个子串的搜索
                    tmp_dict[word] -= 1
                if match:
                    ans.append(lo)
                lo = hi     # 对lo直接赋值 这就是相比法二优化的地方
        return ans

func findSubstring(s string, words []string) []int {
    if len(words) < 1 { return []int{} }
    
    slen := len(s)
    wlen := len(words)
    k := len(words[0])
    if slen < k*wlen { return []int{} }

    var res []int
    var mp = make(map[string]int)
    for _, w := range words {
        mp[w]++
    }

    // 移动窗口减少重复检查单词，按单词长度取不同批次
    for i:=0; i<k; i++ {
        var count int
        var countermp = make(map[string]int)

        for l,r:=i,i; r<=slen-k; r=r+k {
            word := s[r:r+k]
            if num, found := mp[word]; found {
                // 如果计数器中单词数目超标，左移指针直至符合数目要求
                for countermp[word] >= num {
                    countermp[s[l:l+k]]--
                    count--
                    l+=k
                }
                countermp[word]++
                count++
                // fmt.Println(countermp, count)
            } else {
                // 如果当前单词不在词典里，左移指针至下一个单词，左移过程中清理计数
                for l<r {
                    countermp[s[l:l+k]]--
                    count--
                    l+=k
                }
                l+=k
            }
            if count == wlen {
                res = append(res, l)
            }
        }
    }

    return res
}

第三十一题：

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int k = nums.size() - 1;
        while (k > 0 && nums[k - 1] >= nums[k]) k -- ;
        if (k <= 0) {
            reverse(nums.begin(), nums.end());
        } else {
            int t = k;
            while (t < nums.size() && nums[t] > nums[k - 1]) t ++ ;
            swap(nums[t - 1], nums[k - 1]);
            reverse(nums.begin() + k, nums.end());
        }
    }
};

class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.length - 1;
            while (j >= 0 && nums[i] >= nums[j]) {
                j--;
            }
            swap(nums, i, j);
        }
        reverse(nums, i + 1);
    }

    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    public void reverse(int[] nums, int start) {
        int left = start, right = nums.length - 1;
        while (left < right) {
            swap(nums, left, right);
            left++;
            right--;
        }
    }
}

class Solution:
    def nextPermutation(self, nums: List[int]) -> None:
        i = len(nums) - 2
        while i >= 0 and nums[i] >= nums[i + 1]:
            i -= 1
        if i >= 0:
            j = len(nums) - 1
            while j >= 0 and nums[i] >= nums[j]:
                j -= 1
            nums[i], nums[j] = nums[j], nums[i]
        
        left, right = i + 1, len(nums) - 1
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1

func nextPermutation(nums []int) {
    n := len(nums)
    i := n - 2
    for i >= 0 && nums[i] >= nums[i+1] {
        i--
    }
    if i >= 0 {
        j := n - 1
        for j >= 0 && nums[i] >= nums[j] {
            j--
        }
        nums[i], nums[j] = nums[j], nums[i]
    }
    reverse(nums[i+1:])
}

func reverse(a []int) {
    for i, n := 0, len(a); i < n/2; i++ {
        a[i], a[n-1-i] = a[n-1-i], a[i]
    }
}

第三十二题：

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> stk;
        int res = 0;
        for (int i = 0, start = -1; i < s.size(); i ++ ) {
            if (s[i] == '(') stk.push(i);
            else {
                if (stk.size()) {
                    stk.pop();
                    if (stk.size()) {
                        res = max(res, i - stk.top());
                    } else {
                        res = max(res, i - start);
                    }
                } else {
                    start = i;
                }
            }
        }

        return res;
    }
};

public class Solution {
    public int longestValidParentheses(String s) {
        int maxans = 0;
        Deque<Integer> stack = new LinkedList<Integer>();
        stack.push(-1);
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                stack.push(i);
            } else {
                stack.pop();
                if (stack.empty()) {
                    stack.push(i);
                } else {
                    maxans = Math.max(maxans, i - stack.peek());
                }
            }
        }
        return maxans;
    }
}

func longestValidParentheses(s string) int {
    maxAns := 0
    stack := []int{}
    stack = append(stack, -1)
    for i := 0; i < len(s); i++ {
        if s[i] == '(' {
            stack = append(stack, i)
        } else {
            stack = stack[:len(stack)-1]
            if len(stack) == 0 {
                stack = append(stack, i)
            } else {
                maxAns = max(maxAns, i - stack[len(stack)-1])
            }
        }
    }
    return maxAns
}

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        if not s: return 0

        stack = []
        ans = 0
        for i in range(len(s)):
            # 入栈条件
            if not stack or s[i] == '(' or s[stack[-1]] == ')':
                stack.append(i)     # 下标入栈
            else:
                # 计算结果
                stack.pop()
                ans = max(ans, i - (stack[-1] if stack else -1))
        return ans

第三十三题：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.empty()) return -1;
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (nums[mid] >= nums[0]) l = mid;
            else r = mid - 1;
        }

        if (target >= nums[0]) l = 0;
        else l = r + 1, r = nums.size() - 1;

        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }

        if (nums[r] == target) return r;
        return -1;
    }
};

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) {
            return -1;
        }
        if (n == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[0] <= nums[mid]) {
                if (nums[0] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
}

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return -1
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = (l + r) // 2
            if nums[mid] == target:
                return mid
            if nums[0] <= nums[mid]:
                if nums[0] <= target < nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            else:
                if nums[mid] < target <= nums[len(nums) - 1]:
                    l = mid + 1
                else:
                    r = mid - 1
        return -1

func search(nums []int, target int) int {
    low,high:=0,len(nums)-1
    for low < high - 1{
        mid:=(high+low)/2
        a,b,c:=nums[low],nums[mid],nums[high]
        if b == target{
            return mid
        }
        switch {
            // 上面两个case在递增序列找同二分查找
            case target>=a && target<=b:
                high = mid
            case target>=b && target<=c:
                low = mid
            // 如果在递增的区间没有找到
            // 那么只可能在递减的区间中
            // 由于是旋转数组，只可能有一个递减区间
            case a>b:
                high = mid
            case b>c:
                low  = mid
            default:
                return -1
        }
    }
    if nums[low] == target{
        return low
    }
    if nums[high] == target{
        return high
    }
    return -1
}

第三十四题：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if (nums.empty()) return {-1, -1};
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if (nums[r] != target) return {-1, -1};
        int L = r;
        l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (nums[mid] <= target) l = mid;
            else r = mid - 1;
        }

        return {L, r};
    }
};

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
            return new int[]{leftIdx, rightIdx};
        } 
        return new int[]{-1, -1};
    }

    public int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

func searchRange(nums []int, target int) []int {
    leftmost := sort.SearchInts(nums, target)
    if leftmost == len(nums) || nums[leftmost] != target {
        return []int{-1, -1}
    }
    rightmost := sort.SearchInts(nums, target + 1) - 1
    return []int{leftmost, rightmost}
}

from typing import List


class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        size = len(nums)
        if size == 0:
            return [-1, -1]

        first_position = self.__find_first_position(nums, size, target)
        if first_position == -1:
            return [-1, -1]
        last_position = self.__find_last_position(nums, size, target)
        return [first_position, last_position]

    def __find_first_position(self, nums, size, target):
        left = 0
        right = size - 1
        while left < right:
            mid = (left + right) // 2
            if nums[mid] < target:
                left = mid + 1
            elif nums[mid] == target:
                right = mid
            else:
                # nums[mid] > target
                right = mid - 1

        if nums[left] == target:
            return left
        else:
            return -1

    def __find_last_position(self, nums, size, target):
        left = 0
        right = size - 1
        while left < right:
            mid = (left + right + 1) // 2
            if nums[mid] > target:
                right = mid - 1
            elif nums[mid] == target:
                left = mid
            else:
                # nums[mid] < target
                left = mid + 1

        # 由于能走到这里，说明在数组中一定找得到目标元素，因此这里不用再做一次判断
        return left

第三十五题：

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int l = 0, r = nums.size();
        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        return l;
    }
};

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0, right = n - 1, ans = n;
        while (left <= right) {
            int mid = ((right - left) >> 1) + left;
            if (target <= nums[mid]) {
                ans = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

func searchInsert(nums []int, target int) int {
    n := len(nums)
    left, right := 0, n - 1
    ans := n
    for left <= right {
        mid := (right - left) >> 1 + left
        if target <= nums[mid] {
            ans = mid
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return ans
}

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left,right=0,len(nums)
        while left<right:
            mid=left+(right-left)//2
            if nums[mid]<target:
                left = mid+1
            else:
                right = mid
        return left
不能say的秘密
关注
专栏目录
LeetCode面试经典150题
m0_74376876的博客
07-11 1036
LeetCode面试经典150题喵
leetcode题库-leetcode:leetcode
06-29
leetcode题库 :pencil: 使用 Python、Javascript、Python3 的 Leetcode 解决方案 ...29 中等的 30 难的 31 中等的 32 难的 33 中等的 34 中等的 35 简单的 36 中等的 37 难的 38 简单的 39 中等的 40
LeetCode腾讯精选练习（Python）-1
x___xxxx的博客
02-25 270
参考资料： Datawhale资料
Python 整型 溢出
zxc_1018的博客
10-07 610
int_boundary = (1 << 31) - 1 if x > 0 else 1 << 31 int 型的数值范围在[-2^31,2^31-1] 可用于判断在运算过程中数值是否溢出。
for (const string& word: words)
小吕的博客
03-29 2444
vector<string> &strs; for (const auto &s : strs){ // } It's actually a C++11 feature called "range-based for-loops". 近似等价于： // Let's assume this vector is not empty. vector&...
March——7.整数反转
奥古斯都
03-29 153
class Solution: def reverse(self, x: int) -> int: #取整的原因是因为 由于Python的 // 操作是向下取整，导致正负数取余 % 操作结果不一致，因此需要将原数字转为正数操作。 #将每一位进行拆分，然后再进行组合 y, res = abs(x), 0 boundry = (1<<31) -1 if x>0 else 1<<31 ...
leetcode 29 ~ 39
weixin_41332009的博客
04-15 190
Leetcode 29 ⭐⭐ 题目描述 Given two integers dividend and divisor, divide two integers without using multiplication, division, and mod operator. Return the quotient after dividing dividend by divisor. The integer division should truncate toward zero, which means
LeetCode21~40题——NWU_LK
NWU_LK的博客
08-12 130
LeetCode第21题 合并两个有序链表 public class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } class Solution {
LeetCode 21~40
yake1965
10-29 133
21. 合并两个有序链表 22. 括号生成 23. 合并K个升序链表 24. 两两交换链表中的节点 25. K 个一组翻转链表 26. 删除有序数组中的重复项 27. 移除元素 28. 实现 strStr() 29. 两数相除 30. 串联所有单词的子串 31. 下一个排列 32. 最长有效括号 33. 搜索旋转排序数组 34. 在排序数组中查找元素的第一个和最后一个位置 35. 搜索插入位置 36. 有效的数独 37. 解数独 38. 外观数列 39. 组合总和 40. 组合总和 II
LeetCode算法题整理(200题左右)
最新发布
qq_38253797的博客
10-18 1万+
Leetcode
leetCode每日一题（每日更新）
qq_41256473的博客
08-06 603
leetCode每日一题：自我理解
gasstationleetcode-leetcode:简单纪录每日一题
06-30
gas station leetcode 非官方顺序leetcode题解，主要代码为Python和C++。 leetcode 第1题： leetcode 第2题： leetcode ...leetcode ...leetcode ...leetcode ...第35题： leetcode 第36题： leetcode 第37题： leet
Leetcode 448~454题
weixin_44169596的博客
03-26 1288
第四百四十八题: class Solution { public: vector<int> findDisappearedNumbers(vector<int>& nums) { for (auto x: nums) { x = abs(x); if (nums[x - 1] > 0) nums[x - 1] *= -1; } vector<int> re
LeetCode 1~7题
weixin_44169596的博客
12-21 283
第一题： class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { unordered_map<int,int> hash; for(int i=0;i<nums.size();i++) { if(hash.count(target-nums[i])) return {hash[tar
Leetcode 462~470题
weixin_44169596的博客
04-01 239
第四百六十二题： class Solution { public: int minMoves2(vector<int>& nums) { int n = nums.size(); sort(nums.begin(), nums.end()); int res = 0; for (int i = 0; i < n; i ++ ) res += abs(nums[i] - nums[n /
LeetCode 347～357题
weixin_44169596的博客
02-21 214
第三百四十七题： class Solution { public: vector<int> topKFrequent(vector<int>& nums, int k) { unordered_map<int, int> cnt; for (auto x: nums) cnt[x] ++ ; int n = nums.size(); vector<int> s(n + 1);
LeetCode 363~373题
weixin_44169596的博客
02-24 207
第三百六十三题 class Solution { public: vector<vector<int>> s; int get(int x1, int y1, int x2, int y2) { return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]; } int maxSumSubmatrix(vector<vector<int>&g
LeetCode 309~318题
weixin_44169596的博客
02-16 194
第三百零九题： class Solution { public: int maxProfit(vector<int>& prices) { if (prices.empty()) return 0; int n = prices.size(), INF = 1e8; vector<vector<int>> f(n, vector<int>(3, -INF)); f[0][1] =
LeetCode168~179t题：
weixin_44169596的博客
01-22 177
第一百六十八题： class Solution { public: string convertToTitle(int n) { int k = 1; for (long long p = 26; n > p; p *= 26) { n -= p; k ++ ; } n -- ; string res; while (k -- ) {
Java解码LeetCode经典50题面试指南
本资源是一份针对LeetCode经典50题的Java版本解题指南，旨在帮助求职者提升在IT面试中的竞争力。它涵盖了数组、字符串、数学、链表和二叉树等多个核心数据结构和算法领域。以下是部分题目及其知识点的详细解读： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不能say的秘密

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值