图核心算法（c++）

最新推荐文章于 2022-06-17 12:34:11 发布
最新推荐文章于 2022-06-17 12:34:11 发布
阅读量249 收藏
点赞数
分类专栏： 面试 c++ 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxiaoyikesu/article/details/119359825
版权
c++ 同时被 3 个专栏收录
31 篇文章 0 订阅
订阅专栏
面试
27 篇文章 0 订阅
订阅专栏
数据结构与算法
22 篇文章 0 订阅
订阅专栏

1. 拓扑排序

leetcode207

这道题对应拓扑排序，有向图是否有环的问题

1.1 BFS（广度优先搜索）

第一次做法

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 0.初始化准备
        unordered_set<int> temp;
        vector<unordered_set<int>> adj_list(numCourses, temp); //先修课程->所有后续课程
        vector<unordered_set<int>> inv_adj_list(numCourses, temp); //后续课程->所有先修课程
        unordered_set<int> learned; //已学习课程
        // 1.建图
        for (auto &m : prerequisites) {
            inv_adj_list[m[0]].insert(m[1]);
            adj_list[m[1]].insert(m[0]);
        }
        // 2.模拟学习过程
        queue<int> q;
        while (1) {
            // 2.1 找出未学习且可学习的课程，入队
            for (int i=0; i<inv_adj_list.size(); ++i) {
                if (0 == learned.count(i) && inv_adj_list[i].empty()) {
                    q.push(i);
                    learned.insert(i);
                }
            }
            // 2.2 若没有可学习的课程则退出
            if (q.empty()) break;
            // 2.3 更新inv_adj_list
            while (!q.empty()) {
                int curr = q.front();
                q.pop();
                for (auto &m : adj_list[curr]) {
                    if (0 == learned.count(m)) {
                        inv_adj_list[m].erase(curr);
                    }
                }
            }
        }
        // 3.判断是否能够完成
        return learned.size() == numCourses;
    }
};

空间复杂度： O(E)，E为边的数量

直接使用prerequisites， 可以不使用inv_adj_list，节省空间，第二次做法如下：

class Solution {
private:

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 1.初始化图
        vector<vector<int>> adj_list(numCourses); //先修课程->后续课程
        vector<int> indeg(numCourses, 0); //入度数组
        queue<int> q;
        unordered_set<int> learned;
        for (auto &m : prerequisites) {
            ++indeg[m[0]];
            adj_list[m[1]].push_back(m[0]);
        }

        // 2.模拟学习
        while (1) {
            // 2.1 入度为0入队
            for (int i=0; i<indeg.size(); ++i) {
                if (0 == learned.count(i) && 0 == indeg[i]) {
                    q.push(i);
                    learned.insert(i);
                }
            }
            // 2.2 队为空，退出循环，否则将队的尺寸加入结果
            if (q.empty()) {
                break;
            }
            // 2.3 出队，同时将该课程的后续课程的入度减1
            while (!q.empty()) {
                int curr = q.front();
                q.pop();
                for (auto &m : adj_list[curr]) {
                    --indeg[m];
                }
            }
        }
        // 3.判断结果
        return learned.size() == numCourses;
    }
};

更好的解法，拓扑排序

无向图

有向图（可以分为有向无环图和有向有环图）

 新的存储方法：

出度，入度

可以使用入度数组，记录每个结点的入度（BFS）

也可以使用出度数组，记录每个结点的

答案中的方法是在出队的时候更改入度时，顺便判断入度是否为0，若是压入队列，可以省略上面搜索入度为0的步骤，提升速度

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 1.初始化图
        vector<vector<int>> adj_list(numCourses); //先修课程->后续课程
        vector<int> indeg(numCourses); //入度数组
        for (const auto &m : prerequisites) {
            ++indeg[m[0]];
            adj_list[m[1]].push_back(m[0]);
        }
        // 2.首次生成队列
        queue<int> q;
        for (int i=0; i<indeg.size(); ++i) {
            if (0 == indeg[i]) q.push(i);
        }
        // 3.主循环
        int learned = 0;
        while (!q.empty()) {
            // 3.1 出队，记录结果
            int curr = q.front();
            q.pop();
            ++learned;
            // 3.2 更改后续课程的入度，若入度为0，压入队列
            for (const auto &m : adj_list[curr]) {
                --indeg[m];
                if (0 == indeg[m]) q.push(m);
            }
        }
        // 4.返回结果
        return learned == numCourses;
    }
};

 时间复杂度O(V+E)，V为课程数量，对应结点数，E对应先修要求，对应边，因为无边的结点和所有的边都会被处理一次，所以时间复杂度为O(V+E)

