【专题总结】网络流与二分图（持续更新）

最新推荐文章于 2022-04-19 11:54:10 发布
最新推荐文章于 2022-04-19 11:54:10 发布
阅读量538 收藏
点赞数
分类专栏： Topic
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TRiddle/article/details/52506868
版权

POJ 2112

大意

农夫约翰有 k 台挤奶机和 c 只奶牛。任意两个实体（挤奶机或奶牛）都在不同的地点，因此它们之间有相隔距离。每个挤奶机可以为 m 只奶牛挤奶。问怎样分配挤奶机使得任意两个实体之间的最长距离最小（每个奶牛都要分配到挤奶机，题目保证有解）。

思路

显然这是最小化最大值问题，适合用二分查找解决。于是我们可以二分最小值 x ，看看在最长距离小于等于 x 的情况下是否有满足要求的分配方案。于是问题转化成了分配问题，根据题目给出的数据范围我们可以尝试用网络流来解决。建图方式如下：

  • 因为每个挤奶机都只能供 m 只牛使用，所以想到建立超级源点，从超级源点到代表挤奶机的节点连接容量为 m 的边。
  • 因为每个挤奶机可以供距其距离小于 x 的牛使用，所以想到为距其距离小于 x 的奶牛对应的节点连容量为 1 的边。

    • 因为我们要判定是否有合法的分配方案，所以想到建立超级汇点，从每个奶牛对应的节点连接一条容量为1的边。

    • 然后对这个图求最大流，若最大流值等于奶牛的数量的话存在合法的分配方案，否则不存在。

      另外题中的两两实体之间的距离用多源最短路的算法就能够求出来了。

      代码

      #include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 300, INF = 1e8;
int n, s, t, l, r, K, C, M, mid;
int G[maxn][maxn], d[maxn][maxn];

// 最大流用的边
struct edge {
    int from, to, cap;
    edge(int from, int to, int cap): from(from), to(to), cap(cap) {}
};

// 求最大流的Dinic算法
struct dinic {
    int level[maxn];
    int iter[maxn];
    vector <edge> edges;
    vector <int> G[maxn];
    void addedge(int u, int v, int w) {
        G[u].push_back(edges.size());
        edges.push_back(edge(u, v, w));
        G[v].push_back(edges.size());
        edges.push_back(edge(v, u, 0));
    }
    void init(int n) {
        edges.clear();
        for(int i = 1; i <= n; i++) {
            G[i].clear();
        }
    }
    bool bfs(int s, int t) {
        queue <int> q;
        q.push(s);
        memset(level, -1, sizeof(level));
        level[s] = 0;
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            for(int i = 0; i < G[u].size(); i++) {
                edge& e = edges[G[u][i]];
                if(e.cap > 0 && level[e.to] < 0) {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return level[t] > 0;
    }
    int dfs(int u, int t, int f) {
        if(u == t) {
            return f;
        }
        for(int& i = iter[u]; i < G[u].size(); i++) {
            edge& e = edges[G[u][i]];
            if(e.cap > 0 && level[e.to] > level[u]) {
                int d = dfs(e.to, t, min(f, e.cap));
                if(d > 0) {
                    e.cap -= d;
                    edges[G[u][i]^1].cap += d;
                    return d;
                }
            }
        }
        level[u] = -1;
        return 0;
    }
    int max_flow(int s, int t) {
        int flow = 0;
        for(; bfs(s, t);) {
            memset(iter, 0, sizeof(iter));
            for(int f; (f = dfs(s, t, INF)) > 0; flow += f);
        }
        return flow;
    }
}o;

// 求多源最短路的floyd算法
void floyd() {
    for(int k = 1; k <= n; k++) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(d[i][k] == INF || d[k][j] == INF) {
                    continue;
                }
                d[i][j] = min(d[i][j], d[i][k] + d[j][k]);
            }
        }
    }
}

