LeetCode 每日一题 Day 102-108

最新推荐文章于 2024-06-14 15:54:07 发布
最新推荐文章于 2024-06-14 15:54:07 发布
阅读量832 收藏 27
点赞数 21
分类专栏： LeetCode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73814009/article/details/136851844
版权

2864. 最大二进制奇数

给你一个 二进制 字符串 s ，其中至少包含一个 ‘1’ 。

你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。

以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。

注意 返回的结果字符串 可以 含前导零。

示例 1：

输入：s = “010”
输出：“001”
解释：因为字符串 s 中仅有一个 ‘1’ ，其必须出现在最后一位上。所以答案是 “001” 。
示例 2：

输入：s = “0101”
输出：“1001”
解释：其中一个 ‘1’ 必须出现在最后一位上。而由剩下的数字可以生产的最大数字是 “100” 。所以答案是 “1001” 。

提示：

1 <= s.length <= 100
s 仅由 ‘0’ 和 ‘1’ 组成
s 中至少包含一个 ‘1’

菜鸡wa了两发，看了灵神题解：

class Solution {
public:
    string maximumOddBinaryNumber(string s) {
        int cnt = count(s.begin(), s.end(), '1');
        return string(cnt - 1, '1') + string(s.length() - cnt, '0') + '1';
    }
};

题解：贪心（每个语言都只需要两行！）

2789. 合并后数组中的最大元素

给你一个下标从 0 开始、由正整数组成的数组 nums 。

你可以在数组上执行下述操作 任意 次：

选中一个同时满足 0 <= i < nums.length - 1 和 nums[i] <= nums[i + 1] 的整数 i 。将元素 nums[i + 1] 替换为 nums[i] + nums[i + 1] ，并从数组中删除元素 nums[i] 。
返回你可以从最终数组中获得的 最大 元素的值。

示例 1：

输入：nums = [2,3,7,9,3]
输出：21
解释：我们可以在数组上执行下述操作：

  • 选中 i = 0 ，得到数组 nums = [5,7,9,3] 。
  • 选中 i = 1 ，得到数组 nums = [5,16,3] 。
  • 选中 i = 0 ，得到数组 nums = [21,3] 。
    最终数组中的最大元素是 21 。可以证明我们无法获得更大的元素。
    示例 2：

输入：nums = [5,3,3]
输出：11
解释：我们可以在数组上执行下述操作：

  • 选中 i = 1 ，得到数组 nums = [5,6] 。
  • 选中 i = 0 ，得到数组 nums = [11] 。
    最终数组中只有一个元素，即 11 。

提示：

1 <= nums.length <= 1e5
1 <= nums[i] <= 1e6

暴力枚举能过：

class Solution {
public:
    long long maxArrayValue(vector<int>& nums) {
        long long sum = nums.back();
        for (int i = nums.size() - 2; i >= 0; i--) {
            sum = nums[i] <= sum ? sum + nums[i] : nums[i];
        }
        return sum;
    }
};

2312. 卖木头块(Hard)

给你两个整数 m 和 n ，分别表示一块矩形木块的高和宽。同时给你一个二维整数数组 prices ，其中 prices[i] = [hi, wi, pricei] 表示你可以以 pricei 元的价格卖一块高为 hi 宽为 wi 的矩形木块。

每一次操作中，你必须按下述方式之一执行切割操作，以得到两块更小的矩形木块：

沿垂直方向按高度 完全 切割木块，或
沿水平方向按宽度 完全 切割木块
在将一块木块切成若干小木块后，你可以根据 prices 卖木块。你可以卖多块同样尺寸的木块。你不需要将所有小木块都卖出去。你 不能 旋转切好后木块来交换它的高度值和宽度值。

请你返回切割一块大小为 m x n 的木块后，能得到的 最多 钱数。

注意你可以切割木块任意次。

示例 1：

在这里插入图片描述

输入：m = 3, n = 5, prices = [[1,4,2],[2,2,7],[2,1,3]]
输出：19
解释：上图展示了一个可行的方案。包括：

  • 2 块 2 x 2 的小木块，售出 2 * 7 = 14 元。
  • 1 块 2 x 1 的小木块，售出 1 * 3 = 3 元。
  • 1 块 1 x 4 的小木块，售出 1 * 2 = 2 元。
    总共售出 14 + 3 + 2 = 19 元。
    19 元是最多能得到的钱数。
    示例 2：