空间复杂度，主要是adj_list和indeg，前一个对应边的数量，后一个对应结点数量，所以空间复杂度是O(V+E)

这种解法可以说是BFS，也可以说是Kahn算法，这是一种贪心算法的引申

这道题当然也可以采用DFS的思路，不过BFS更加直观自然

1.2 DFS（深度优先搜索）

思路：dfs的思想或者说Kahn算法，就是先一条路走到黑，它更像是判断有向图是否有环，从这个逻辑出发，每个dfs完成的是判断从该节点出发是否存在环，对于一个节点有3种状态，使用visited存储：

  • visited = 0，未搜索
  • visited = 1, 搜索中
  • visited = 2, 已搜索

若搜索到该节点时已搜索则不处理直接返回，若是搜索中说明出现了环，设置结果后返回，若是未搜索，首先将当前结点的状态设置为搜索中，然后对该结点的所有下一个结点继续运行dfs，每次运行时都要判断valid是否为true，若为false，则说明有环，直接返回

而在主函数中做初始化的工作，还有就是对所有的结点都使用dfs进行处理

class Solution {
private:
    // 需要的变量
    vector<vector<int>> adj_list; //先修课程->所有后续课程
    vector<int> visited; //记录结点状态，0为未搜索，1为搜索中，2为已搜索，如果搜索时发现一个结点是搜索中的说明有环
    bool valid = true; //记录结果,初始为能够完成课程，若存在环说明不能完成，设置为false
    // 判断从一个结点出发是否有环
    void dfs (int i) {
        if (2 == visited[i]) return; //1.该结点为已搜索，直接返回
        if (1 == visited[i]) { //2.该结点为搜索中，存在环，设置后返回
            valid = false;
            return;
        }
        //3.该结点为未搜索，继续搜索它的后续结点
        visited[i] = 1; //设置为搜索中
        for (auto &m : adj_list[i]) { 
            dfs(m);
            if (!valid) return;
        }
        visited[i] = 2; //4.设置为已搜索
    }
public:
    // 使用dfs解决判断有向图是否有环的问题
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 1.初始化准备
        visited.resize(numCourses);
        adj_list.resize(numCourses);
        for (auto &m : prerequisites) {
            adj_list[m[1]].push_back(m[0]);
        }
        // 2.正式处理
        for (int i=0; i<numCourses; ++i) {
            if (!valid) break;
            dfs(i);
        }
        // 3.返回结果
        return valid;
    }
};

时间复杂度：首先会遍历边，复杂度为O(E)，而对于dfs处理，最多对于每一个结点都会处理一次，复杂度是O(V)，合起来就是O(E+V)

空间复杂度方面adj_list和visited合起来就是O(E+V)，递归栈的深度最多不会超过边的个数，所以合起来是O(E+V)

2. 岛屿的数量

思路：无向图，邻接矩阵，BFS/DFS，图的遍历，辅助队列

