Leetcode题解-算法-搜索

最新推荐文章于 2020-09-13 23:47:09 发布
最新推荐文章于 2020-09-13 23:47:09 发布
阅读量401 收藏
点赞数 1
分类专栏： leetcode题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyjacob/article/details/99718443
版权

文章目录

1、BFS

1.1 将一个数分解为整数的平方和

279. Perfect Squares(Medium)
Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, …) which sum to n.
Example 1:

Input: n = 12
Output: 3
Explanation: 12 = 4 + 4 + 4.

Example 2:

Input: n = 13
Output: 2
Explanation: 13 = 4 + 9.

方法一：BFS
计算最少可以拆解为几个平方和，用广度优先搜索，如果两个数的差等于整数的平方，则认为这两个数之间有边，问题转化为求整数 n 到整数 0 之间的最短路径。

定义一个队列，存放每层遍历的数字，再定义一个数组，查看每个节点（这里就是数字）是否遍历过，只走没走过的路径。

class Solution {
public:
    int numSquares(int n) {
        vector<int>square = generate(n);
        queue<int>qu;
        vector<int>visited(n+1, 0);
        qu.push(n);
        visited[n] = 1;
        int step = 0;
        while (!qu.empty()){
            int len = qu.size();
            step++;
            for(int i = 0; i < len; i++){
                int fr = qu.front();
                qu.pop();
                for(int c : square){
                    int next = fr - c;
                    if(next < 0)
                        break;
                    if(next == 0)
                        return step;
                    if(visited[next])
                        continue;
                    qu.push(next);
                    visited[next] = 1;
                }
            }
        }
        return n;
    }
private:
    vector<int>generate(int n){
        vector<int>res;
        for (int i = 1; i*i <= n; i++)
            res.push_back(i *i);
        return res;
    }
};

方法二：动态规划
子问题：i 最少能用几个数的平方和表示，用 dp[i] 表示
初始化：dp[i] = i，即用 1 的平方和表示
递推条件：dp[i] = min(dp[i], dp[i-j*j] + 1)

class Solution {
public:
    int numSquares(int n) {
        vector<int>dp(n+1, 0);
        for (int i = 0; i <= n; i++)
            dp[i] = i;
        for (int i = 1; i <= n; i++){
            for (int j = 1; j*j <= i; j++)
                dp[i] = min(dp[i], dp[i-j*j] + 1);
        }
        return dp[n];
    }
};

1.2 最短单词路径

127. Word Ladder(Medium)
给一个出发单词和一个结束单词，和一个单词序列，每次只能变化一个字母，问最快几个可以把出发单词变成结束单词。

Example 1:

Input:
beginWord = “hit”,
endWord = “cog”,
wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
Output: 5
Explanation: As one shortest transformation is “hit” -> “hot” -> “dot” -> “dog” -> “cog”,
return its length 5.

Example 2:

Input:
beginWord = “hit”
endWord = “cog”
wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
Output: 0
Explanation: The endWord “cog” is not in wordList, therefore no possible transformation.

解题思路：广度优先搜索
将每个单词看成节点，只有一个字母不相同的单词之间存在边。

先将出发单词放入队列中，每次从队列中取出一个元素，如果取出的元素等于结束元素，就找到了，否则将所有没有访问过的，之差一个字符的单词放入队列中。

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        int n = wordList.size();
        vector<int>visited(n, 0);
        queue<string>qu;
        qu.push(beginWord);
        int step = 0;
        while (!qu.empty()) {
            int len = qu.size();
            step++;								//更新层数
            for (int i = 0; i < len; i++){ 		//取出队列的每个元素
                string fr = qu.front();
                qu.pop();
                if (fr == endWord) return step;
                for (int j = 0; j < n; j++){ 	//没访问过的，存在边的节点放入队列中
                    if (visited[j] == 0 && diff(fr, wordList[j]) == 1){
                        qu.push(wordList[j]);
                        visited[j] = 1;			//访问过的元素做标记
                    }
                }
            }            
        }
        return 0;
    }
    int diff(string s, string t){ 				//查看两个单词之间有几个字母不相同
        int cnt = 0;
        for (int i = 0; i < s.size(); i++){
            if (s[i] != t[i])
                cnt++;
        }
        return cnt;
    }
    
};