在这里插入图片描述

输入：m = 4, n = 6, prices = [[3,2,10],[1,4,2],[4,1,3]]
输出：32
解释：上图展示了一个可行的方案。包括：

  • 3 块 3 x 2 的小木块，售出 3 * 10 = 30 元。
  • 1 块 1 x 4 的小木块，售出 1 * 2 = 2 元。
    总共售出 30 + 2 = 32 元。
    32 元是最多能得到的钱数。
    注意我们不能旋转 1 x 4 的木块来得到 4 x 1 的木块。

提示：

1 <= m, n <= 200
1 <= prices.length <= 2 * 1e4
prices[i].length == 3
1 <= hi <= m
1 <= wi <= n
1 <= pricei <= 1e6
所有 (hi, wi) 互不相同 。

菜鸡不会hard，参考灵神题解：

class Solution {
public:
    long long sellingWood(int m, int n, vector<vector<int>> &prices) {
        vector<vector<long long>> f(m + 1, vector<long long>(n + 1));
        for (auto &p : prices) {
            f[p[0]][p[1]] = p[2];
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                for (int k = 1; k <= j / 2; k++) f[i][j] = max(f[i][j], f[i][k] + f[i][j - k]); // 垂直切割
                for (int k = 1; k <= i / 2; k++) f[i][j] = max(f[i][j], f[k][j] + f[i - k][j]); // 水平切割
            }
        }
        return f[m][n];
    }
};

题解：动态规划：枚举切割位置+循环优化

2684. 矩阵中移动的最大次数

给你一个下标从 0 开始、大小为 m x n 的矩阵 grid ，矩阵由若干 正 整数组成。

你可以从矩阵第一列中的 任一 单元格出发，按以下方式遍历 grid ：

从单元格 (row, col) 可以移动到 (row - 1, col + 1)、(row, col + 1) 和 (row + 1, col + 1) 三个单元格中任一满足值 严格 大于当前单元格的单元格。
返回你在矩阵中能够 移动 的 最大 次数。

示例 1：
在这里插入图片描述

输入：grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]
输出：3
解释：可以从单元格 (0, 0) 开始并且按下面的路径移动：

  • (0, 0) -> (0, 1).
  • (0, 1) -> (1, 2).
  • (1, 2) -> (2, 3).
    可以证明这是能够移动的最大次数。
    示例 2：

在这里插入图片描述

输入：grid = [[3,2,4],[2,1,9],[1,1,7]]
输出：0
解释：从第一列的任一单元格开始都无法移动。

提示：

m == grid.length
n == grid[i].length
2 <= m, n <= 1000
4 <= m * n <= 1e5
1 <= grid[i][j] <= 1e6

DFS或BFS都可做：

class Solution {
public:
    int maxMoves(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        int ans = 0;
        function<void(int, int)> dfs = [&](int i, int j) {
            ans = max(ans, j);
            if (ans == n - 1) {
                return;
            }
            for (int k = max(i - 1, 0); k < min(i + 2, m); k++) {
                if (grid[k][j + 1] > grid[i][j]) {
                    dfs(k, j + 1);
                }
            }
            grid[i][j] = 0;
        };
        for (int i = 0; i < m; i++) {
            dfs(i, 0);
        }
        return ans;
    }
};