// 二分查找中用于判断最长距离x是否合法的函数
bool ok(int x) {
    o.init(n);
    for(int i = 1; i <= K; i++) {
        o.addedge(s, i, M);
    }
    for(int i = 1; i <= K; i++) {
        for(int j = K + 1; j <= K + C; j++) {
            if(d[j][i] > x) {
                continue;
            }
            o.addedge(i, j, 1);
        }
    }
    for(int i = K + 1; i <= K + C; i++) {
        o.addedge(i, t, 1);
    }
    int f = o.max_flow(s, t);
    if(f < C) {
        return false;
    }
    return true;
}

int main() {
    scanf("%d%d%d", &K, &C, &M);
    n = K + C;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            scanf("%d", &G[i][j]);
            d[i][j] = G[i][j] ? G[i][j] : (i == j ? 0 : INF);
        }
    }
    floyd();
    s = 0;
    t = K + C + 1;
    l = -1;
    r = INF;
    // 二分查找
    while(r - l > 1) {
        mid = (l + r) >> 1;
        if(ok(mid)) {
            r = mid;
        }
        else {
            l = mid;
        }
    }
    printf("%d\n", r);
    return 0;
}

      HDU 3315

      大意

      在一次游戏中，我方和对方各有 n 枚棋子。对方棋子出战顺序是固定的，而我方棋子的出战顺序是任意的（有一个初始顺序但可以改动）。每个棋子有攻击力和生命值两个属性，与对方棋子战斗的时候，每回合可以让对方棋子的生命值减少其攻击力的值。当我方棋子第 i 次出战时战胜对方棋子，我方可赢得 vi 分数，否则则输掉 vi 分数。问怎样安排我方棋子的出战顺序，使得我方得到的分数最大，还要求出顺序改动的百分比，当分数同样时优先选择顺序改动最小的方案。

      思路

      这是一个匹配问题，由于在匹配的情况下还要求某个权值最大，因此可以选择的模型有最小费用最大流和最大权匹配。这里用最小费用最大流解决。建图方式如下：

      • 因为双方棋子可以任意配对，所以从我方棋子到对方所有棋子连边，以保证双方每两个棋子之间都有边相连。
      • 因为对战结果是可以预测的，所以每条边的费用是此边相连的两个棋子能给我方带来的分数的相反数（因为只能求最小费用）。
      • 因为还要知道顺序改动的情况，所以先将每条边的费用乘 1000 ，如果这条边连接的对手棋子的编号与我方棋子的初始编号相同的话将边权减 1 （本应该加 1 ，但是因为边权要取相反数所以变为减 1 ）以示奖励。乘 1000 的原因就是为了不让奖励分数影响到主要分数。
      • 建立超级源点和超级汇点，超级源点到所有我方棋子之间都要连边，对方棋子到所有超级汇点之间也都要连边，这些边的费用为 0 。
      • 所有边的流量都为 1 。

      然后对图求最小费用最大流。其中的最小费用为 ans 。那么我方能够获得的最大分数就是 −ans/1000 。改变的顺序就是 −ans\mathchoicemod1000 。

      代码

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

const int maxn = 100, maxv = 3 * maxn, maxVal = 1000, INF = 1e7;
int c, n, s, t, N, ans, score, similar;
int v[maxn], h[maxn], p[maxn], a[maxn], b[maxn];

// 图中的边
struct edge {
    int from, to, cap, flow, cost;
    edge(int from, int to, int cap, int flow, int cost):
        from(from), to(to), cap(cap), flow(flow), cost(cost) {}
};