1.3 K 站中转内最便宜的航班

787. Cheapest Flights Within K Stops(Medium)
Example 1:

Input:
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
Output: 200
Explanation:
The graph looks like this:
The cheapest price from city 0 to city 2 with at most 1 stop costs 200, as marked red in the picture.
在这里插入图片描述

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        queue<vector<int>>q;            //队列中每个vector的第一个元素为该路径的花的钱，后面的元素表示路径
        q.push(vector<int>{0, src});
        while (!q.empty()) {
            auto tmp = q.front();
            q.pop();
            if(tmp[tmp.size()-1] == dst) {      //找到目的节点
                if (tmp.size() -1 <= K+2)       //不算起点终点，中间点个数不能小于等于K
                    min_value = min(min_value, tmp[0]); //更新最少钱数
            }
            if(tmp.size() > K+2 || tmp[0] > min_value)  //路径超出的，钱大于给定值的，直接丢弃
                continue;
            for(auto key : flights){
                //找到的从该起点的路径，且终点没有访问过（用find返回尾迭代器表示节点未访问）更新钱数，更新路径
                if(key[0] == tmp[tmp.size() - 1] && find(tmp.begin() + 1, tmp.end(), key[1]) ==tmp.end()){
                    vector<int>new_tmp;
                    new_tmp.insert(new_tmp.begin(), tmp.begin(), tmp.end());//新的价值，路径移动到新容器中
                    new_tmp[0] += key[2];
                    new_tmp.push_back(key[1]);
                    q.push(new_tmp);
                }
            }
        }
        if(min_value == INT_MAX)
            return -1;
        return min_value;
    }
private:
    int min_value = INT_MAX;
};

2、DFS

2.1 查找最大的连通面积

695. Max Area of Island(Medium)
Example 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]
Given the above grid, return 6. Note the answer is not 11, because the island must be connected 4-directionally.

Example 2:

[[0,0,0,0,0,0,0,0]]
Given the above grid, return 0.

class Solution {
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        if (grid.empty() || grid[0].empty()) return 0;
        row = grid.size();
        col = grid[0].size();
		int res = 0;
		for (int i = 0; i < row; i++)	{
			for (int j = 0; j< col; j++) {
				if (grid[i][j] == 1) {
					int area = 0;
					DFS(grid, area, i, j);
					res = max(res, area);
				}
			}
		}
		return res;
    }
    void DFS(vector<vector<int>>& grid, int &area, int x, int y) {
		if(x < 0 || x >= row || y < 0 || y >= col || grid[x][y] == 0)
            return;
		grid[x][y]= 0;
		area++;
		DFS(grid,area,x,y+1);
		DFS(grid,area,x,y-1);
		DFS(grid,area,x-1,y);
		DFS(grid,area,x+1,y);
	}
private:
    int row;
    int col;
};

2.2 矩阵中的连通分量数目

200. Number of Islands(Medium)
Example 1:

Input:
11110
11010
11000
00000
Output: 1

Example 2:

Input:
11000
11000
00100
00011
Output: 3

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.size() == 0 || grid[0].size() == 0)
            return 0;
        row = grid.size();
        col = grid[0].size();
        int res = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j] == '1'){
                    DFS(grid, i, j);
                    res++;
                }
            }  
        }
        return res;
    }
    void DFS(vector<vector<char>>& grid, int i, int j){
        if(i < 0 || i >= row || j < 0 || j >= col || grid[i][j] == '0')
            return;
        grid[i][j] = '0';			//修改访问过的节点
        DFS(grid, i + 1, j);
        DFS(grid, i - 1, j);
        DFS(grid, i, j + 1);
        DFS(grid, i, j - 1);
    }
    
private:
    int row;
    int col;
};

2.3 朋友圈的数量

547. Friend Circles(Medium)
矩阵 M 中的 M[i][j] == 1 表示 i 和 j 是朋友，直接朋友和间接朋友组成一个朋友圈，问有多少个朋友圈。
Example 1:

