一些图论算法的代码实现

已于 2024-08-20 12:17:17 修改
阅读量136 收藏
点赞数 1
文章标签： 算法 图论 数据结构
于 2024-08-17 15:04:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45595437/article/details/141278144
版权

文章目录

朴素 Dijkstra 算法的代码实现
#include <bits/stdc++.h>

using namespace std;

const int N = 510;

int n, m;
int g[N][N], dist[N];
bool st[N]; // 集合S

void dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++) {
            if (!st[j] && (t == -1 || dist[j] < dist[t])) 
                t = j;
        }
        
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
            
        st[t] = true;
    }
}

int main() {
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);
    }
    
    dijkstra();
    
    if (dist[n] == 0x3f3f3f3f) cout << -1 << endl;
    else cout << dist[n] << endl;
    return 0;
}
堆优化 Dijkstra 算法的代码实现
#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> PII;

const int N = 2e5 + 10;

int n, m;
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    priority_queue<PII, vector<PII>, greater<PII>> pq;
    pq.push({0, 1});
    
    while (!pq.empty()) {
        auto [_, t] = pq.top(); pq.pop(); // 此处不可以用引用
        if (st[t]) continue;
        
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + w[i]) {
                dist[j] = dist[t] + w[i];
                pq.push({dist[j], j});
            }
        }
        
        st[t] = true;
    }
}

int main() {
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    dijkstra();
    
    if (dist[n] == 0x3f3f3f3f) cout << -1 << endl;
    else cout << dist[n] << endl;
    return 0;
}
Bellman-Ford 算法的代码实现
#include <bits/stdc++.h>

using namespace std;

const int N = 510, M = 1e4 + 10;

int n, m, k;
int dist[N], last[N];

struct Edge {
    int a, b, w;
}edges[M];

void bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    for (int i = 0; i < k; i++) {
        memcpy(last, dist, sizeof dist);
        for (int j = 0; j < m; j++) {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], last[a] + w);
        }
    }
}

int main() {
    cin >> n >> m >> k;
    
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }
    
    bellman_ford();
    
    if (dist[n] > 0x3f3f3f3f / 2) cout << "impossible" << endl;
    else cout << dist[n] << endl;
    return 0;
}
SPFA 算法的代码实现
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n, m;
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool st[N]; // 标记某个点是否已在队列中

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void spfa() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    queue<int> que;
    que.push(1);
    st[1] = true;
    
    while (!que.empty()) {
        auto t = que.front(); que.pop();
        st[t] = false; // 标记t已不在队列中
        
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + w[i]) {
                dist[j] = dist[t] + w[i];
                if (!st[j]) {
                    st[j] = true;
                    que.push(j);
                }
            }
        }
    }
}

int main() {
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    spfa();
    
    if (dist[n] == 0x3f3f3f3f) cout << "impossible" << endl;
    else cout << dist[n] << endl;
    return 0;
}
SPFA 判负环的代码实现
#include <bits/stdc++.h>

using namespace std;

const int N = 2010, M = 1e4 + 10;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N], cnt[N];
bool st[N];

void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

bool spfa() {
    queue<int> que;
    
    for (int i = 1; i <= n; i++) {
        que.push(i);
        st[i] = true;
    }
    
    while (!que.empty()) {
        auto t = que.front(); que.pop();
        st[t] = false;
        
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + w[i]) {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;
                if (!st[j]) {
                    que.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

int main() {
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    if (spfa()) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0;
}
Floyd 算法的代码实现
#include <bits/stdc++.h>

using namespace std;

const int N = 210;

int n, m, q;
int d[N][N];

void floyd() {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

int main() {
    cin >> n >> m >> q;
    
    memset(d, 0x3f, sizeof d);
    for (int i = 1; i <= n; i++) d[i][i] = 0;
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        d[a][b] = min(d[a][b], c);
    }
    
    floyd();
    
    for (int i = 0; i < q; i++) {
        int a, b;
        cin >> a >> b;
        if (d[a][b] > 0x3f3f3f3f / 2) cout << "impossible" << endl;
        else cout << d[a][b] << endl;
    }
    return 0;
}
Prim 算法求最小生成树
#include <bits/stdc++.h>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N], dist[N];
bool st[N];

int prim() {
    memset(dist, 0x3f, sizeof dist);
    
    int res = 0;
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++) {
            if (!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        }
        
        if (i && dist[t] == INF) return INF;
        if (i) res += dist[t];
        
        for (int j = 1; j <= n; j++) {
            dist[j] = min(dist[j], g[t][j]);
        }
        
        st[t] = true;
    }
    return res;
}

int main() {
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c); // 无向图需要添加两条有向边
    }
    
    int t = prim();
    if (t == INF) cout << "impossible" << endl;
    else cout << t << endl;
    return 0;
}
Kruskal 算法求最小生成树
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10, M = N * 2, INF = 0x3f3f3f3f;

