leetcode练习（简单总结做过的题）

最新推荐文章于 2022-01-13 16:53:35 发布
最新推荐文章于 2022-01-13 16:53:35 发布
阅读量413 收藏
点赞数
分类专栏： leetcode练习记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhmonkey/article/details/107984177
版权

文章目录

leetcode（简单总结做过的题）

题目来源：力扣（LeetCode）

两数之和：简单

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

题解：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){//nums的第一个值会存入map 
                return new int[]{map.get(temp),i};//将两个索引值返回
            }
            map.put(nums[i],i); //将数与索引值一起存入map
        }
        return new int[]{-1,-1};
    }
}    

    //     for(int i=0;i<nums.length;i++){
    //         for(int j=i+1;j<nums.length;j++){
    //             if(nums[i]==target-nums[j]){
    //                 return new int[]{i,j};
    //             }
    //         }
    //     }
    //     throw new IllegalArgumentException("No two sum solution");
    // }

整数反转：简单

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321
示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21
注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

题解：

class Solution {
    public int reverse(int x) {
        long y=0;
        while(x != 0){
            y = x%10 + y*10;
            x=x/10;
        }
        return (int)y==y?(int)y:0;//要考虑是否溢出
    }
}

回文数：简单

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true
示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:

你能不将整数转为字符串来解决这个问题吗？

题解：（1）

class Solution {
    public boolean isPalindrome(int x) {
        if(x<0){
            return false;
        }
        String s = Integer.toString(x); //转换成字符串
        String sf =new StringBuilder(s).reverse().toString(); //将字符串反转
        if(sf.equals(s)){
            return true;
        }
        return false;
    }
}

题解：（2）

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0)) { //当x为负数或x为10的倍数时，x不是回文数
            return false;
        }

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
      
     //当x是偶数位时，x==revertedNumber，例如1221；当x是奇数位时，x == revertedNumber / 10，例如121
        return x == revertedNumber || x == revertedNumber / 10;
    }
}

罗马数字转整数：简单

罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”
输出: 3
示例 2:

输入: “IV”
输出: 4
示例 3:

输入: “IX”
输出: 9
示例 4:

输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题解：

class Solution {
    public int romanToInt(String s) {
        int sum=0;
        int pre = getValue(s.charAt(0));
        for(int i=1;i<s.length();i++){
            int back = getValue(s.charAt(i));
            if(pre < back){ //小于情况例如：IV，则需要减去I
                sum-=pre;
            }else{
                sum+=pre;  //III
            }
            pre = back;
        }
        sum+=pre;
        return sum;
    }
    private int getValue(char c){
        switch(c){
            case 'I': return 1;
            case 'V': return 5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: return 0;
        }
    }
}

最长公共前缀：简单

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:

输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

题解：

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs == null || strs.length == 0){ //若为空则返回空字符串
            return "";
        }
        String prefix = strs[0];
        for(int i=1;i<strs.length;++i){
            prefix = CompareStrings(prefix,strs[i]);
            if(prefix.length() == 0){
                break;//只要其中两个没有公共的，则退出循环
            }
        }
        return prefix;
    }

    private String CompareStrings(String a,String b){
        int len = Math.min(a.length(),b.length());//取短的那个字符串的长度
        int i=0;
        while(i<len && a.charAt(i)==b.charAt(i)){ //比较两个字符串的字符
            i++;
        }
        return a.substring(0,i);//截取公共前缀
    }
}

有效的括号：简单

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()”
输出: true
示例 2:

输入: “()[]{}”
输出: true
示例 3:

输入: “(]”
输出: false
示例 4:

输入: “([)]”
输出: false
示例 5:

输入: “{[]}”
输出: true

题解：

class Solution {
    private Map<Character,Character> map;

    public Solution(){ //初始化map
        this.map = new HashMap<Character,Character>();
        this.map.put(')','(');
        this.map.put(']','[');
        this.map.put('}','{');
    }

