第19周 算法思想 搜索（BFS&DFS）

最新推荐文章于 2025-12-27 16:49:17 发布
原创 最新推荐文章于 2025-12-27 16:49:17 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #leetcode #职场和发展

本文介绍了如何使用BFS算法解决Word Ladder II中的最短单词路径问题，并将BFS转换为DFS以寻找所有路径。此外，展示了DFS在找到矩阵中最近0的距离、最大连通区域和封闭区域填充中的应用，以及括号生成的多种解决方案，如动态规划、暴力法和深度优先搜索。

文章目录

BFS

最短单词路径（输出所有路径）

把对节点的BFS转换为对路径的DFS，依然可以用层次遍历的思路解决，有两点需要注意

  • 从队列的pop出一个路径时需要把它的长度和最短路径长度做比较
  • 对visited节点的更新需要在整个层次遍历完之后进行
class Solution {
public:    
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        queue<vector<string>> q;
        vector<vector<string>> ans;
        unordered_set<string> wordSet;
        unordered_set<string> visitedSet;
        
        for(string word: wordList)
            wordSet.insert(word);
        
        q.push({beginWord});
        
        int shortest  = 1005;
        
        while(!q.empty()){
            vector<string> visited;
            
            int size = q.size();
                        
            while(size--){
                vector<string> curr = q.front();
                q.pop();
            
                if(curr.back() == endWord){
                    if(curr.size() < shortest){  // 清除非最短路径
                        for(int i = 0;i < ans.size(); i++)
                            ans[i].clear();
                        ans.clear();                    
                        ans.push_back(curr);
                        shortest = curr.size();
                    }
                    else if(curr.size() == shortest){
                        ans.push_back(curr);
                    }
                }

                if(curr.size() > shortest)
                    continue;

                string last = curr.back();

                for(int i = 0;i < last.size(); i++){
                    string tmp = last;
                    for(char c: "abcdefghijklmnopqrstuvwxyz"){
                        tmp[i] = c;
                        if(c != last[i] && wordSet.find(tmp) != wordSet.end() && (visitedSet.find(tmp) == visitedSet.end() || tmp == endWord)){
                            vector<string> curr_tmp = curr;
                            curr_tmp.push_back(tmp);
                            q.push(curr_tmp);
                            visited.push_back(tmp);                            
                        }
                    }    
                }
            }
            
            for(auto s: visited)
               visitedSet.insert(s);
            
        }
        
        return ans;
        
        
    }
};

到离得最近的0的距离

typedef pair<int,int> P;
class Solution {
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        int n = mat.size();
        int m = mat[0].size();
        
        queue<P> q;
        
        vector<vector<int>> ans;
        for(int i = 0;i < n; i++){
            vector<int> tmp(m, 99999);
            ans.push_back(tmp);
        }
        
        for(int i = 0;i < n; i++){
            for(int j = 0;j < m; j++){
                if(mat[i][j] == 0){
                    ans[i][j] = 0;
                    q.push({i,j});
                }
            }
        }
        
        int dx[] = {0,0,1,-1};
        int dy[] = {1,-1,0,0};
        
        while(!q.empty()){
            P u = q.front();
            q.pop();
            
            int x = u.first, y = u.second;
            for(int i = 0;i < 4; i++){
                int nx = x + dx[i];
                int ny = y + dy[i];
                if(nx >= 0 && nx < n && ny >= 0 && ny < m && ans[nx][ny] > ans[x][y] + 1){
                    ans[nx][ny] = ans[x][y] + 1;
                    q.push({nx, ny});
                }
            }
        }
        return ans;     
    }
};

DFS

查找最大的连通面积

class Solution {
public:
    int m, n, curr;
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    
    void dfs(vector<vector<int>>& grid, int x, int y){
        grid[x][y] = 0;
        curr += 1;
        for(int i = 0;i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == 1){
                dfs(grid, nx, ny);
            }
        }
    }
    
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        n = grid.size();
        m = grid[0].size();
        
        int ans = 0;
        
        for(int i = 0;i < n; i++){
            for(int j = 0;j < m; j++){
                if(grid[i][j] == 1){
                    curr = 0;
                    dfs(grid, i, j);
                    if(curr > ans)
                        ans = curr;
                }
            }
        }
        
        return ans;
        
    }
};