int n, m;
int p[N];

struct Edge {
    int a, b, w;
    bool operator<(const Edge& e) {
        return w < e.w;
    }
}edges[M];

int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal() {
    sort(edges, edges + m);
    
    for (int i = 1; i <= n; i++) p[i] = i; // 初始化并查集
    
    int res = 0, cnt = 0; // res是当前最小生成树的总长度，cnt是当前最小生成树的总边数
    for (int i = 0; i < m; i++) {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a), b = find(b);
        if (a != b) {
            p[a] = b;
            res += w;
            cnt++;
        }
    }
    
    if (cnt == n - 1) return res;
    else return INF;
}

int main() {
    cin >> n >> m;
    
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }
    
    int t = kruskal();
    if (t == INF) cout << "impossible" << endl;
    else cout << t << endl;
    return 0;
}
染色法判定二分图
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10, M = N * 2; // 无向图边数为点数的2倍

int n, m;
int h[N], e[M], ne[M], idx;
int color[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool dfs(int u, int c) { // 尝试将节点u染成颜色c
    color[u] = c;
    
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (!color[j]) {
            if (!dfs(j, 3 - c)) return false; // 若为子节点染色失败，则返回false
        }
        else if (color[j] == c) return false; // 若子节点已染色但和当前节点所染颜色一样，则返回false
    }
    return true; // 若整个连通块均染色顺利，则说明当前连通块是二分图
}

int main() {
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a); // 无向图要添加两条有向边
    }
    
    bool flag = true;
    for (int i = 1; i <= n; i++) {
        if (!color[i]) {
            if (!dfs(i, 1)) { // 若没有染色成功，则说明不是二分图，应置flag为false,并立即退出
                flag = false;
                break;
            }
        }
    }
    
    if (flag) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0;
}
匈牙利算法求二分图的最大匹配
#include <bits/stdc++.h>

using namespace std;

const int N = 510, M = 1e5 + 10;

int n1, n2, m;
int h[N], e[M], ne[M], idx;
int match[N];
bool st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool find(int x) { // 为左半部的点x寻找能够匹配的邻居。若能找到，则返回true；否则，返回false
    for (int i = h[x]; i != -1; i = ne[i]) { // 遍历x的所有邻居
        int j = e[i];
        if (!st[j]) { // 如果该邻居尚未被之前的点考虑过，则
            st[j] = true; // 考虑该邻居（不管后面有没有匹配成功，都要将j标记为“已考虑过”）
            if (match[j] == 0 || find(match[j])) { // 若该邻居尚未被匹配，或能为匹配该邻居的点找到新的邻居，则
                match[j] = x; // 让该邻居匹配点x
                return true; // 返回匹配成功
            }
        }
    }
    return false; // 若遍历完所有邻居都未能匹配，则匹配失败
}

int main() {
    cin >> n1 >> n2 >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    int res = 0;
    for (int i = 1; i <= n1; i++) {
        memset(st, false, sizeof st);
        if (find(i)) res++; // find函数的功能是为点i寻找能够匹配的邻居
    }
    
    cout << res << endl;
    return 0;
}
有向图的拓扑序
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n, m;
int h[N], e[N], ne[N], idx;
int ind[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

vector<int> top_sort() {
    /* 初始时，将所有入度为0的点加入队列 */
    queue<int> que;
    for (int i = 1; i <= n; i++) {
        if (ind[i] == 0) que.push(i);
    }
    
    vector<int> res;
    while (!que.empty()) {
        auto t = que.front(); que.pop();
        res.push_back(t);
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            ind[j]--;
            if (ind[j] == 0) que.push(j);
        }
    }
    return res;
}