遍历二维网格，发现一块陆地，则沉没一座岛屿（使用队列实现），计数，返回结果

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        // 0.异常处理
        if (grid.size() == 0) return 0;
        // 1.初始化准备
        // 1.1 运动数组
        vector<pair<int, int>> moves;
        moves.push_back(make_pair(0,-1));
        moves.push_back(make_pair(0,1));
        moves.push_back(make_pair(-1,0));
        moves.push_back(make_pair(1,0));
        queue<pair<int, int>> q;
        int ans = 0;
        int rows = grid.size();
        int cols = grid[0].size();

        // 2.遍历网格
        for (int i=0; i<rows; ++i) {
            for (int j=0; j<cols; ++j) {
                if ('0' == grid[i][j]) continue;
                q.push(make_pair(i, j));
                grid[i][j] = '1';
                ++ans;

                // 2.1 每次使用队列，处理（沉没）一座岛屿，计数
                while (!q.empty()) {
                    auto temp = q.front();
                    q.pop();

                    // 判断四周是否是岛屿
                    for (auto &m : moves) {
                        // 判断边界与水域
                        int new_i = m.first + temp.first;
                        int new_j = m.second + temp.second;
                        if (new_i >= rows || new_i < 0 || new_j >= cols || new_j < 0 || grid[new_i][new_j] == '0') continue;
                        q.push(make_pair(new_i, new_j));
                        grid[new_i][new_j] = '0';
                    }
                }
            }
        }
        
        // 3.返回结果
        return ans;
    }
};

 时间复杂度O(E)，E是边的数量，每条边会被处理一次，所以时间复杂度时O(E)

空间复杂度O(min(M,N))，M是行数，N是列数

3. 有效的数独

4. 省份数量

leetcode547

思路：使用BFS，使用邻接表，队列，标记数组等数据结构

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        if (0 == isConnected.size()) return 0;
        // 1.初始化准备
        vector<vector<int>> adj_list(isConnected.size()); //邻接表
        vector<bool> visited(isConnected.size(), false); //标记结点是否被访问过
        int ans = 0; //最终答案
        for (int i=0; i<isConnected.size(); ++i) {
            for (int j=0; j<isConnected[0].size(); ++j) {
                if (j == i) continue; //去掉本身
                if (1 == isConnected[i][j]) adj_list[i].push_back(j);
            }
        }

        // 2.遍历邻接表
        queue<int> q;
        for (int i=0; i<adj_list.size(); ++i) {
            if (visited[i]) continue;
            else {
                q.push(i);
                ++ans;
                visited[i] = true;
                // 将连通的结点遍历完
                while (!q.empty()) {
                    int temp = q.front();
                    q.pop();
                    for (auto &m : adj_list[temp]) {
                        if (!visited[m]) {
                            q.push(m);
                            visited[m] = true;
                        }
                    }
                }
            }
        }

        return ans;   
    }
};

 时间复杂度O(E^2)+O(E)，总的是O(E^2)

空间复杂度O(V+E)

可以进一步优化，直接使用邻接矩阵，不使用邻接表，节省空间

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        if (0 == isConnected.size()) return 0;
        // 1.初始化准备
        vector<bool> visited(isConnected.size(), false); //标记结点是否被访问过
        int ans = 0; //最终答案

        // 2.遍历邻接表
        queue<int> q;
        for (int i=0; i<isConnected.size(); ++i) {
            if (visited[i]) continue;
            else {
                q.push(i);
                ++ans;
                visited[i] = true;
                // 将连通的结点遍历完
                while (!q.empty()) {
                    int temp = q.front();
                    q.pop();
                    for (int j=0; j<isConnected[temp].size(); ++j) {
                        if (!visited[j] && isConnected[temp][j] == 1) {
                            q.push(j);
                            visited[j] = true;
                        }
                    }
                }
            }
        }

        return ans;   
    }
};

 时间复杂度O(E)，总的是O(E)

空间复杂度O(V)，V为节点数量，E是边的数量

5. 最小路径搜索

实现参考geeksforgeeks实现

所需数据结构：

使用邻接表存放图vector<vector<pair<int, int>>> adj

需要实时更新未标记结点中到达起点的距离最小的结点，可以用set<pair<int, int>> setds，pair指的是weight, vertex，set底层是红黑树，红黑树的高度近似 log2n，所以它是近似平衡，插入、删除、查找操作的时间复杂度都是 O(logn)。setds存放的信息是根据目前已经知道的信息，未标记的结点距离起始点的最短距离。

需要最短路径中当前结点的上一个结点, 可以用vector<int> last

还需要一个vector<int> 来存放跟踪目前信息，当前结点到起点的最短距离