// 最小费用最大流算法
struct MCMF {
    int v;
    vector <edge> edges;
    vector <int> G[maxv];
    int inq[maxv];                  // 是否在队列中
    int d[maxv];                    // Bellman-Ford
    int p[maxv];                    // 上一条弧
    int a[maxv];                    // 可改进量
    void init(int v) {
        this->v = v;
        for(int i = 0; i < v; i++) {
            G[i].clear();
        }
        edges.clear();
    }
    void addEdge(int from, int to, int cap, int cost) {
        G[from].push_back(edges.size());
        edges.push_back(edge(from, to, cap, 0, cost));
        G[to].push_back(edges.size());
        edges.push_back(edge(to, from, 0, 0, -cost));
    }
    bool BellmanFord(int s, int t, int& flow, int& cost) {
        for(int i = 0; i < v; i++) {
            d[i] = INF;
        }
        memset(inq, 0, sizeof(inq));
        d[s] = 0;
        inq[s] = 1;
        p[s] = 0;
        a[s] = INF;
        queue <int> q;
        q.push(s);
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            inq[u] = 0;
            for(int i = 0; i < G[u].size(); i++) {
                edge& e = edges[G[u][i]];
                if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
                    d[e.to] = d[u] + e.cost;
                    p[e.to] = G[u][i];
                    a[e.to] = min(a[u], e.cap - e.flow);
                    if(!inq[e.to]) {
                        q.push(e.to);
                        inq[e.to] = 1;
                    }
                }
            }
        }
        if(d[t] == INF) return false; // s-t不连通，失败退出
        flow += a[t];
        cost += d[t] * a[t];
        for(int u = t; u != s; u = edges[p[u]].from) {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
        }
        return true;
    }
    int Mincost(int s, int t) {
        int flow = 0, cost = 0;
        while(BellmanFord(s, t, flow, cost));
        return cost;
    }
}o;

// 用于判断胜负的函数
inline int beat(int x, int y) {
    int tx = h[x] / b[y] + (h[x] % b[y] > 0);
    int ty = p[y] / a[x] + (p[y] % a[x] > 0);
    return tx >= ty;
}

int main() {
    while(scanf("%d", &n), n) {
        // 输入部分
        for(int i = 1; i <= n; i++) {
            scanf("%d", &v[i]);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%d", &h[i]);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%d", &p[i]);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%d", &b[i]);
        }
        // 建图部分
        s = 0;
        t = 2 * n + 1;
        N = t + 1;
        o.init(N);
        for(int i = 1; i <= n; i++) {
            o.addEdge(s, i, 1, 0);
        }
        for(int i = 1; i <= n; i++) {
            o.addEdge(n + i, t, 1, 0);
        }
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                c = (beat(i, j) ? -1 : 1) * maxVal * v[i] - (i == j);
                o.addEdge(i, n + j, 1, c);
            }
        }
        // 计算结果部分
        ans = o.Mincost(s, t);
        score = -ans / maxVal;
        similar = -ans % maxVal;
        if(score > 0) {
            printf("%d %.3f%%\n", score, 100.0 * similar / n);
        }
        else {
            puts("Oh, I lose my dear seaco!");
        }
    }
    return 0;
}

      HDU 3395

      大意

      有 n 个鱼，它们会攻击认为是异性的鱼，然后被攻击的鱼就会产卵。每只鱼有一个权值，鱼卵的权值为该鱼卵的双亲的权值得异或和。问所有鱼卵的权值之和是多少？

      思路

      该问题也是一个类似于分配的问题。由于题目中涉及“最大权值之和”，因此适合建模为二分图带权匹配或最小费用最大流（将原权值变为相反数）。这里采用最小费用最大流的方法，建图方法如下：

      • 根据题给矩阵，只要一只鱼认为另一只鱼是异性，那么就给这两条鱼连一条容量为 1 ，权值为两只鱼权值异或和的相反数的边。注意，这里将一只鱼拆成两个点，分别代表攻击者和被攻击者。

      • 因为每条鱼只能攻击一次，所以建立超级源点，从超级源点向所有代表攻击者的点连容量为 1 ，边权为 0 的边。
      • 因为每条鱼只能被攻击一次，所以建立超级汇点，从每个被攻击者对应的点向超级汇点连容量为 1 ，边权为 0 的边。
      • 因为最小费用最大流算法先满足最大流然后才考虑最小费用，因此一定要让图满流（还要不影响权值）。方法是让所有攻击者向超级汇点连容量为 1 ，权值为 0 的边。（即使有鱼没有攻击机会，仍然能够满流）

      • 然后对图求最小费用最大流。假设最小费用是 ans ，那么答案就是 −ans 。

        代码

        #include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int maxn = 1010, INF = 1e6;