BFS方法(灵神）：

class Solution {
public:
    int maxMoves(vector<vector<int>> &grid) {
        int m = grid.size(), n = grid[0].size();
        vector<int> vis(m, -1), q(m);
        iota(q.begin(), q.end(), 0);
        for (int j = 0; j < n - 1; j++) {
            vector<int> nxt;
            for (int i : q) {
                for (int k = max(i - 1, 0); k < min(i + 2, m); k++) {
                    if (vis[k] != j && grid[k][j + 1] > grid[i][j]) {
                        vis[k] = j; // 第 k 行目前最右访问到了 j
                        nxt.push_back(k);
                    }
                }
            }
            if (nxt.empty()) { // 无法再往右走了
                return j;
            }
            q = move(nxt);
        }
        return n - 1;
    }
};

310. 最小高度树

树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，任何一个没有简单环路的连通图都是一棵树。

给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。

可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称为 最小高度树 。

请你找到所有的 最小高度树 并按 任意顺序 返回它们的根节点标签列表。

树的 高度 是指根节点和叶子节点之间最长向下路径上边的数量。

示例 1：
在这里插入图片描述

输入：n = 4, edges = [[1,0],[1,2],[1,3]]
输出：[1]
解释：如图所示，当根是标签为 1 的节点时，树的高度是 1 ，这是唯一的最小高度树。
示例 2：
在这里插入图片描述

输入：n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
输出：[3,4]

提示：

1 <= n <= 2 * 1e4
edges.length == n - 1
0 <= ai, bi < n
ai != bi
所有 (ai, bi) 互不相同
给定的输入 保证 是一棵树，并且 不会有重复的边

没怎么了解过拓扑排序的题目，当然也可以用BFS或DFS做（虽然我没想出来orz）：

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
        if (n == 1)
            return {0};
        vector<vector<int>> adj(n);
        vector<int> degree(n, 0);
        for (auto& edge : edges) {
            adj[edge[0]].push_back(edge[1]);
            adj[edge[1]].push_back(edge[0]);
            degree[edge[0]]++;
            degree[edge[1]]++;
        }
        queue<int> q;
        for (int i = 0; i < n; ++i) {
            if (degree[i] == 1)
                q.push(i);
        }
        while (n > 2) {
            int sz = q.size();
            n -= sz;
            for (int i = 0; i < sz; ++i) {
                int t = q.front();
                q.pop();
                for (auto& a : adj[t]) {
                    --degree[a];
                    if (degree[a] == 1)
                        q.push(a);
                }
            }
        }
        vector<int> res;
        while (!q.empty()) {
            res.push_back(q.front());
            q.pop();
        }
        return res;
    }
};

[303. 区域和检索 - 数组不可变](https://leetcode.cn/problems/range-sum-query-immutable/description/?envType=daily-question&envId=2024-03-18

给定一个整数数组 nums，处理以下类型的多个查询:

计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right
实现 NumArray 类：

NumArray(int[] nums) 使用数组 nums 初始化对象
int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ，包含 left 和 right 两点（也就是 nums[left] + nums[left + 1] + … + nums[right] )

示例 1：

输入：
[“NumArray”, “sumRange”, “sumRange”, “sumRange”]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出：
[null, 1, -1, -3]

解释：
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))

提示：

  • 1 <= nums.length <= 1e4
  • -1e5 <= nums[i] <= 1e5
  • 0 <= i <= j < nums.length
  • 最多调用 1e4 次 sumRange 方法

经典前缀和：

class NumArray {
public:
    vector<int> preSum;

    NumArray(vector<int>& nums) {
        preSum.resize(nums.size() + 1, 0);
        for (int i = 0; i < nums.size(); ++i) {
            preSum[i + 1] = preSum[i] + nums[i];
        }
    }

    int sumRange(int i, int j) { return preSum[j + 1] - preSum[i]; }
};

1793. 好子数组的最大分数(Hard)

给你一个整数数组 nums （下标从 0 开始）和一个整数 k 。

一个子数组 (i, j) 的 分数 定义为 min(nums[i], nums[i+1], …, nums[j]) * (j - i + 1) 。一个 好 子数组的两个端点下标需要满足 i <= k <= j 。

请你返回 好 子数组的最大可能 分数 。

示例 1：

输入：nums = [1,4,3,7,4,5], k = 3
输出：15
解释：最优子数组的左右端点下标是 (1, 5) ，分数为 min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15 。
示例 2：

输入：nums = [5,5,4,5,4,1,1,1], k = 0
输出：20
解释：最优子数组的左右端点下标是 (0, 4) ，分数为 min(5,5,4,5,4) * (4-0+1) = 4 * 5 = 20 。

提示：

1 <= nums.length <= 1e5
1 <= nums[i] <= 2 * 1e4
0 <= k < nums.length