Input:
[[1,1,0],
[1,1,0],
[0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
The 2nd student himself is in a friend circle. So return 2.

Example 2:

Input:
[[1,1,0],
[1,1,1],
[0,1,1]]
Output: 1
Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends,
so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.

解题思路：深度优先搜索

对遍历每个人，如果没有访问过，以此人为节点进行深度优先搜索，将所有的直接，间接朋友找出，并做标记，表示已经访问过。

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        n = M.size();
        vector<int>people(n, 0);
        int res = 0;
        for (int i = 0; i < n; i++){
            if (people[i] == 0){
                res++;
                DFS(M, people, i);
            }
        }
        return res;
    }
    void DFS(vector<vector<int>>&M, vector<int>&people, int x){
        people[x] = 1;
        for (int i = 0; i < n; i++){
            if (M[i][x] == 1 && people[i] == 0)
                DFS(M, people, i);
        }
    }
    int n = 0;
};

2.4 填充封闭的区域

130. Surrounded Regions(Medium)
矩阵中只有字符 ‘X’ 和 ‘O’（大写字母O），将所有被 ‘X’ 包围的 ‘O’ 变成 ‘X’，边界不作为封闭条件。

Example:

X X X X
X O O X
X X O X
X O X X
After running your function, the board should be:
X X X X
X X X X
X X X X
X O X X

解题思路：

  1. 从四条边开始搜索 ‘O’，若边上存在 ‘O’,则从它开始进行 DFS 进行特殊标记，这部分的 ‘O’ 都不用变成 ‘X’;
  2. 标记完成后，则只剩下内部的 ‘O’ 了，此时直接将 ‘O’ 变成 ‘X’ 即可；
  3. 再将第一步的特殊标记变回 ‘O’ 即完成。
class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if(board.empty() || board[0].empty())
            return;
        row = board.size();
        col = board[0].size();
        for (int i = 0; i < row; i++){
            dfs(board, i, 0);
            dfs(board, i, col-1);
        }
        for (int i = 1; i < col - 1; i++){
            dfs(board, 0, i);
            dfs(board, row-1, i);
        }
        for (int i = 0; i < row; i++){
            for (int j = 0; j < col; j++){
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == 'T')
                    board[i][j] = 'O';
            }
        }
    }
    void dfs(vector<vector<char>>& board, int i, int j) {
        if(i < 0 || i >= row || j < 0 || j >= col || board[i][j] != 'O')
            return;
        board[i][j] = 'T';
        dfs(board, i+1, j);
        dfs(board, i-1, j);
        dfs(board, i, j+1);
        dfs(board, i, j-1);
    }
private:
    int row;
    int col;
};

2.5 能到达的太平洋和大西洋的区域

417. Pacific Atlantic Water Flow(Medium)
上面和左侧是太平洋，下面和右侧是大西洋，矩阵中的每个值表示此处的海拔，水只能流向和原位置等高或低海拔的地方，找出所有可以流入太平洋和大西洋区域。

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~ 
       ~  1   2   2   3  (5) *
       ~  3   2   3  (4) (4) *
       ~  2   4  (5)  3   1  *
       ~ (6) (7)  1   4   5  *
       ~ (5)  1   1   2   4  *
          *   *   *   *   * Atlantic

Return:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

解题思路：
从四条边出发，深度优先搜索，将所有能访问到的节点标记，两个标记矩阵，一个表示可以从流入太平洋的区域，另一个表示可以流入大西洋的区域，找出二者共同的区域即可。

class Solution {
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& matrix) {
        vector<vector<int>>res;
        if(matrix.empty() || matrix[0].empty())
            return res;
        row = matrix.size();
        col = matrix[0].size();
        vector<vector<bool>>reachPacific(row, vector<bool>(col, 0));//可以流入太平洋的区域
        vector<vector<bool>>reachAtlantic(row, vector<bool>(col, 0));//可以流入大西洋的区域
        for (int i = 0; i < row; i++){
            DFS(matrix, reachPacific, i, 0);		//左侧边
            DFS(matrix, reachAtlantic, i, col-1);	//右侧边
        }
        for (int i = 0; i < col; i++){
            DFS(matrix, reachPacific, 0, i);		//上边
            DFS(matrix, reachAtlantic, row-1, i);	//下边
        }
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++)
                if(reachPacific[i][j] && reachAtlantic[i][j])//找都能到达的区域
                    res.push_back(vector<int>{i, j});
        }
        return res;
    }
    void DFS(vector<vector<int>>& matrix, vector<vector<bool>>& reach,int i, int j){
        reach[i][j] = 1;
        for(int a = 0; a < 4; a++){
            int nexti = i + dir[a][0];
            int nextj = j + dir[a][1];
            //下一个位置，在矩阵中，没有被访问，且大于等于当前海拔
            if(isValid(nexti,nextj) && !reach[nexti][nextj] && matrix[nexti][nextj] >= matrix[i][j])
                DFS(matrix, reach, nexti, nextj);
        }
    }
    //判断是否可以到达
    bool isValid(int i, int j){
	    return i >= 0 && i < row && j >= 0 && j < col;
    }