填充封闭区域

从边界上的“缺口”开始DFS，剩下没有遍历到的”缺口“就是被包围的。

class Solution {
public:
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int n, m;
    
    void dfs(vector<vector<char>>& board, int x, int y){
        board[x][y] = 'Z';
        for(int i = 0;i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx >= 0 && nx < n && ny >= 0 && ny < m && board[nx][ny] == 'O')
                dfs(board, nx, ny);
        }
    }
    
    void solve(vector<vector<char>>& board) {
        n = board.size();
        m = board[0].size();
        
        for(int i = 0;i < n; i++){
            if(board[i][0] == 'O')
                dfs(board, i, 0);
            if(board[i][m-1] == 'O')
                dfs(board, i, m-1);
        }
        for(int i = 0;i < m; i++){
            if(board[0][i] == 'O')
                dfs(board, 0, i);
            if(board[n-1][i] == 'O')
                dfs(board, n-1, i);
        }
        
        for(int i = 0;i < n; i++){
            for(int j = 0;j < m; j++){
                if(board[i][j] == 'Z')
                    board[i][j] = 'O';
                else if(board[i][j] == 'O')
                    board[i][j] = 'X';
            }
        }
        
    }
};

括号生成

三种方法

  • 动态规划法：求解包含n对括号的字符串时，如果包好0到n-1对括号的解都知道，那就可以直接得到n对括号的解。设想n对括号的解集包括两部分，一部分是可以拆为两部分的，就是左边是完整的k对括号，右边是完整的n-k对括号，另一部分是不可以拆分的，也就是最外层有一对括号，括号里面是n-1对括号。为了避免生成过程中产生重复，所以用set记录生成的所有括号。
  • 暴力法：这道题一开始想到的就是动态规划法，后来才知道可以DFS，直接写DFS感觉优点理解不了，所以就实现了下暴力法方便自己理解。暴力法就是生成有左右括号组成的长度为2n的字符串，然后再挑选其中的合法字符串。合法的定义就是：(的数量要一直大于等于)的数量，并且遍历完成后左右括号的数量相等且都为n。
  • DFS：在搜索的过程中就判断是否合法，left，right变量记录已经用掉的左右括号数量，left==0 && right == 0表明用完了则curr就是答案，否则只有在left<=right的时候也就是用掉的左括号多于右括号的时候才继续后续的添加。
class Solution {
public:
    // 动态规划的思想，求解子问题的解，用子问题解决原问题
    vector<string> generateParenthesis_dp(int n) 
    {
        unordered_set<string> ans[n+1];
        for(int i = 1;i <= n; i++)
        {
            if(i == 1)
                ans[i].insert("()");
            else{
                for(auto it : ans[i-1])
                   ans[i].insert("("+it+")");
                
                for(int j = 1;j <= i-1; j++){
                    for(auto& it1 : ans[j]){
                        for(auto& it2 : ans[i-j])
                            ans[i].insert(it1+it2);
                    }
                }
            }
        }
        
        vector<string> ans_v;
        for(auto it : ans[n])
            ans_v.push_back(it);

        return ans_v;
    }
    
    // 暴力解法，生成所有字符串然后挑合法的
    vector<string> generateParenthesis_BruteForce(int n){
        vector<string> all, ans;
        dfs_BruteForce("", n * 2, all);
        cout << all.size() << endl;
        for(int i = 0;i < all.size(); i++){
            // cout << all[i] << endl;
            if(valid(all[i]))
                ans.push_back(all[i]);
        }
        return ans;
    }
    
    void dfs_BruteForce(string curr, int k, vector<string>& all){
        if(k == 1){
            all.push_back(curr+"(");
            all.push_back(curr+")");
        }
        else{
            dfs_BruteForce(curr+"(", k-1, all);
            dfs_BruteForce(curr+")", k-1, all);
        }
    }
    