注意这里的标记的意思是该结点到起始结点的最小距离已经知道了

思路：

1. 每次从setds取出最小元素，对应未标记的结点中距离起始点最近的结点，然后把它从setds中删除

2.遍历该结点相邻的边，如果发现通过这些边到达的结点的最短路径（存放在dist中）可以更小，则更新dist, last以及setds

#include <bits/stdc++.h>
using namespace std;

/**
 * @brief 生成邻接表
 * @param edges 边 [src, dst, weight]
 * @param adj 邻接表
 */
void GenerateAdjList(vector<vector<int>> &edges, vector<vector<pair<int, int>>> &adj) {
    // 注意无向图，需要插入两条边
    for (auto &m : edges) {
        adj[m[0]].push_back(make_pair(m[1],m[2]));
        adj[m[1]].push_back(make_pair(m[0], m[2]));
    }
}

/**
 * @brief 求src到dst的最短距离和对应的路径
 * @param edges 所有边的信息
 * @param src 源结点
 * @param dst 目标结点
 * @param path 最短路径信息
 * @return 最短路径长度
 */
int ShortestPath(vector<vector<pair<int, int>>> &adj, int count, int src, int dst, vector<int> &path) {
    // 1.初始化准备
    set<pair<int, int>> setds; //pair is <weight, vertex>，用于快速找到未标记的距离起点最近的结点
    vector<int> dist(count, INT_MAX); //存放距离信息, vertex -> distance
    vector<int> last(count); //存放最短路径中该结点的上一个结点

    // 2.源结点设置
    setds.insert(make_pair(0, src));
    dist[src] = 0;
    last[src] = 0;

    // 3.正式处理
    while (!setds.empty()) {
        // 3.1 取出未标记的距离起点最近的结点
        auto shortest = *(setds.begin());
        setds.erase(setds.begin());
        int u = shortest.second;

        // 3.2 遍历最近点的边
        for (auto &i : adj[u]) {
            int v = i.first;
            int weight = i.second;

            // 更新dist和setds
            if (dist[v] > dist[u] + weight) {
                // 如果不是第一次，则删除setds中原来的元素
                if (dist[v] != INT_MAX) {
                    setds.erase(setds.find(make_pair(dist[v], v)));
                }
                dist[v] = dist[u] + weight;
                last[v] = u;
                setds.insert(make_pair(dist[v], v));
            }
        }
    }

    // 4.求出最短路径
    int curr = dst;
    path.push_back(dst);
    while (curr != src) {
        path.push_back(last[curr]);
        curr = last[curr];
    }
    reverse(path.begin(), path.end()); //反转路径

    return dist[dst];
}

int main() {
    vector<vector<int>> edges;
    edges.push_back(vector<int>{0, 1, 4});
    edges.push_back(vector<int>{0, 7, 8});
    edges.push_back(vector<int>{1, 2, 8});
    edges.push_back(vector<int>{1, 7, 11});
    edges.push_back(vector<int>{2, 3, 7});
    edges.push_back(vector<int>{2, 8, 2});
    edges.push_back(vector<int>{2, 5, 4});
    edges.push_back(vector<int>{3, 4, 9});
    edges.push_back(vector<int>{3, 5, 14});
    edges.push_back(vector<int>{4, 5, 10});
    edges.push_back(vector<int>{5, 6, 2});
    edges.push_back(vector<int>{6, 7, 1});
    edges.push_back(vector<int>{6, 8, 6});
    edges.push_back(vector<int>{7, 8, 7});

    // 生成邻接表
    int count = 9;
    vector<vector<pair<int, int>>> adj(count); //dst,weight
    GenerateAdjList(edges, adj);

    // 生成最短路径
    vector<int> shortest_path;
    int length = ShortestPath(adj, count, 0, 4, shortest_path);
    for (auto &m : shortest_path) {
        cout << m << " ";
    }
    cout << endl;
    cout << "Total length: " << length << endl;
    return 0;
}