private:
    int row;
    int col;
    int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
};
-出发-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode】单调栈相关题目总结
flora
05-06 536
单调栈单调栈用单调栈的类型42. 接雨水496. 下一个更大元素 I503. 下一个更大元素 II 单调栈 用单调栈的类型 42. 接雨水 42. 接雨水 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。 提示： n == height.length 0 <= n <= 3 * 104 0 <= height[i] <= 105 思路： 有坑才能接住雨水，所谓的坑其实就是有左右两个边界，那我们只要找到每个坑的边界，就可以通过这个边
LeetCode---搜索算法
weixin_43571751的博客
03-03 276
搜索算法 图 图Graph的概念 图是一种由节点和边构成的数据结构，实际上树也是一种特殊的图。图可以用来表示现实世界中的很多事物：道路交通系统、航班线路、互联网连接等等。 顶点Vertex (节点Nond)：是图的基本组成部分，顶点具有名称标识key，也可以携带数据项payload。 边Edge（弧Arc）：作为两个顶点之间关系的表示，边连接两个顶点；边可以是无向或有向的，相应的图称为“无向图”和“有向图”。 权重Weight：为了表达从一个顶点到另一个顶点的代价，可以给边赋权；例如公交网中的两个站点之间的
leecode第二百七十九题（完全平方数）
weixin_30952103的博客
08-05 125
class Solution { public: int numSquares(int n) { vector<int> res(n+1,0); for(int i=1;i<n+1;i++) { res[i]=i; for(int j=1;i-j...
（动态规划）01背包
Jan___的博客
09-06 291
分割等和子集 给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200 示例1： 输入: [1, 5, 11, 5] 输出: true 解释: 数组可以分割成 [1, 5, 5] 和 [11]. 示例2： 输入: [1, 2, 3, 5] 输出: false 解释: 数组不能分割成两个元素和相等的子集. ...
Leetcode 题解 - 动态规划-0-1 背包（8）：组合总和
qq_40320556的博客
05-07 283
[LeetCode] Combination Sum IV 组合之和之四 加上所有dp[i]的可能性 Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer ta...
算法面试不懂这6大数据结构知识一定挂！（附力扣LeetCode真题讲解）
形势所逼，不进则退
09-04 2476
本文作者：苏勇，Google 资深技术工程师 首发地址：https://mp.weixin.qq.com/s/u8pvmupISQ5D4kGIkgfKbA 在互联网行业的算法面试中经常会被考到数据结构的知识，它与算法相辅相成，没有扎实的数据结构基础，学好算法几乎不太可能。 挨踢君精心整理了Google资深工程师的学习笔记和解题技巧，总结出6大数据结构必考知识点，同时以力扣LeetCode经典题...
leedcode题解-搜索
whyzw1314520的博客
04-09 234
1、组成整数的最小平方数数量 279. Perfect Squares (Medium) 输入: n = 12 输出: 3 解释: 12 = 4 + 4 + 4.BFS广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。 思路：用层序遍历的BFS思想，一层一层的遍历（通过控制队列的size）,第一次找...
500195422331430LeetCode题解 - Java语言实现.zip
最新发布
03-25
标题 "500195422331430LeetCode题解 - Java语言实现.zip" 暗示这是一个包含Java编程语言实现的LeetCode问题解决方案的压缩文件。LeetCode是一个在线平台，提供了大量的编程题目，旨在帮助程序员提升算法技能和面试...
LeetCode题解 - Java语言实现-181页.pdf
06-04
本文档为LeetCode题解的Java语言实现，涵盖了181页的内容，涉及到数组、链表、树、图、动态规划、回溯算法等多种数据结构和算法。 1. Rotate Array in Java 数组旋转是一个基本的数组操作，要求将数组中的元素旋转...
LeetCode题解-两数相加python实现
01-20
在leetcode做算法题时，并不需要写输入输出，但是在实际线上笔试的时候，需要自己调试。 本文以链表为例，讲解链表的插入以及链表的输出，还有链表的定义。 1.两数相加-Python实现 链表-两数相加-python语言实现 ...
leetcode中国-leetcode:leetcode题解收录
06-29
《LeetCode题解收录——深度探索编程算法之美》 LeetCode，这个响亮的名字在编程领域内无人不晓，它是全球知名的在线编程挑战平台，专为程序员提供算法练习和技能提升。LeetCode中国则是在此基础上，针对国内程序员...
leetcode跳跃-LeetCode:LeetCode题解
06-30
【标题】"LeetCode题解"是一份针对LeetCode在线编程挑战平台的解答集合，它旨在帮助用户理解和解决LeetCode上的各种算法问题。LeetCode是一个非常受欢迎的平台，程序员们在这里提升自己的编程技能，准备面试，或者...
动态规划总结——背包dp(基于LeetCode题目)
qq_38732834的博客
05-09 332
题目汇总 这类问题阔以说是笔试最常出现的题目了(线性dp也挺常见，啥最长上升子序列啥啥的)。 这类问题如果不是太难基本上阔以套模板的。 抽象一下 就是有一个收益尽可能大的目标，有一个其他消耗，在允许的消耗范围内使得收益最大。 子问题也很好想，就是某个消耗限制下最大的收益。 这类问题分为01背包，多重背包，完全背包。 01背包就是同个有价值的消耗都只有一个。 多重背包每个有价值的消耗有有限个(可以转换为01背包)。 完全背包就是每个有价值的消耗有无穷个。 这是一个01背包问题。那个数组里的就是消耗。 价值：
图论3解
qq_33271192的博客
09-13 118
力扣787 输入: n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]] src = 0, dst = 2, k = 1 输出: 200 从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图。 城市航班图： #mermaid-svg-Bs7AbXg3OXMz2E3A .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fi
Leetcode 题解 - 动态规划-0-1 背包（1）：问题简介
qq_40320556的博客
06-03 1925
0-1 背包 有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。 定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论： 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件...
leetcode刷题知识点记录
weixin_43850162的博客
03-11 196
文章目录一、链表 一、链表
leetcode刷题——算法（6）:搜索
qq_37772475的博客
02-19 321
搜索（2.15） BFS 1. 计算在网格中从原点到特定点的最短路径长度 修改后做出 2. 组成整数的最小平方数数量（2.16） 一开始未做出 ※ 3. 最短单词路径 ...
Leetcode 题解 - 动态规划
Cybenko
06-30 1016
递归和动态规划都是将原问题拆成多个子问题然后求解，他们之间最本质的区别是，动态规划保存了子问题的解，避免重复计算。 斐波那契数列 爬楼梯 70. Climbing Stairs (Easy) 题目描述：有 N 阶楼梯，每次可以上一阶或者两阶，求有多少种上楼梯的方法。 定义一个数组 dp 存储上楼梯的方法数（为了方便讨论，数组下标从 1 开始），dp[i] 表示走到第 i 个楼梯的方法数目。 第 i 个楼梯可以从第 i-1 和 i-2 个楼梯再走一步到达，走到第 i 个楼梯的方法数为走到第 i-1 和第 i-
Leetcode题解(更新中……)
桑凯旋的博客
03-13 1423
算法思想 双指针 Two Sum II - Input array is sorted 排序 快速选择 堆排序 桶排序 荷兰国旗问题 贪心算法 二分查找 分治 搜索 BFS DFS Backtracking 动态规划 斐波那契数列 矩阵路径 数组区间 分割整数 最长递增子序列 最长公共子序列 0-1 背包 数学 素数 最大公约数 进制转换 阶乘 字符串加法减法 相遇问题 多数投票问题 其它 数据结...
leetcode-cpp (一些数据结构和经典算法)
04-03
本资源是关于LeetCode的cpp解决方案，涵盖了各种数据结构和经典算法，旨在帮助读者提高编程水平和质量。下面是从该资源中提炼出的知识点： 一、数据结构 * 数组：数组是一种基本的数据结构，用于存储一组相同类型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值