int main() {
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b);
        ind[b]++;
    }
    
    auto t = top_sort();
    if (t.size() == n) {
        for (auto x : t) cout << x << " ";
        cout << endl;
    }
    else cout << -1 << endl;
    return 0;
}
快速排序
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n;
int a[N];

void quick_sort(int a[], int l, int r) {
    if (l >= r) return;
    
    int x = a[l + r >> 1];
    
    int i = l - 1, j = 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(a, l, j);
    quick_sort(a, j + 1, r);
}

int main() {
    cin >> n;
    
    for (int i = 0; i < n; i++) cin >> a[i];
    
    quick_sort(a, 0, n - 1);
    
    for (int i = 0; i < n; i++) cout << a[i] << " ";
    cout << endl;
    return 0;
}
归并排序
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;

int n;
int a[N], tmp[N];

void merge_sort(int a[], int l, int r) {
    if (l >= r) return;
    
    int mid = l + r >> 1;
    merge_sort(a, l, mid);
    merge_sort(a, mid + 1, r);
    
    int i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r) {
        if (a[i] <= a[j]) tmp[k++] = a[i++];
        else tmp[k++] = a[j++];
    }
    while (i <= mid) tmp[k++] = a[i++];
    while (j <= r) tmp[k++] = a[j++];
    
    for (int i = l, j = 0; i <= r; i++, j++) a[i] = tmp[j];
}