// 图中的边
struct edge {
    int from, to, cap, flow, cost;
    edge(int from, int to, int cap, int flow, int cost):
        from(from), to(to), cap(cap), flow(flow), cost(cost) {}
};

// 最小费用最大流算法
struct MCMF {
    int v;
    vector <edge> edges;
    vector <int> G[maxn];
    int inq[maxn];             // 是否在队列中
    int d[maxn];               // Bellman-Ford
    int p[maxn];               // 上一条弧
    int a[maxn];               // 可改进量
    void init(int v) {
        this->v = v;
        for(int i = 0; i < v; i++) {
            G[i].clear();
        }
        edges.clear();
    }
    void addEdge(int from, int to, int cap, int cost) {
        G[from].push_back(edges.size());
        edges.push_back(edge(from, to, cap, 0, cost));
        G[to].push_back(edges.size());
        edges.push_back(edge(to, from, 0, 0, -cost));
    }
    bool BellmanFord(int s, int t, int& flow, int& cost) {
        for(int i = 0; i < v; i++) {
            d[i] = INF;
        }
        memset(inq, 0, sizeof(inq));
        d[s] = 0;
        inq[s] = 1;
        p[s] = 0;
        a[s] = INF;
        queue <int> q;
        q.push(s);
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            inq[u] = 0;
            for(int i = 0; i < G[u].size(); i++) {
                edge& e = edges[G[u][i]];
                if(e.cap > e.flow && d[e.to] > d[u] + e.cost) {
                    d[e.to] = d[u] + e.cost;
                    p[e.to] = G[u][i];
                    a[e.to] = min(a[u], e.cap - e.flow);
                    if(!inq[e.to]) {
                        q.push(e.to);
                        inq[e.to] = 1;
                    }
                }
            }
        }
        if(d[t] == INF) return false; // s-t不连通，失败退出
        flow += a[t];
        cost += d[t] * a[t];
        for(int u = t; u != s; u = edges[p[u]].from) {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
        }
        return true;
    }
    int Mincost(int s, int t) {
        int flow = 0, cost = 0;
        while(BellmanFord(s, t, flow, cost));
        return cost;
    }
}o;

char G[maxn][maxn];
int n, s, t, ans, v[maxn];