时间复杂度O(ElogV)，因为对每条边都有常量级的处理操作，每次操作比如往set插入元素，或者删除元素的复杂度为O(logV)，所以最终的时间复杂度为O(ElogV)

空间复杂度为O(E+V)，其中E是边的数量，V是结点的数量 

相关题目：leetcode743

class Solution {
private:
    void shortestTime(vector<vector<pair<int, int>>> &adj_list, int src, vector<int> &times) {
        // 1.初始化准备
        set<pair<int, int>> setts; //pair是[w, v]
        setts.insert(make_pair(0, src));
        times[src] = 0;

        // 2.正式处理
        while (!setts.empty()) {
            // 2.1 处理setts首元素,移除
            auto temp = *(setts.begin());
            setts.erase(setts.begin());
            int u = temp.second;

            // 2.2 处理首元素的所有下一个结点
            for (auto &m : adj_list[u]) {
                int v = m.first; //下一个结点
                int w = m.second; //到达下一个结点花费时间

                //若未标记结点存在更短路径则更新相应数据
                if (times[v] > times[u] + w) {
                    //对于已经存在于setts中的结点需要先删除
                    if (INT_MAX != times[v]) {
                        setts.erase(setts.find(make_pair(times[v], v))); //注意先要找到迭代器
                    }
                    //更新
                    times[v] = times[u] + w;
                    setts.insert(make_pair(times[v], v));
                }
                
            }
        }
        
    }
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        // 1.初始化准备
        vector<vector<pair<int, int>>> adj_list(n); //pair指[v,w]
        vector<int> shortest_times(n, INT_MAX); //从结点到达该结点的最短时间
        for (auto &m : times) {
            adj_list[m[0]-1].push_back(make_pair(m[1]-1, m[2])); //注意题目中结点序号从1开始
        }

        // 2.求从k出发到达其他所有结点的最短时间
        shortestTime(adj_list, k-1, shortest_times);

        // 3.返回结果
        // 3.1 如果存在不可到达的结点，那么返回-1(可以通过shortest_times的元素最大值是否是INT_MAX来判断)
        // 3.2 所有最短时间的最大时间就是网络延迟时间
        int ans = *max_element(shortest_times.begin(), shortest_times.end());
        return ans == INT_MAX ? -1 : ans;
    }
};

时间复杂度O(ElogV)，空间复杂度O(E+V) 

6. A*算法

对Dijkstra算法的改造，启发式搜索算法利用估价函数，避免“跑偏”，贪心地朝着最有可能到达终点的方向前进。这种算法找出的路线，并不是最短路线。Dijkstra算法每次是从距离起点距离最小的结点出发，使用队列进行处理，而A*算法同时考虑到终点的距离，启发式地进行搜索。