int main() {
    cin >> n;
    
    for (int i = 0; i < n; i++) cin >> a[i];
    
    merge_sort(a, 0, n - 1);
    
    for (int i = 0; i < n; i++) cout << a[i] << " ";
    cout << endl;
    
    return 0;
}
defacto'
关注
最短路径 Dijkstra算法的Matlab代码实现
乐观的lishan的博客
09-11 6万+
本文实现了dijkstra算法的Matlab代码，并封装成一个函数，给定一个邻接矩阵，以及指定一个终点，可以直接输出任意点到终点的最短路径和相应的距离值
图论算法整理
happyBrooke的博客
04-21 1432
图论算法整理 图算法专题的一些基础知识。 文章目录图论算法整理一、图的遍历二、最短路算法1.Dijkstra算法2.Bellman-Ford和SPFA算法3.Floyd算法三、最小生成树算法1.prim算法2.kruskal算法四、拓扑排序总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、图的遍历 DFS 深度优先搜索 #include <iostream> #include <vector> using namespace std; #define MAXV 100
数模常用算法——图论算法简介&代码实现
热门推荐
JiandaoStudio
06-19 1万+
图与网络优化概述 目录 1. 求 两个指定顶点之间的最短路径（Dijkstra算法） 2. 求每对顶点之间的最短距离（Floyd算法） 3.最小代价生成树 3.1 prim算法模板，当前测试点下标从0开始，输出从1开始： 3.2 kruskal算法模板： 4. 网络流 4.1最大流算法（最简单的EK算法） 4.2 二分最大权匹配 KM算法模板 4.3 最小...
图论算法及其matlab实现 程序,图论算法及其matlab程序代码.doc
weixin_29505469的博客
03-21 1176
图论算法及其matlab程序代码.doc 图论算法及其MATLAB程序代码求赋权图GV,E,F中任意两点间的最短路的WARSHALLFLOYD算法设AAIJNN为赋权图GV,E,F的矩阵,当VIVJ∈E时AIJFVIVJ,否则取AII0,AIJ∞I≠J,DIJ表示从VI到VJ点的距离,RIJ表示从VI到VJ点的最短路中一个点的编号①赋初值对所有I,J,DIJAIJ,RIJJK1转向②②更新DIJ,...
[算法基础系列]图论基础算法详解
m0_64710378的博客
06-27 1074
需要熟悉的概念：（1）有向图和无向图（2）子图（3）连通，连通图和连通分量（4）生成树（5）顶点的度，入度和出度（6）边的权和网（7）稠密图和稀疏图yon（8）路径长度和回路。
图论基础算法
csdnwqy030429的博客
01-23 3356
图论基础问题图的存储与遍历拓扑排序最短路算法最小生成树二分图 图的存储与遍历 拓扑排序 最短路算法 最小生成树 二分图
C++算法集锦：图论
05-06 1678
图论最小生成树 最小生成树 牛客连接： 最小生成树 解法1 思路：kruskal算法+并查集 利用kruskal的思想，每次选择最短的路径，加入到候选集和中，从而最终连通整个图。 这里同时采用并查集的思想，每次将一条对一条候选路径进行选择的时候，判断两个端点是否拥有共同父亲，如果拥有则表明这两个点之间已经存在被加入候选集合中了，放弃这条边；如果没有拥有共同父亲，则将两个点连接，即指定一个点为另一个点的父亲，并且选择这条边加入连通图。最终，判断完所有的路径。 class Solution { publ
C++基础图论算法大集合 （图论，看我就行了）
qq_43514659的博客
04-06 5890
图论搜索技术深度优先搜索 （应用——求重心）广度优先搜索 （应用——图中的层次遍历）有向图的拓扑排序最短路问题Dijkstra算法（朴素版）Dijkstra算法 （堆优化）bellman_ford算法spfa算法spfa判负权Floyd算法最小生成树系列prim算法二分图判断二分图（染色法）二分图的最大匹配 搜索技术 深度优先搜索 （应用——求重心） 重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。 本题的本质是树的dfs， 每次dfs可以确定以u
算法-图论
jingyu_1的博客
07-15 1221
以下内容部分来自陈小玉老师的算法ppt，将图论中常见的算法进行汇总。包括图的存储以及图论的经典算法（最短路径、最小生成树）等。部分代码转自陈小玉老师的《算法训练营》。主要汇总了常用的图的存储和算法，建议初学者直接看B站的相关视频。...
数学建模：图论算法
weixin_45745854的博客
07-25 3140
数学建模：图论算法 1.图论的概念及问题引入 1.1 图 1.1.1概念 图论中所谓的“图”是指某类具体事物和这些事物之间的联系,如果我们用点表示这些具体事物,用连接两点的线段(直的或曲的)表示两个事物的某种联系,就得到了描述这个“图”的几何形象。 1.1.2 引例 最短路径问题 一名货车司机想要在最短的时间内将一车货物从甲 地运往乙地.从甲地到乙地有多种行车路线,这名司 机应选择哪条线路呢?假设货车的运行速度是恒定 的,那么这一问题相当于需要找到一条从甲地到乙地的最短路 公路连接问题 某一地区有若
MATLAB算法图论算法代码
04-15
标题中提到的“MATLAB算法图论算法代码”意味着这是一个专门针对图论问题的算法实现集合，该集合通过MATLAB编程语言来表达。图论算法可以包括但不限于最短路径算法（如迪杰斯特拉算法Dijkstra和贝尔曼-福特算法...
图论算法代码.zip_fun2g1_matlab_图论算法
07-14
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
图论算法及其MATLAB实现（完整版）
04-30
《图论算法及其MATLAB实现》是一本深入探讨图论算法与其实现的书籍，尤其强调了使用MATLAB这一强大的科学计算工具进行编程实践。图论是计算机科学和数学的一个重要分支，它研究的是点（节点）和点之间的连接线（边）...
数学建模MATLAB代码图论算法代码
03-10
本文介绍了MATLAB在数学建模中的应用及其在图论算法中的实现方法。通过上述讨论可以看出，MATLAB不仅提供了丰富的内置函数来简化编程工作，还允许用户根据具体需求自定义算法。此外，通过具体的代码示例展示了...
tulunsuanfa.rar_图论_图论算法_图论算法实现_算法
09-20
接下来，我们将探讨一些**基础图论算法**： 1. **深度优先搜索（DFS）**：从一个顶点出发，尽可能深地探索图的分支，直到访问所有可达顶点。在回溯过程中，标记已访问的顶点，避免重复访问。 2. **广度优先搜索...
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1277
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 367
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 1001
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
图论算法MATLAB实现指南
全书共分为9个章节，每个章节都专注于解决特定类型的图论问题，并提供相应的MATLAB代码实现。 第1章是图论基础，讲解了图的基本概念，如可达矩阵的计算、关联矩阵与邻接矩阵的转换等，这些都是图论分析的基础。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值