int main() {
    while(scanf("%d", &n), n) {
        for(int i = 1; i <= n; i++) {
            scanf("%d", &v[i]);
        }
        for(int i = 1; i <= n; i++) {
            scanf("%s", G[i] + 1);
        }
        // 建图部分
        s = 0;
        t = 2 * n + 1;
        o.init(2 * n + 2);
        for(int i = 1; i <= n; i++) {
            o.addEdge(s, i, 1, 0);
        }
        // 为了满流连的边
    for(int i = 1; i <= n; i++) {
        o.addEdge(i, t, 1, 0);
    }
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(G[i][j] == '0') {
                    continue;
                }
                o.addEdge(i, n + j, 1, - (v[i] ^ v[j]));
            }
        }
        for(int i = 1; i <= n; i++) {
            o.addEdge(n + i, t, 1, 0);
        }
        ans = o.Mincost(s, t);
        printf("%d\n", -ans);
    }
    return 0;
}
TRiddle
关注
专栏目录
二分图和网络流
weixin_45874139的博客
08-15 1141
网络流和二分匹配 二分图 如果一张图的n个节点能分成两部分，使每个部分的点之间没有连边，这个图就是二分图。 二分图的判断 定理：一张无向图是二分图，当且仅当图中不存在奇环。 简单证明：如果一张图里不存在环，可以将节点沿着链以左右交替的顺序放入左右两部分，此时图明显是一个二分图。如果一张图存在环，也可以从任意一节点开始将节点沿环放入左右部分，但是起始点和最终点应该属于不同部分，不然当连接起始点和最终点的时候就会产生同一个部分中的连边，不符合二分图定义。显然，当环的长度奇数时起始点最终点一定在同一部分，而偶环
网络流&二分图匹配
NEW_moon_11的博客
08-02 304
网络流 最大流 问题简述： 有一个有向图，存在源点 SSS 和汇点 TTT，每条边有一个流量，求从 SSS 到 TTT 最多能经过多少流量。 例如，在下图中： 最大流为4。 最小割 割：表示一个切面或切线，将网络分为分别包含源点和汇点的两个子集，该切线或切面与网络相交的边的集合，称为图像的割。 最小割：网络的所有割中，边权值和最小的割。 具体解释还可以参考百度百科。 显然的，最大流=最小割。 Ford-Fulkerson算法 基本思想： 这是一种贪心思想，只要存在从源点到汇点的路径，我们就沿着其中一个扩充
二分图专题系列各大知识点总结（匈牙利，染色法，最大独立集，最小点覆盖，最小路径覆盖）
weixin_45630722的博客
05-10 432
本文概论 二分图的判断方法：图中不存在奇数环----->染色法判断二分图不存在矛盾 二分图： 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图。 染色判断： 二分图判断可分为：连通图判断和非连通图判断 染色思路: 1)初始所有定点未染色 2)随意取出一个未染色的顶点u,把它染成一种颜色(假设为0)。 3)取出与它连接的结点v,如果v未染色，则将v
二分图 与 网络流
qq_52383696的博客
07-29 251
Route Redundancy 题意： 给定一张n个点m条边的有向图，边具有流量限制，给定起点与终点 问整张图从起点到终点的“最大总流量”与“单条路径的最大流量”的比值是多少 思路： 先根据要求建图跑一遍最大流，最大总流量便能求出 “单条路径的最大流量”也就是此时网络中从起点到终点的最长路，搜索即可 用dfs来搜索能减少时间复杂度（别问，问就是用 bfs TLE了） 当前边的流量，就是起点 u -> 终点 v 这条边的反向边的容量，再在搜索过程中更新每个节点即可 int n,m,id,s,t; st
二分图的最小顶点覆盖 最大独立集 最大团
weixin_34234721的博客
11-06 257
二分图的最小顶点覆盖 定义：假如选了一个点就相当于覆盖了以它为端点的所有边。最小顶点覆盖就是选择最少的点来覆盖所有的边。 方法：最小顶点覆盖等于二分图的最大匹配。 我们用二分图来构造最小顶点覆盖。 对于上面这个二分图，顶点分为左右两个集合，X集合包含1,2,3,4，Y集合包含5,6,7,8,9.假如现在我们已经找到一个最大匹配M，就是上面的红线所标注的M={(1,7),(2,5),(4...
二分图&网络流
....
04-19 939
二分图 定义 二分图，又称二部图，英文名叫 Bipartite graph。 二分图是什么？节点由两个集合组成，且两个集合内部没有边的图。 换言之，存在一种方案，将节点划分成满足以上性质的两个集合。 性质 如果两个集合中的点分别染成黑色和白色，可以发现二分图中的每一条边都一定是连接一个黑色点和一个白色点。 二分图不存在长度为奇数的环 因为每一条边都是从一个集合走到另一个集合，只有走偶数次才可能回到同一个集合。 二分图判定 染色法 O(m+n)O(m+n)O(m+n) 题目链接 首先随意选取一个未染色的
二分图与网络流
solemntee的博客
03-06 360
一、二分图匹配（匈牙利算法） 匈牙利算法的本质是在二分图里面搜索增广路，因为每条增广路取反可以使最大匹配+1。 可以证明：如果在某一时刻，找不到以x为起点的增广路，则增广几轮之后仍不会找到。 所以只需要遍历一次左部的点，对于每个点寻找一次增广路即可。 需要注意的是vis[i]的功能，因为增广路为u−>to−>u′−>to′...u->to->u'->to'...u−>to−>u′−>to′...因为我们知道增广路没有环，所以需要标记vis[to]vis[
网络流二分图课件
01-04
网络流二分图是图论中的一个重要概念，它在计算机科学，尤其是算法设计与分析领域中有着广泛的应用。网络流问题通常涉及到在一个有向图中从一个源节点向一个汇节点输送“流量”，其中每条边都有一个容量限制，流量不...
异构网络融合环境下基于加权二分图的网络选择算法
01-19
摘要：在异构网络融合场景中，为了合理利用异构网络资源，提出了一种基于加权二分图的网络选择算法。将网络选择过程映射为寻找最优加权二分图的过程，用户和网络双方的需求经数学建模后进行供需最优匹配，供需匹配有...
匈牙利算法及二分图知识专题讲解
05-07
这是一个专题训练讲解，内有匈牙利算法详细阐述及二分图知识，并且有各种在线提交系统上的相关题目描述及解析，并附有完整的代码，希望给各位对匈牙利算法的学习带来帮助！
网络流+二分图模板
AAAAAAAC的博客
08-12 270
最大流 //是否拆点慎重考虑，如果是无向边，就不加0的反边了 //最小割即为最大流，拆点，其他边权为0x3f3f3f3f,点与点’之间为点值，然后求最大流就可，//注意是否无向，是否需要加方向 例：POJ 1087 A Plug for UNIX #include&lt;bits/stdc++.h&gt;//最大流模板 #define maxn 210000 #define INF 2...
网络流&二分图学习总结
Mathon
08-04 640
网路流 最大流问题：给出一个联通的不带边权的有向图，给出源点s和汇点t，将边当作一条有容量限制（单位时间内只能流固定容量的水）的带方向（水流只能从向边的方向流动）的水管。求解单位时间内从s到t最多能流动多少水量。Ford-Fulkerson算法：思路： Ford-Fulkerson算法是一种贪心算法，该算法的核心在于当流量f经过边e的时候，同时建立e的一条容量为f的反向边，然后利用满足f(e) <
USACO Section 4.2 The Perfect Stall - 网络流求最大二分图匹配..
zzyzzy12
01-13 1527
用网络流求二分图匹配的方法在算法导论上就看到过了..只是一直没去实现..确实用网络流来解二分图匹配有点大材小用了..一般的求最大匹配用匈牙利算法轻轻松松一分钟啊..但是网络流的解法虽然写起来多..但思想也是很简单的...对二分图左边加一个超级源点...超级源点对左边所有点做一条容量为1的边..右边给个超级汇点..右边所有点对超级汇点做一条容量为1的边..而左边所有点的点按照所给的关系对右边做边..
【二分图匹配入门专题1】O - Assignment hdu2853【km巧妙变形】
weixin_30687587的博客
08-14 100
Last year a terrible earthquake attacked Sichuan province. About 300,000 PLA soldiers attended the rescue, also ALPCs. Our mission is to solve difficulty problems to optimization the assignment of tro...
二分图专题
curry___的博客
05-15 315
Fire Nethdu1045 题意：在一个最多4×4的方格中，类似于求棋盘问题，只是有些点变成了“墙”，对于同一行或同一列如果有墙，墙两边的点是没有影响的。 思路：对于普通的棋盘问题，只需要把每一行或每一列当成一个点建图就可以了，但这个因为有墙的存在显然不行了， 可以想到对于普通的棋盘问题在没有墙的时候对于每一行每一列正好是一行一个点，一列一个点，所以也就是连续的 “.” 当成一个点，所...
线性规划与优化：从基础到网络流和二分图匹配
"该资源详细介绍了线性规划、网络流和二分图匹配这三个重要的算法概念，并通过实例进行解析。" 线性规划是一种优化技术，用于在满足一系列线性约束条件下最大化或最小化一个线性目标函数。在给定的例子中，目标是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值