CrazyFox%
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 图算法
inuyasha1027的专栏
06-15 2047
在计算机科学中 图算法占据着很重要的地位，无论是在地图中的最短lu
图算法《c++算法》（二）
yshuise的专栏
01-24 1402
//d路堆#ifndef PQI_INCLUDE_H#define PQI_INCLUDE_H#include vector>using std::vector;template class keyType>class PQi...{private:    int d;    int N;    vectorint>p, q;    const vectorkeyType>&a;public:
图算法（c++模板）
11-01
用c++模板写的图算法，包括广搜、深搜、最小生成树算法（prim、kruskal）、单源最短路径（bellman-ford、dijkstra）、拓扑排序，prim、dijkstra算法使用优先级队列实现
图算法《c++算法》（一）
yshuise的专栏
01-20 1488
// DenseGRAPH.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include iostream>#include vector>#include queue>using namespace std;class DenseGRAPH...{private:    vect
算法—图（C++实现)
m0_58086930的博客
09-18 717
1.定义 class Edge; class Node { public: int value;//点的值 int in;//入度 int out;//出度 list<Node*> nexts;//由该节点射出的点 list<Edge*> edges;//由该节点射出的边 Node(int val) { value = val; in = 0;out = 0; } }; class Edge {//有向边，无向边可由有向边转化 public: int we
C++图算法
weixin_33889665的博客
03-25 311
C++算法-图算法-03 ...
C++算法-图算法（pdf版）
06-23
c++算法-图算法(第三版)一书的pdf版
遗传算法c++代码_遗传算法C++_
10-03
本文将深入探讨遗传算法的核心概念及其在C++中的实现细节。 首先，遗传算法的基本步骤包括初始化种群、适应度评价、选择、交叉和变异。初始化种群是随机生成一组解决方案，每组解决方案称为一个个体，代表可能的解...
社区发现中的GN算法C++实现
01-05
在C++实现GN算法时，首先要理解算法的核心步骤。GN算法主要包括以下部分： 1. **构建网络模型**：网络通常表示为图（Graph），其中节点（Node）代表网络中的个体，边（Edge）表示它们之间的关系。C++中可以使用图...
带权重的A*算法C++、CMake实现
01-19
在给定的“带权重的A*算法C++、CMake实现”中，我们可以深入探讨以下几个关键知识点： 1. **A*算法的核心思想**：A*算法的核心在于评估每个节点的f(n)值，该值由g(n)（从起点到当前节点的实际成本）和h(n)（从当前...
C++算法-图算法
12-13
介绍关于图的算法，C++语言描述。介绍关于图的算法，C++语言描述。
算法V（C++实现）图算法 C++算法：图算法 （第3版
05-27
算法经典书籍 普林斯顿大学教授大作，用c++描述，利于学习算法及c++
核心算法的c++表达.cpp
最新发布
06-28
核心算法的c++表达.cpp
ECC.zip_C++ 椭圆_ECC算法_椭圆 加密_椭圆曲线ecc_椭圆曲线算法
09-20
在C++环境下实现ECC算法，可以有效地进行数据加密与解密，保障信息安全。 首先，我们来理解椭圆曲线的基本概念。椭圆曲线是一类代数几何对象，其数学表达形式为：y^2 = x^3 + ax + b，其中a和b是常数，且满足一定...
图的基本算法——C/C++
Strive_LiJiaLe的博客
04-19 394
图的结构体定义 typedef struct vertex { int number; //顶点的编号 }VertexType; //别名，顶点的类型 typedef struct matrix { int n; //顶点个数 int e; //边数 int adjMat[MAXV][MAXV]; //邻接矩阵数组 VertexType ver[MAXV]; //存放顶点信息 }MatGraph; //别名，完整的
图算法实现及其应用C++
weixin_51626421的博客
06-17 1281
数据结构课程设计之图算法实现及其应用
C++算法集锦：图论
05-06 1587
图论最小生成树 最小生成树 牛客连接： 最小生成树 解法1 思路：kruskal算法+并查集 利用kruskal的思想，每次选择最短的路径，加入到候选集和中，从而最终连通整个图。 这里同时采用并查集的思想，每次将一条对一条候选路径进行选择的时候，判断两个端点是否拥有共同父亲，如果拥有则表明这两个点之间已经存在被加入候选集合中了，放弃这条边；如果没有拥有共同父亲，则将两个点连接，即指定一个点为另一个点的父亲，并且选择这条边加入连通图。最终，判断完所有的路径。 class Solution { publ
C++实现图算法（一）
热门推荐
Ai
03-21 1万+
图算法（一） 对图的顶点和边进行了封装。
用C++写的图的算法。
jerryjerryone的专栏
08-25 494
1.用到了设计模式里的template method,首先定义了一个图的虚基类GRAPH,在里面定义了一些虚方法的接口，然后在GRAPH里用这些虚方法实现了图的各个算法(BFS,DFS,Prim,Kruskal,Dijkstra,Floyd)。然后在GRAPH的子类AdjMatrixGRAPH和AdjListGRAPH里分别用邻接表和邻接矩阵表示图，并实现GRAPH中定义的接口，这样图的算法与图的
C++学习路径与核心算法解析
"C++学习线路图，提供了一个逐步学习C++的推荐书籍列表，并结合基础算法知识进行讲解，帮助学习者系统掌握C++编程语言和算法应用。" C++是一门强大的面向对象编程语言，它广泛应用于系统编程、游戏开发、科学计算等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值