    bool valid(string& s){
        int left = 0, right = 0;
        for(int i = 0;i < s.size(); i++){
            if(s[i] == '(')
                left += 1;
            else if(s[i] == ')')
                right += 1;
            if(left < right)
                return false;
        }
        return left == right && left == s.size() / 2;
    }
    
    // DFS，在暴力求解的基础上对搜索的目标进行剪枝
    vector<string> generateParenthesis(int n){
        vector<string> ans;
        
        dfs("", n, n, ans);
        
        return ans;
    }
    
    void dfs(string curr, int left, int right, vector<string>& ans){
        if(left == 0 && right == 0)
            ans.push_back(curr);
        
        if(left <= right && right > 0)
            dfs(curr + ")", left, right-1, ans);
        
        if(left <= right && left > 0)
            dfs(curr + "(", left-1, right, ans);
    }
    
};
搜索（DFS与BFS）：
嵌入式技术开发
02-14 2552
深度搜索与广度搜索
数据结构与算法学习⑤(BFS和DFS 贪心算法 二分查找)
m0_46690280的博客
12-10 1492
数据结构与算法学习⑤数据结构与算法学习⑤1、BFS和DFS1.1、深度优先搜索算法1.2、广度优先搜索算法2、面试实战102. 二叉树的层序遍历104. 二叉树的最大深度515. 在每个树行中找最大值200. 岛屿数量 数据结构与算法学习⑤ 1、BFS和DFS 深度优先搜索算法（DFS）和广度优先搜索算法（BFS）是一种用于遍历或搜索树或图的算法，在搜索遍历的过程中保证每个节点（顶点）访问一次且仅访问一次，按照节点（顶点）访问顺序的不同分为深度优先和广度优先。 1.1、深度优先搜索算法 深度优先搜索算法（D
图解搜索算法(BFS、DFS、Dijstra算法、KSP算法、A*算法)
风清扬zld的博客
08-21 3149
由于在工作中用到了BFS算法、DFS算法、Dijkstra算法、KSP算法，因此将上述算法的工作原理记录一下，同时用图解的方式解释相应的算法。A*算法由于本文在工作中，还没用过，因此只做了一个简单的介绍。
300分钟搞定数据结构与算法课程学习5 ——DFS和BFS
鱼之天空的博客
05-11 727
DFS 和 BFS 经常在算法面试题当中出现，在整个算法面试知识点中所占的比重非常大。应用最多的地方就是对图进行遍历，树也是图的一种。深度优先搜索（Depth-First Search / DFS） 深度优先搜索，从起点出发，从规定的方向中选择其中一个不断地向前走，直到无法继续为止，然后尝试另外一种方向，直到最后走到终点。就像走迷宫一样，尽量往深处走。 DFS 解决的是连通性的问题，即，给定两个点，一个是起始点，一个是终点，判断是不是有一条路径能从起点连接到终点。起点和终点，也可以指的是某种起始状态和.
数据结构与算法——BFS(广度优先搜索)
热门推荐
闻道有先后，术业有专攻
08-17 1万+
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
Java数据结构与算法----搜索篇（DFS与BFS）
stu_kk的博客
03-25 2528
DFS与BFS算法
【BFS】池塘计数（Flood Fill算法 + BFS/DFS）
hongjianMa的博客
04-10 989
的经典应用，通过BFS/DFS标记连通区域。的矩形土地，部分区域被水淹没。要求计算整个矩阵中有多少片独立的池塘。
2021秋招-算法-BFS-DFS
LBJ_King的博客
06-23 1096
BFS-DFS总结
图的BFS和DFS原理及实例分析（java） & 转载 图的DFS和BFS算法
qq_39429288的博客
03-19 442
图的BFS和DFS原理及实例分析（java） https://blog.youkuaiyun.com/feilong_csdn/article/details/69386527 图的深度优先遍历(DFS)和广度优先遍历(BFS），DFS利用递归来实现比较易懂，DFS非递归就是将需要的递归的元素利用一个栈Stack来实现，以达到递归时候的顺序，而BFS则是利用一个...
算法基础课—搜索与图论（一）DFS、BFS
Yttttttttttttttt的博客
05-24 436
算法基础课—搜索与图论（一）DFS、BFS、树、图的存储方式及搜索深度优先搜索 DFS核心——回溯和剪枝回溯剪枝算法思想整体结构算法模板——来自于排列数的题目排列数字题目算法思想代码n皇后问题题目方法一代码方法二代码宽度优先搜索 BFS最短性空间复杂度的对比适用情况核心BFS模板代码模板——走迷宫的宽度有限搜索走迷宫题目算法思想代码八数码问题题目算法思想代码 深度优先搜索 DFS 深度优先搜索DFS 一直往深的搜，直到碰到叶节点就回溯到上一节点进行搜索 核心——回溯和剪枝 DFS ——递归实现——回溯和剪
刷题笔记（十四）--二叉树：层序遍历和DFS,BFS
weixin_53860901的博客
06-06 1947
一篇文章带你了解并且掌握DFS和BFS
路径算法实战精讲：BFS vs DFS在迷宫游戏中的性能对比
本文系统介绍了BFS与DFS两种基础搜索算法的理论原理、复杂度特性及其在迷宫建模中的实现方式，比较了两种算法在不同场景下的性能表现。通过构建随机迷宫数据集，本文实验分析了算法在时间消耗、空间占用及路径最优性...
算法 | 广度优先搜索（BFS）和深度优先搜索（DFS）理论与深入实践
Welcome to the Western World
04-19 1562
搜索算法不仅在实际应用中非常重要，也是各大公司编程笔试题目重头戏，本文聚焦于两大经典的图算法：广度优先搜索（Breadth First Search）和深度优先搜索（Depth First Search）。我在学习数据结构的时候初识这两种算法，后来在算法图解一书也看到了形象的介绍，虽然算法的概念不难但是因为足够的实践经验，理解不够深刻。现在，本文将对这两种经典算法进行简单的介绍，着...
图算法：DFS、BFS及其应用
### 图算法：DFS、BFS及其应用 #### 1. 有向图的平方 有向图 $G=(V,E)$ 的平方图定义为：当且仅当存在某个顶点 $v$ ，使得 $(u,v)\in E$ 且 $(v,w)\in E$ 时，$(u,w)$ 是平方图中的边，即存在一条恰好由两条边组成...
PageRank 算法：互联网的“人气投票”
core815的专栏
12-26 930
PageRank 算法：互联网的“人气投票”
【AI称重算法落地指南】实施步骤、多算法方案与避坑手册
最新发布
昔时扬尘处
12-27 31
AI称重算法的落地核心是“硬件精准采样+数据高质量标注+轻量化模型适配”，结合STM32G4的算力优势与NanoEdge AI Studio的低代码开发能力，可快速实现100克级精度的称重方案。在算法选型上，静态场景优先DNN（资源占用低、精度高），动态/噪声场景优先CNN（抗干扰强），时序依赖场景优先RNN（快速响应）。实际应用中需重点解决数据分布、噪声干扰、硬件适配三大核心问题，通过样本扩充、软硬件协同优化、现场自学习等手段，确保方案的可靠性与量产适配性。
TDCA 算法在 SSVEP-BCI 中的时间戳技术要求与工程实现
m0_63827302的博客
12-26 559
在基于稳态视觉诱发电位（Steady-State Visual Evoked Potential, SSVEP）的脑机接口（Brain-Computer Interface, BCI）系统中，任务驱动成分分析（Task-Driven Component Analysis, TDCA）作为核心的有监督时空特征学习算法，其性能高度依赖于脑电信号（Electroencephalogram, EEG）与视觉刺激事件的时序一致性 —— 而时间戳正是保障这一一致性的关键技术支撑。
Q-learning 算法 —— 无模型（model-free）强化学习
一杯水果茶！足矣~
12-25 1208
从已知模型到 Model-free 的强化学习转变：Q-Learning 算法，通过详细示例来讲解，理解 Q-table 的更新和贪婪策略
数组的初始化与使用
WQlovematch的博客
12-23 398
摘要：本文介绍了C语言数组的基本概念和使用方法。数组是存储相同类型元素的连续内存结构，通过索引访问元素。文章详细说明了数组的声明、初始化（包括完全和部分初始化）、多维数组的定义和访问方式。同时讲解了基本数据类型（int、char、float、double）的特性及存储空间。通过示例代码演示了数组遍历、数据类型大小检测和简单图形绘制。最后提出了数组逆序输出的课后练习，强调数组越界访问会导致未定义行为。
详细介绍一下，枚举、排序（冒泡、选择、插入）、搜索（bfs\dfs）、贪心、模拟、二分、高精度、数据结构（栈、队列）、排序（归并排序、快速排序）、搜索（记忆化搜索）、图论（最近共同祖先）、数学（容斥原理）、数据结构（ST表），我用C++打比赛
03-30
<think>嗯，用户想了解在C++比赛中常用的算法和数据结构，比如枚举、排序、搜索、贪心等等。我需要详细解释每个部分，还要用中文，结构清晰。首先，我得确保每个算法都分点介绍，包括基本概念、应用场景、C++实现要点和例题。用户可能正在准备竞赛，需要这些知识点来提升解题能力。 首先，枚举，也就是暴力法，要讲清楚它的适用情况，比如数据量小的时候。然后是排序算法，用户提到了冒泡、选择、插入，可能还需要补充归并和快排，虽然用户后面也提到了归并和快排，但可能在排序部分需要分开说明。接下来是搜索，BFS和DFS的区别和应用，比如最短路径用BFS，回溯用DFS。然后是贪心算法，强调局部最优但可能不是全局最优，需要例子比如活动选择。 模拟题需要仔细处理步骤，可能容易出错，比如日期计算。二分法适用于有序数据，比如找最小值。高精度处理大数，用数组存储。数据结构部分，栈和队列的应用，比如括号匹配和BFS。归并和快排的分治思想，时间复杂度的差异。记忆化搜索用于优化递归，比如斐波那契数列。图论的LCA问题，最近公共祖先，用倍增法。数学中的容斥原理，计算集合的并集。ST表用于区间最值查询，比如RMQ问题。 需要检查每个算法的实现要点，比如循环变量、边界条件。例如冒泡排序的双层循环，快速排序的递归实现。还要注意C++的代码片段是否正确，比如使用vector还是数组，是否需要头文件。可能用户需要代码示例，但用户没有明确要求，所以可能简要给出关键部分。 还要考虑用户可能遇到的常见错误，比如二分法的终止条件，高精度加法时的进位处理。数据结构部分，栈和队列的STL用法，或者自己实现。ST表的预处理步骤和查询函数。另外，例题推荐可以帮助用户练习，但可能用户需要具体的题目名称，比如LeetCode或洛谷的题号。 需要确保每个部分结构一致，先介绍概念，再讲应用场景，然后实现要点，最后例题。语言要简洁，避免冗长。可能用户时间有限，需要快速掌握重点。还要注意术语的准确性，比如BFS和DFS的应用场景区别，贪心算法的适用条件。 最后，检查是否有遗漏的部分，用户提到的所有关键词是否都覆盖到了，比如模拟、高精度、ST表、容斥原理等。确保每个子项都有对应的解释，并且逻辑连贯，帮助用户逐步构建知识体系。可能还需要提醒一些优化技巧，比如在枚举中剪枝，或者高精度运算时的效率问题。</think>我将分模块为您介绍C++竞赛中常用算法与数据结构，按实现难度和竞赛出现频率分层讲解： 一、基础算法（必须掌握） 1. 枚举（暴力法） - 概念：遍历所有可能解 - 应用：小数据量（n≤1e4）、状态有限问题 - 实现要点：循环嵌套层数控制，剪枝优化 - 例题：百钱买百鸡问题 2. 基础排序（时间复杂度O(n²)） ```cpp // 冒泡排序核心代码 for(int i=0; i<n-1; ++i) for(int j=0; j<n-i-1; ++j) if(a[j] > a[j+1]) swap(a[j], a[j+1]); // 插入排序核心代码 for(int i=1; i<n; ++i){ int key = a[i], j = i-1; while(j>=0 && a[j]>key){ a[j+1] = a[j]; j--; } a[j+1] = key; } ``` 二、中级算法（区域赛常用） 3. 二分查找（时间复杂度O(logn)） - 核心思想：有序序列的快速定位 - 实现要点：左右边界处理，循环终止条件 ```cpp int l=0, r=n-1; while(l <= r){ int mid = (l+r)/2; if(a[mid] >= target) r = mid-1; else l = mid+1; } return l; // 第一个>=target的位置 ``` 4. 简单数据结构 - 栈：括号匹配、表达式求值 ```cpp stack<int> s; s.push(1); s.pop(); s.top(); ``` - 队列：BFS基础结构 ```cpp queue<int> q; q.push(1); q.pop(); q.front(); ``` 三、高阶算法（省赛/区域赛关键题） 5. 分治排序（时间复杂度O(nlogn)） - 归并排序：稳定排序，逆序对计算 ```cpp void merge_sort(int l, int r){ if(l >= r) return; int mid = (l+r)/2; merge_sort(l, mid); merge_sort(mid+1, r); // 合并两个有序数组 } ``` - 快速排序：实际应用更广泛 ```cpp void quick_sort(int l, int r){ if(l >= r) return; int i=l-1, j=r+1, x=a[(l+r)>>1]; while(i < j){ do i++; while(a[i] < x); do j--; while(a[j] > x); if(i < j) swap(a[i], a[j]); } quick_sort(l, j); quick_sort(j+1, r); } ``` 6. 记忆化搜索 - 核心思想：递归+结果缓存 - 应用：斐波那契数列、网格路径计数 ```cpp int memo[MAXN]; int dfs(int state){ if(memo[state] != -1) return memo[state]; // 计算逻辑 return memo[state] = res; } ``` 四、进阶专题（国赛/ICPC级） 7. 图论-LCA（最近公共祖先） - 倍增法实现（时间复杂度O(nlogn)预处理，O(logn)查询） ```cpp int up[MAXN][20]; // 预处理祖先表 int lca(int u, int v){ if(depth[u] < depth[v]) swap(u,v); // 先跳到同一深度 for(int i=19; i>=0; --i) if(depth[up[u][i]] >= depth[v]) u = up[u][i]; if(u == v) return u; // 共同上跳 for(int i=19; i>=0; --i) if(up[u][i] != up[v][i]) u=up[u][i], v=up[v][i]; return up[u][0]; } ``` 8. ST表（区间最值查询） ```cpp int st[MAXN][20]; void init(){ for(int j=1; (1<<j)<=n; ++j) for(int i=1; i+(1<<j)-1<=n; ++i) st[i][j] = max(st[i][j-1], st[i+(1<<(j-1))][j-1]); } int query(int l, int r){ int k = log2(r-l+1); return max(st[l][k], st[r-(1<<k)+1][k]); } ``` 五、特殊技巧 9. 容斥原理 - 公式表达：$$|A_1 \cup ... \cup A_n| = \sum|A_i| - \sum|A_i \cap A_j| + ... + (-1)^{n+1}|A_1 \cap ... \cap A_n|$$ - 应用：求多个集合的并集大小 10. 高精度计算 - 实现要点：字符串处理、进位处理 ```cpp vector<int> add(vector<int>& a, vector<int>& b){ vector<int> c; int t = 0; for(int i=0; i<a.size()||i<b.size(); ++i){ if(i < a.size()) t += a[i]; if(i < b.size()) t += b[i]; c.push_back(t%10); t /= 10; } if(t) c.push_back(1); return c; } ``` 建议练习顺序：基础排序 → 二分/模拟 → 数据结构 → 分治算法 → 图论/数学。实际比赛中要注重代码模板的整理和边界条件处理，推荐配合《算法竞赛进阶指南》系统学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值