单调栈：

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> left(n), right(n);
        stack<int> stk;
        for (int i = 0; i < n; ++i) {
            while (!stk.empty() && nums[stk.top()] >= nums[i]) {
                stk.pop();
            }
            left[i] = stk.empty() ? -1 : stk.top();
            stk.push(i);
        }
        while (!stk.empty()) {
            stk.pop();
        }
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && nums[stk.top()] >= nums[i]) {
                stk.pop();
            }
            right[i] = stk.empty() ? n : stk.top();
            stk.push(i);
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (left[i] < k && k < right[i]) {
                ans = max(ans, nums[i] * (right[i] - left[i] - 1));
            }
        }
        return ans;
    }
};
XforeverZ
关注
  • 21
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode每日一题在哪-interviewalgorithms:面试算法
06-30
每日一题在哪2020 年问题： 找到重复的号码 # goes through and makes the # Time: O(n) # Space: O(1) def findDuplicate ( self , nums : List [ int ]) -> int : for i in range ( len ( nums )): if nums [ abs ...
leetcode每日一题在哪-LeetCode-Solutions:我的Leetcode.com解决方案和有用的代码
06-30
每日一题在哪编码_挑战 这是我每天回答 Leetcode 问题的地方。 下面我将为我的每个答案写一个快速解释。 这个 repo 将作为一个地方来跟踪我的问题解决能力以及我的算法交流工作。 ### 2016 年 4 月 11 日星期一 19:...
LeetCode 每日一题 Day 167-181
m0_73814009的博客
05-31 732
否则，answer = [-1, -1]。输入: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]输入：matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]解释：在所有可能的子序列集合 {[3,5], [3,2], [3,6], [5,2], [5,6], [2,6]} 中，[2,6] 最具竞争力。
LeetCode 每日一题 Day 182-195
最新发布
m0_73814009的博客
06-14 598
解释：总共有 10 种方法分配 3 颗糖果，且每位小朋友的糖果数不超过 3 ：(0, 0, 3) ，(0, 1, 2) ，(0, 2, 1) ，(0, 3, 0) ，(1, 0, 2) ，(1, 1, 1) ，(1, 2, 0) ，(2, 0, 1) ，(2, 1, 0) 和 (3, 0, 0)。现在要求你戳破所有的气球。输入：edges = [[0,6,3],[6,5,3],[0,3,1],[3,2,7],[3,1,6],[3,4,2]], signalSpeed = 3。
LeetCode 每日一题 Day 123-136
m0_73814009的博客
04-16 620
请你返回一个大小为 n 的数组 ans ，其中 ans[i]是离节点 i 最近的祖先节点且满足 nums[i] 和 nums[ans[i]] 是 互质的 ，如果不存在这样的祖先节点，ans[i] 为 -1。调用 Successor(Jack, curOrder) ，返回 Bob ，所以我们将 Bob 放入 curOrder 中，得到 [“king”, “Alice”, “Jack”, “Bob”]。在节点网络中，当 graph[i][j] = 1 时，表示节点 i 能够直接连接到另一个节点 j。
LeetCode 每日一题 Day 137-143
m0_73814009的博客
04-23 1074
如果通过一条道路恰好用去 2 小时，就无需等待，可以直接继续。不跳过任何休息时间，你将用 (7/2 + 1/2) + (3/2 + 1/2) + (5/2 + 1/2) + (5/2) = 11.5 小时才能抵达会议现场。输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3。输入：graph = [[1,1,0,0],[1,1,1,0],[0,1,1,1],[0,0,1,1]], initial = [0,1]
LeetCode 每日一题 Day 158-166
m0_73814009的博客
05-16 848
将下标在 [i + 1, n - 1] 的所有设备的电池百分比减少 1，确保它们的电池百分比 不会低于 0 ，即 batteryPercentages[j] = max(0, batteryPercentages[j] - 1)。在设备 0 上，batteryPercentages[0] > 0 ，现在有 1 个已测试设备，batteryPercentages 变为 [1,0,1,0,2]。解释：难度级别为 2 的任务只有 1 个，但每一轮执行中，只能选择完成 2 个或者 3 个相同难度级别的任务。
LeetCode 每日一题 Day 47 - 50
m0_73814009的博客
01-21 1019
给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2。第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6]。第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9]。第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0]。因此，结果数组为 [“one”,“two”,“three”,“four”,“five”,“six”]。
LeetCode 每日一题 Day 88 - 94
m0_73814009的博客
03-05 1020
输入：n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]输入：edges = [[0,1],[1,2],[1,3],[4,2]], guesses = [[1,3],[0,1],[1,0],[2,4]], k = 3。输入：n = 7, edges = [[0,1],[1,2],[3,1],[4,0],[0,5],[5,6]], restricted = [4,5]
LeetCode 每日一题 Day 95-101
m0_73814009的博客
03-12 828
在 K-or 操作中，如果在 nums 中，至少存在 k 个元素的第 i 位值为 1 ，那么 K-or 中的第 i 位的值是 1。解释：因为 k == 1 ，数组的 1-or 等于其中所有元素按位或运算的结果。给你一个下标从 0 开始的字符串 word ，长度为 n ，由从 0 到 9 的数字组成。给你一个秘密数字 secret 和朋友猜测的数字 guess ，请你返回对朋友这次猜测的提示。提示的格式为 “xAyB” ，x 是公牛个数， y 是奶牛个数，A 表示公牛，B 表示奶牛。
LeetCode 每日一题 Day 116-122
m0_73814009的博客
04-02 886
输出：[[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]例如，上面的二叉树可以被序列化为字符串 “9,3,4,#,#,1,#,#,2,#,6,#,#”，其中 # 代表一个空节点。给你一个下标从 0 开始的整数数组 coins，表示可用的硬币的面值，以及一个整数 target。
leetcode每日一题在哪-leetcode:数据结构和算法之旅
06-30
每日一题在哪力码 数据结构和算法之旅 一般提示 滥用“运行”按钮很诱人，但没有帮助。 尝试简单的，目标是在第一次提交时被接受，因为这更真实地模拟了白板情况。 它迫使您自己考虑所有用例。 树木 一棵二叉树最多...
leetcode每日一题在哪-CodeCraft:Lei和Yoon-G的讨论记录
06-30
每日一题在哪手Craft.io 欢迎来到 CodeCraft，这是 Lei 和 Yoon-G 的关于计算机科学的讨论区。 虽然一个人追逐温暖的阳光，一个人拥抱寒冷的冬天，但他们都相信学习和实践让生活更美好。 ---雷 2020-2-21 讨论了求子...
leetcode每日一题在哪-SQL-Practices-Leetcode:SQL-实践-Leetcode
06-30
每日一题在哪LeetCode 上的 SQL 实践 该文件包含我在 MySQL 中对 LeetCode SQL 问题的解决方案。 问题清单 简单的 | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 418
【代码】力扣LCP 08.剧情触发时间。
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 258
你可以按 任何顺序 返回答案。
【代码随想录算法训练Day35】LeetCode 1005. K 次取反后最大化的数组和、LeetCode 134.加油站、LeetCode 135.分发糖果
qq_46121420的博客
06-11 226
贪心第三天
leetcode387：字符串中的第一个唯一字符
Ricky_youngone的博客
06-10 197
这个题目看似简单，实际上很考验你对于字符数组的理解，说白了，这个题目中档，一开始我用的是遍历和标记，最后发现不行。换了unordered_map这个方法，这个方法也是映射，也就是遍历一遍给的字符，把单独的字符在char映射到int中增加1，然后在遍历一遍字符，看看哪个是第一个出现且char映射的int数字只有1，这个就是第一个唯一字符。
leetcode今日每日一题
03-28
今日的每日一题是「两数相加」（Add Two Numbers），编号为 2。 题目描述 给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以零开头。 示例 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 解题思路 本题的难点在于链表的遍历和处理进位。具体思路如下： - 遍历两个链表，同时记录进位 carry。 - 将两个链表的当前节点的值相加，加上上一轮的进位 carry。 - 计算当前位的值和进位 carry。 - 将当前位的值插入新链表的末尾，并将当前节点指向下一个节点。 - 循环执行步骤 2~4，直到两个链表都遍历完毕。 - 如果最后还有进位，将进位添加到新链表的末尾。 时间复杂度：O(max(m, n))，其中 m 和 n 分别为两个链表的长度。 空间复杂度：O(max(m, n))，新链表的长度为 max(m, n) + 1。 参考代码 以下是 Python3 的实现代码：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

XforeverZ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值