    public boolean isValid(String s) {
        if(s.length() % 2 != 0){
            return false;
        }

        Stack<Character> stack = new Stack<Character>();//new一个字符串栈（先进后出）
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            
            if(this.map.containsKey(c)){ // ( {不是key，所以进栈    } )是key，所以进行下一步

                char ck = stack.empty() ? '#':stack.pop();//按顺序出栈 { (
                if(ck != this.map.get(c)){ //若不匹配则为false
                    return false;
                }
            }else{
                stack.push(c); // ( {
            }
        }
        return stack.isEmpty();
    }
}

合并两个有序的链表：简单

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

题解：

/**
 * Definition for singly-linked list.
 * 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 {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode p=l1,q=l2;
        if(p==null){
            return q;
        }
        if(q==null){
            return p;
        }
        if(p.val < q.val){
            p.next = mergeTwoLists(p.next,q);  //递归思想，一开始没想到！
            return p;
        }else{
            q.next = mergeTwoLists(p,q.next);
            return q;
        }
    }
}

删除排序数组中的重复项：简单

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

题解：

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        int len=0;
        for(int i=1;i<nums.length;i++){
            if(nums[i] != nums[len]){ //只有不相等的时候才把后面的元素一一放到指定的下一个位置
                len++;
                nums[len]=nums[i];
            }
        }
        return len+1;
    }
}

移除元素：简单

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

题解：

class Solution {
    public int removeElement(int[] nums, int val) {
        int len = 0;
        for(int i=0;i<nums.length;++i){
            if(nums[i] != val){
                nums[len] = nums[i];  //跟上一题的思路相同
                len++;
            }
        }
        return len;
    }
}

实现strStr()函数：简单

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:

输入: haystack = “aaaaa”, needle = “bba”
输出: -1
说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

题解：（1）

class Solution {
    public int strStr(String haystack, String needle) {
        int len1 = haystack.length(),len2 = needle.length();
        for(int i=0;i<len1-len2+1;i++){
            if(haystack.substring(i,i+len2).equals(needle)){ //通过截取字符串来比较substring
                return i;
            }
        }
        return -1;
    }
}

题解：（2）

class Solution {
    public int strStr(String haystack, String needle) {
        int len1 = haystack.length(),len2 = needle.length();
        if(len2 == 0){
            return 0;
        }
        for(int i=0;i<len1-len2+1;i++){
            if(haystack.charAt(i) == needle.charAt(0)){
                if(haystack.substring(i,i+len2).equals(needle)){
                    return i;
                }
            }
        }
        return -1; 
    }
}

//参考的javascript解法：(见下)
var strStr = function (haystack, needle) {
    if (needle === "") return 0
    for (var i = 0; i < haystack.length; i++) {
        if (haystack[i] === needle[0]) {
            if (haystack.substring(i, i + needle.length) === needle) return i;
        }
    }
    return -1
};

搜索插入位置：简单

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: [1,3,5,6], 5
输出: 2
示例 2:

输入: [1,3,5,6], 2
输出: 1
示例 3:

输入: [1,3,5,6], 7
输出: 4
示例 4:

输入: [1,3,5,6], 0
输出: 0

题解：

class Solution {
    public int searchInsert(int[] nums, int target) {
        //二分法查找
         int len = nums.length;
         if(len == 0){
             return 0;
         }

         if(nums[len - 1] < target){
             return len;
         }

         int left=0;
         int right=len-1;
         while(left < right){
             int middle=left+(right-left)/2; //中间指针
             if(nums[middle] < target){
                 // 下一轮搜索区间是 [mid + 1, right]
                 left = middle+1;
             }else{
                 // 下一轮搜索区间是 [left, mid]
                 right = middle;
             }
         }
         return left;
         
    }
}

两数相加：中等

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

题解：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head=new ListNode(0);//输出的链表头
        ListNode p=l1,q=l2,cur=head;
        int a=0; //进位的数记录
        while(p!=null || q!=null){
            int x=(p!=null)?p.val:0;
            int y=(q!=null)?q.val:0;
            int s=a+x+y;
            a=s/10;
            cur.next = new ListNode(s%10);
            cur=cur.next;
            if(p!=null) p=p.next;
            if(q!=null) q=q.next;
        }
        if(a>0){ //若最后还有进位，则a=1
            cur.next=new ListNode(a);
        }
        return head.next;//head->7->0->8
       
    }
}

无重复字符的最长字串：中等

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

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

题解：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Set<Character> son = new HashSet<Character>();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int point = -1,len = 0;
        for(int i=0;i<s.length();++i){
            if(i!=0){
                // 左指针向右移动一格，移除一个字符
                son.remove(s.charAt(i-1));
            }
            while(point+1<s.length() && !son.contains(s.charAt(point+1))){
                 // 不断地移动右指针(向右)
                son.add(s.charAt(point+1));
                ++point;
            }
            len = Math.max(len,point-i+1);//取最大的长度
        }
        return len;
    }
}
monkeyhlj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题分类练习
yao09605的博客
05-20 397
文章目录(一)分治法(二)动态规划法(三)贪心法(四)回溯法 文字转载：https://baijiahao.baidu.com/s?id=1660742044135451900&wfr=spider&for=pc (一)分治法 适用特征：该问题的规模缩小到一定的程度就可以容易地解决；可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；利用该问题分解出的子问题的解可以合并为该问题的解；所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。 典型代表：二分搜索、棋盘覆盖
2.1_链表基本练习题.CPP
10-28
从键盘输入一组整型元素序列，建立链表。要求输入元素递增，如果不递增提示重新输入刚才错误的数据。 实现该链表的遍历。 在该链表中进行顺序查找某一元素,查找成功返回1,否则返回0。 把元素x插入递增有序表中，仍保持有序性。 把递增的链表扩大成2倍大小，把链表变成前后对称的链表。
Leetcode刷题简短总结
wangcaimeng的博客
03-07 401
说明 一句话简短的总结，用于自己复习回顾，详细解法非常推荐 https://github.com/MisterBooo/LeetCodeAnimation 1.两数之和 简单 HashSet， 一次遍历 O(n) 2.两数相加 中等 数字由链表从低位到高位表示，按位做加法进位即可 3.无重复的最长子串 中等 滑动窗口+HashSet 5.最长回文串 中等 暴力法O(n^3) 反转+最长公共子串 D...
leetcode 给我上了深深的一课，被删掉所有题解后的我感动了
Google大神
04-10 2496
常在河边走，哪有不湿鞋。我是小浩算法公众号的号主，昨天发生了一件非常悲催的事情。我在leetcode上的所有算法题解（五六十篇肯定是有的）都被删除了。可惜之前我没有截图，现在进到页面里...
leetcode练习过的题目总结
喜欢打篮球的普通人
06-29 264
栈 难度：简单 链接 20 有效的括号 20 有效的括号 20 有效的括号 20 有效的括号
leetcode题库-LeetCode:leetcodepython题库
06-29
- **分类与标签**：LeetCode题目按照难度分为简单、中等和困难，同时也按照主题进行分类，如二分查找、链表操作等。 - **提交与测试**：用户可以在线编写和提交代码，LeetCode会自动运行测试用例来验证解决方案的...
leetcode题库-LeetCode:LeetCode题库
06-29
有效的LeetCode学习策略通常包括先从基础的数据结构和简单算法开始，然后逐步挑战更复杂的题目。定期复习和归纳总结解题思路也是很重要的。 **社区互动** LeetCode有一个活跃的社区，用户可以在讨论区分享解决方案...
leetcode和codewar-leetcode:leetcode练习
07-07
1. 题目分类：LeetCode的题目按照难度分为简单、中等和困难三个级别，方便不同层次的学习者选择合适的题目进行挑战。 2. 编辑器与提交：LeetCode内置了一个简洁的在线编辑器，用户可以直接在网页上编写和测试代码，...
leetcode答案-Leetcode:做题记录和一些看到的答案
06-30
LeetCode 是一个在线平台，专注于提供编程练习题，旨在帮助开发者提升算法技能和解决实际问题的能力。这个压缩包“Leetcode答案-Leetcode:做题记录和一些看到的答案”很可能包含了用户在解决LeetCode题目过程中积累...
leetcode第四题-LeetCode_Exercise:力扣_练习
07-01
结束了一些位操作和位掩码练习，难度由低到高总结了几道非常讲的位运算和位掩码题，难度由低到高 （简单的） （简单的） （强烈推荐） （中等的） （中）（强烈推荐） （中）（强烈推荐，即使你能想到每个元素出现4...
计算机考研408每日一题 day63
漫磋嗟
10-09 1118
将两个长度分别为len1和len2的升序链表，合并为一个长度为len1+len2的降序列表，釆用归并算法，在最坏情况下，比较操作的次数与___最接近。（中国科学院大学 2015年） 采用8种相位，每种相位各有两种幅度的QAM调制方法，在1200Baud的信号传输速率下能达到的数据传输速率为___ 。（北京航空航天大学 2006年） 下列选项中，导致创建新进程的操作是___ 。（中国科学院大学 2018年） 1）管理员启动Web服务 2）用户启动浏览器程序 3）浏览器访问新的网页 设相对寻址的转移指令占2个字
JAVA数据结构：HashMap
qq_39392014的博客
06-11 1198
HashMap的结构：结合数组和链表的结构，在数组中存储链表，链表的节点中存储键值对。这样的结构结合了数组高效访问的优势和链表高效增删的优势。（数组和链表是所有数据结构的祖宗）
给定两个逆序非空链表，求链表中两数相加的和,且仍返回逆序链表
j086924的专栏
01-13 306
1.问题描述 给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。 2.示例输出，eg: 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 3.算法demo，此处以java实现 1).递归思路 class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l...
剑指offer 题目及答案
惯看秋风的博客
11-07 2227
1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 两种思路 一种是： 把每一行看成有序递增的数组， 利用二分查找， 通过遍历每一行得到答案， 时间复杂度是nlogn public class Solution { public boolean ...
Java 集合深入理解（16）：HashMap 主要特点和关键方法源码解读
热门推荐
张拭心的博客 shixinzhang
11-26 2万+
>点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 前面我们介绍了 哈希相关概念：哈希 哈希函数 冲突解决 哈希表，这篇文章我们来根据 JDK 1.8 源码，深入了解下使用频率很高的 HashMap 。 读完本文你将了解到： 点击查看 Java 集合框架深入理解 系列 - - 乾杯 什么是 HashMap HashMap 的特点 HashMap 的 13 个成
升序链表合并为降序链表的复杂度问题分析
小胡同的诗
07-27 1万+
题目： 链接：https://www.nowcoder.com/questionTerminal/47d9d6dce7f140a5a2654fb852f118c8?toCommentId=379084 来源：nowcoder一位大连理工的老师的评论 解析： 这道题答案个人觉得应该为D。虽然确实比较次数最多是m+n次。 1.贡献时间复杂度的不是“移动”次数，而是“比较”，如果从“移动”的角度上考虑...
Python编程题
TSY_1222的博客
06-09 2万+
1、输入直角三角形的两个直角边的长度a、b，求斜边c的长度 from math import sqrt # 从math库中导入sqrt方法 a = eval(input('输入直角边a的长度：')) b = eval(input('输入直角边b的长度：')) c = sqrt(a*a+b*b) print('斜边c的长度为：%d'%c) # 运行结果 ''' 输入直角边a的长度：6 输入...
数据结构代码.docx
10-31
&A, const vector<vector<int>> &B, vector<vector<int>> &C) { 2. int n = A.size(); 3. int m = B[0].size...通过LeetCode、秋招笔试和牛客网的学习过程，不断提高自己的编程水平，成为一名优秀的程序员。".

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值