《算法竞赛进阶指南》 0x68 ~ 0x67 代码 + 杂谈

最新推荐文章于 2021-05-24 22:15:52 发布
最新推荐文章于 2021-05-24 22:15:52 发布
阅读量464 收藏
点赞数
分类专栏： 题集 《算法竞赛进阶指南》杂谈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40831340/article/details/98471218
版权

二分图最大匹配

之前 一直没有学匈牙利 只写DINIC 匈牙利也挺简单的 关键是好写多了orz

关押罪犯

https://blog.csdn.net/qq_40831340/article/details/88821278

棋盘覆盖

我依稀的记得 第一次见到是DP来着

#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int cx[] = {-1, 0, 1, 0};
const int cy[] = {0, 1, 0, -1};

int n, k;
bool mp[maxn][maxn], vis[maxn * maxn];

int head[maxn * maxn], match[maxn * maxn], cnt;
int nxt[maxn * maxn << 2], to[maxn * maxn << 2];


void ade(int a, int b) {
    to[++cnt] = b;
    nxt[cnt] = head[a], head[a] = cnt;
}

int ids(int i, int j) {
    return (i) * n + j;
}

bool chk(int i, int j) {
    if(i < 1 || i > n || j < 1 || j > n) return 0;
    if(mp[i][j]) return 0;
    return 1;
}

bool dfs(int x) {
    for(int i = head[x], y; i; i = nxt[i]) {
        if(!vis[y = to[i]]) {
            vis[y] = 1;
            if(!match[y] || dfs(match[y])) {
                match[y] = x; return true;
            }
        }
    }
    return false;
}

int main() {
    cin >> n >> k;
    for(int i = 1, a, b; i <= k; i ++) {
        cin >> a >> b;
        mp[a][b] = 1;
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = (i % 2 ? 1 : 2); j <= n; j += 2) {
            for(int z = 0; z < 4; z ++) {
                if(chk(i + cx[z], j + cy[z]))
                    ade(ids(i, j), ids(i + cx[z], j + cy[z])), ade(ids(i + cx[z], j + cy[z]), ids(i, j));
            }
        }
    }
    
    int ans = 0;
    for(int i = 1; i <= n; i ++) {
        for(int j = (i % 2 ? 1 : 2); j <= n; j += 2) {
            if(mp[i][j]) continue;
            memset(vis, 0, sizeof vis);
            if(dfs(ids(i, j))) ans ++;
        }
    }
    cout << ans << endl;
    return 0;
}
车的放置

把行和列当 左右匹配点

#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
const int cx[] = {-1, 0, 1, 0};
const int cy[] = {0, 1, 0, -1};

int n, m, k;
bool mp[maxn][maxn], vis[maxn * maxn];

int head[maxn * maxn], match[maxn * maxn], cnt;
int nxt[maxn * maxn << 2], to[maxn * maxn << 2];


void ade(int a, int b) {
    to[++cnt] = b;
    nxt[cnt] = head[a], head[a] = cnt;
}

bool chk(int i, int j) {
    if(i < 1 || i > n || j < 1 || j > n) return 0;
    if(mp[i][j]) return 0;
    return 1;
}

bool dfs(int x) {
    for(int i = head[x], y; i; i = nxt[i]) {
        if(!vis[y = to[i]]) {
            vis[y] = 1;
            if(!match[y] || dfs(match[y])) {
                match[y] = x; return true;
            }
        }
    }
    return false;
}

int main() {
    cin >> n >> m >> k;
    for(int i = 1, a, b; i <= k; i ++) {
        cin >> a >> b;
        mp[a][b] = 1;
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++) {
            if(!mp[i][j]) ade(i, j + n),ade(j + n, i);
        }
    }
    
    int ans = 0;
    for(int i = 1; i <= n; i ++) {
            memset(vis, 0, sizeof vis);
            if(dfs(i)) ans ++;
    }
    cout << ans << endl;
    return 0;
}
导弹防御塔

https://blog.csdn.net/qq_40831340/article/details/97746759

二分图 带权匹配

一般费用流最大价值 边取反处理
补上 蚂蚁那道题 既然线不相交 那样 他们之间距离就会保持最小

#include <bits/stdc++.h>
#define fastio ios::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 2e4 + 10;

int n, m, s, t;
int head[maxn], cnt;
int nxt[maxn << 1], to[maxn << 1], cap[maxn << 1];
double cost[maxn << 1];
int ans[maxn];

void ade(int a, int b, int w, double c) {
    to[cnt] = b, cost[cnt] = c, cap[cnt] = w;
    nxt[cnt] = head[a], head[a] = cnt++;
}

bool vis[maxn];
double dis[maxn];
int flow[maxn], pre[maxn], last[maxn];

bool spfa() {
    queue<int> que;
    memset(flow, 0x3f, sizeof(flow));
    memset(vis, 0, sizeof(vis));
    fill(dis, dis + 2 * n + 3, 1e12);
    que.push(s);
    vis[s] = 1;
    dis[s] = 0;
    pre[t] = -1;
    flow[s] = INF;
    while(!que.empty()) {
        int now = que.front(); que.pop();
        vis[now] = 0;
        for(int i = head[now]; ~i ; i = nxt[i]) {
            if(cap[i] && dis[to[i]] > dis[now] + cost[i]) {
                dis[to[i]] = dis[now] + cost[i];
                pre[to[i]] = now;
                last[to[i]] = i;
                flow[to[i]] = min(flow[now], cap[i]);
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    que.push(to[i]);
                }
            }
        }
    }
    return pre[t] != -1;
}

double mincost;
int maxflow;

void MCMF() {
    while(spfa()) {
        int now = t;
        maxflow += flow[t];
        mincost += 1.0 * flow[t] * dis[t];
        while(now != s) {
            cap[last[now]] -= flow[t];
            cap[last[now] ^ 1] += flow[t];
            now = pre[now];
        }
    }
}

struct point {
    int x, y;
} a[105], b[105];

double redis(int i, int j) {
    return sqrt((a[i].x - b[j].x) * (a[i].x - b[j].x) + (a[i].y - b[j].y) * (a[i].y - b[j].y));
}

signed main() {
    fastio;
    memset(head, -1, sizeof(head));
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i].x >> a[i].y;
    for(int i = 1; i <= n; i ++) cin >> b[i].x >> b[i].y;
    s = 0, t = 2 * n + 1;
    
    for(int i = 1; i <= n; i++) {
        ade(s, i, 1, 0), ade(i, s, 0, 0);
        ade(i + n, t, 1, 0), ade(t, i + n, 0, 0);
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= n; j ++) {
            double len = redis(i, j);
            ade(i, j + n, 1, len), ade(j + n, i, 0, -len);
        }
    }
    MCMF();
    
    for(int u = 1; u <= n; u++) {
        for(int i = head[u]; ~i; i = nxt[i]) {
            if(cap[i] == 0) ans[u] = to[i] - n;
        }
    }
    
    for(int i = 1; i <= n; i++) {
        cout << ans[i] << endl;
    }
    // cout << maxflow << " " << mincost << endl;
    return 0;
}

二分图覆盖

最小点覆盖 = 最大匹配
相对于二分图匹配完的边 每个边上二者至少选一个 覆盖所有边

任务机器
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;

int n, m, k;
int head[maxn << 1], match[maxn << 1], cnt;
int nxt[maxn << 1], to[maxn << 1];
bool vis[maxn << 1];

void ade(int a, int b) {
    to[++cnt] = b;
    nxt[cnt] = head[a], head[a] = cnt;
}

bool dfs(int x) {
    for(int i = head[x], y; i; i = nxt[i]) {
        if(!vis[y = to[i]]){
            vis[y] = 1;
            if(!match[y] || dfs(match[y])){
                match[y] = x; return true;
            }
        }
    } 
    return false;
}

int main() {
    while(cin >> n && n) {
        cin >> m >> k;
        memset(head, 0, sizeof head);
        memset(match, 0, sizeof match);
        cnt = 0;
        for(int i = 1, a, b, c; i <= k; i ++) {
            cin >> c >> a >> b;
            if(a == 0 || b == 0) continue;
            ade(a, b + n + 1), ade(b + n + 1, a);
        }
        int ans = 0;
        for(int i = 1; i <= n; i ++){
            memset(vis, 0, sizeof vis);
            if(dfs(i)) ans ++ ;
        }
        cout << ans << endl;
    }
    
    return 0;
}
泥泞的区域

与网络流一样 还是建图是最难写的地方。。。。。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;

int n, m;
char mp[maxn][maxn];
int h[maxn][maxn], l[maxn][maxn];
int head[maxn], match[maxn], cnt;
int nxt[maxn << 1], to[maxn << 1];
bool vis[maxn];

void ade(int a, int b) {
    to[++ cnt] = b;
    nxt[cnt] = head[a], head[a] = cnt;
}

bool dfs(int x) {
    for(int i = head[x], y; i; i = nxt[i]) {
        if(!vis[y = to[i]]) {
            vis[y] = 1;
            if(!match[y] || dfs(match[y])) {
                match[y] = x; return true;
            }
        }
    }
    return false;
}

int main() {
    scanf ("%d %d", &n, &m);
    for(int i = 1; i <= n; i ++) scanf("%s", mp[i] + 1);
    int tot = 0;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++) {
            if(mp[i][j] == '*') {
                if(mp[i][j - 1] == '*') h[i][j] = tot;
                else h[i][j] = ++tot;
            }
        }
    }
    
    for(int i = 1; i <= m; i ++) {
        for(int j = 1; j <= n; j ++) {
            if(mp[j][i] == '*') {
                if(mp[j - 1][i] == '*') l[j][i] = tot;
                else l[j][i] = ++tot;
            }
        }
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++) {
            if(l[i][j] && h[i][j]) {
                ade(l[i][j], h[i][j]), ade(h[i][j], l[i][j]);
            }
        }
    }
    // for(int i = 1; i <= n; i ++) {
    //     for(int j = 1; j <=m;j ++) {
    //         cout << h[i][j] << " ";
    //     }cout << endl;
    // }
    
    // for(int i = 1; i <= n; i ++) {
    //     for(int j = 1; j <=m;j ++) {
    //         cout << l[i][j] << " ";
    //     }cout << endl;
    // }
    
    int ans = 0;
    for(int i = 1; i <= tot; i ++) {
        memset(vis, 0, sizeof vis);
        if(dfs(i)) ans ++;
    }
    cout << ans / 2<< endl;
    return 0;
}

二分图最大独立集

任何点之间 都没有边链接

骑士放置
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;

int n, m, k;
int mp[105][105];
int head[maxn], match[maxn], cnt;
int nxt[maxn << 1], to[maxn << 1];
bool vis[maxn];

const int cx[10]={-1, -2, -1, -2, 1, 2, 1, 2};
const int cy[10]={-2, -1, 2, 1, -2, -1, 2, 1};

int ids(int i, int j) {
    return (i - 1) * m + j;
}

bool chk(int x, int y) {
    if(x < 1 || y < 1 || x > n || y > m || mp[x][y]) return 1;
    else return 0;
}

void ade(int a, int b) {
    to[++ cnt] = b;
    nxt[cnt] = head[a], head[a] = cnt;
}

bool dfs(int x) {
    for(int i = head[x], y; i; i = nxt[i]) {
        if(!vis[y = to[i]]) {
            vis[y] = 1;
            if(!match[y] || dfs(match[y])) {
                match[y] = x; return true;
            }
        }
    }
    return false;
}

int main() {
    cin >> n >> m >> k;
    for(int i = 1, a, b; i <= k; i ++) {
        cin >> a >> b;
        mp[a][b] = 1;
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++) {
            if(mp[i][j]) continue;
            for(int z = 0; z < 8; z ++) {
                int nx = i + cx[z], ny = j + cy[z];
                if(chk(nx, ny)) continue;
                ade(ids(i, j), ids(nx, ny));
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++ ) {
            if(mp[i][j]) continue;
            memset(vis, 0, sizeof vis);
            if(dfs(ids(i, j))) ans ++;
        }
    }
    cout << n * m - ans/2 - k << endl;
    return 0;
}
ANT

带权二分图匹配 费用流写法

#include <bits/stdc++.h>
#define fastio ios::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 2e4 + 10;

int n, m, s, t;
int head[maxn], cnt;
int nxt[maxn << 1], to[maxn << 1], cap[maxn << 1];
double cost[maxn << 1];
int ans[maxn];

void ade(int a, int b, int w, double c) {
    to[cnt] = b, cost[cnt] = c, cap[cnt] = w;
    nxt[cnt] = head[a], head[a] = cnt++;
}

bool vis[maxn];
double dis[maxn];
int flow[maxn], pre[maxn], last[maxn];

bool spfa() {
    queue<int> que;
    memset(flow, 0x3f, sizeof(flow));
    memset(vis, 0, sizeof(vis));
    fill(dis, dis + 2 * n + 3, 1e12);
    que.push(s);
    vis[s] = 1;
    dis[s] = 0;
    pre[t] = -1;
    flow[s] = INF;
    while(!que.empty()) {
        int now = que.front(); que.pop();
        vis[now] = 0;
        for(int i = head[now]; ~i ; i = nxt[i]) {
            if(cap[i] && dis[to[i]] > dis[now] + cost[i]) {
                dis[to[i]] = dis[now] + cost[i];
                pre[to[i]] = now;
                last[to[i]] = i;
                flow[to[i]] = min(flow[now], cap[i]);
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    que.push(to[i]);
                }
            }
        }
    }
    return pre[t] != -1;
}

double mincost;
int maxflow;

void MCMF() {
    while(spfa()) {
        int now = t;
        maxflow += flow[t];
        mincost += 1.0 * flow[t] * dis[t];
        while(now != s) {
            cap[last[now]] -= flow[t];
            cap[last[now] ^ 1] += flow[t];
            now = pre[now];
        }
    }
}

struct point {
    int x, y;
} a[105], b[105];

double redis(int i, int j) {
    return sqrt((a[i].x - b[j].x) * (a[i].x - b[j].x) + (a[i].y - b[j].y) * (a[i].y - b[j].y));
}

signed main() {
    fastio;
    memset(head, -1, sizeof(head));
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i].x >> a[i].y;
    for(int i = 1; i <= n; i ++) cin >> b[i].x >> b[i].y;
    s = 0, t = 2 * n + 1;
    
    for(int i = 1; i <= n; i++) {
        ade(s, i, 1, 0), ade(i, s, 0, 0);
        ade(i + n, t, 1, 0), ade(t, i + n, 0, 0);
    }
    
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= n; j ++) {
            double len = redis(i, j);
          //  cout << len << endl;
            ade(i, j + n, 1, len), ade(j + n, i, 0, -len);
        }
    }
    MCMF();
    
    for(int u = 1; u <= n; u++) {
        for(int i = head[u]; ~i; i = nxt[i]) {
            if(cap[i] == 0) ans[u] = to[i] - n;
        }
    }
    
    for(int i = 1; i <= n; i++) {
        cout << ans[i] << endl;
    }    
    // cout << maxflow << " " << mincost << endl;
    return 0;
}

有向无环图最小路径点覆盖 待续

ZHXU1998
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现0x68转十进制,C语言的进制转换及算法实现教程
weixin_39912984的博客
05-22 1923
1、其他进制转十进制1.1、二进制转十进制转换规程： 从最低位开始，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和，例如：二进制 1011 = 1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 = 1 + 2 + 0 + 8 = 111.2、八制转十进制转换规则： 从最低位开始，将每个位上的数提取出来，乘以8的(位数-1)次方，然后求和，例如：八进制 0123 = 3*8^0...
0x68.图论 - 二分图的匹配
繁凡さん的博客
06-24 643
二分图 概述 二分图又称作二部图，是图论中的一种特殊模型。设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边(i,j)所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图。 如上图就是一个标准的二分图 性质： 二分图不存在长度为奇数的环 一、二分图的判定 此题来源于《挑战程序设计竞赛》 DFS vector<int> G[MAX_V];//图的表示 int V;//顶点数 int color[M
ASCII三种进制对照表、二进制、字节
无趣的博客
05-24 3万+
一、ASCII三种进制对照表 换行、空格等对照表 二、JAVA代码中，各种进制的表现形式： 十进制表示：104 二进制表示：0b01101000 十六进制表示：0x68 总结：二进制前加0b，十六进制前加0x 三、JAVA中类型长度： byte：1个字节8位； short：2个字节16位； int：4个字节32位； long：8个字节64位； 浮点型： float：4个字节32位； double：8个字节64位； 注：默认的是double类型，如3.14是double类型的，加F（3.14F）就是dou
c# 常见问题解决
bupt10212029的专栏
07-05 743
由于最近参与了实验室的一个项目，是用c#语言
leetcode中国-ACAG-Code:《算法竞赛进阶指南》（AlgorithmCompetitionAdvancedGuide）中例题和习
06-29
《算法竞赛进阶指南》练习代码 《算法竞赛进阶指南》全部例题和习题的练习代码，希望能给大家带来帮助，如有错误欢迎批评指正。 总进度：0/323 关于作者：WHZ0325 QQ：1669135547 Blog：（书中题目的题解以后会整理...
电脑启动不了错误代码0x80070002(1).pdf
11-17
电脑启动不了错误代码0x80070002(1).pdf
VL53L0X激光测距模块硬件资料+源代码+详细教程100%好用.zip
最新发布
09-17
《VL53L0X激光测距模块：硬件详解与应用指南》 VL53L0X是一款由意法半导体（STMicroelectronics）推出的高性能、小型化的飞行时间（Time-of-Flight, TOF）激光测距传感器。这款模块在物联网、智能家居、机器人导航...
共享的打印机突然不能打印，提示添加打印机错误代码0x0000011b
04-23
共享打印机突然不能打印，提示添加打印机错误代码0x0000011b 原因大部分是共享打印机的主机系统win10更新了补丁，补丁代码为KB5005569/KB5005573/KB5005568/KB5005566/KB5005565等。 win10更新后导致共享打印机失效...
AT24C0X存储芯片读写源代码_brainov4_AT24C0x存储芯片的源代码_
10-01
这篇"AT24C0X存储芯片读写源代码"是针对51单片机平台用C语言编写的，51系列单片机是广泛应用的经典微控制器，以其简单易用和资源适中的特性，在教学和小型项目中十分常见。源代码的编写通常会涉及以下几个关键知识点...
MPU6050写地址不对应问题
嵌入式学习记录站点
10-15 2058
手册中所说的地址0x68是指7bit的器件地址，其中最低位状态由AD0引脚的电平指示。不过在咱们真正在I2C中送地址的时候，前7bit是其设备地址，第8bit是读写控制位，所以，0xd0中的最后一位就是那个读写控制位，如果看其前7bit的话，还是0x68的二进制形式。 ...
H264帧类型判断
骠姚校尉的博客
09-20 1万+
我们经常在网络直播推流或者客户端拉流的时候，需要对获取到的H.264视频帧进行判断后处理，我们经常获取到各种不同的视频数据0x67 0x68 0x65 0x61，0x27 0x28 0x25 0x21，0x47 0x48 0x45 0x41，各种不同的编码芯片有时间出来的NAL Header规则不大一样，那么我们怎么来以统一的方式判断帧的类型呢：sps、pps、IDR、P 如下转自EasyDar...
h264 NAL头解析
热门推荐
occupy8的专栏
06-06 3万+
NAL全称Network Abstract Layer，即网络抽象层。在H.264/AVC视频编码标准中，整个系统框架被分为了两个层面：视频编码层面（VCL）和网络抽象层面（NAL）。其中，前者负责有效表示视频数据的内容，而后者则负责格式化数据并提供头信息，以保证数据适合各种信道和存储介质上的传输。NAL单元是NAL的基本语法结构，它包含一个字节的头信息和一系列来自VCL的称为原始字节序列载荷（R
H264 数据帧理解（转载总结）
轻飘飞扬
11-10 8449
根据H.264的不同类别，编码器会使用不同类型的帧，例如I帧、P帧和B帧。I帧（帧内编码帧）是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码。视频序列中的第一个帧始终都是I帧。如果所传输的比特流遭到破坏，则需要将I帧用作新查看器的起始点或重新同步点。I帧可以用来实现快进、快退以及其它随机访问功能。如果新的客户端将参与查看视频流，编码器将以相同的时间间隔或者根据要求自动插入I帧。I帧的缺
H264(NAL简介与I帧判断)
weixin_30548917的博客
11-27 824
http://blog.csdn.net/jefry_xdz/article/details/8461343 1、NAL全称Network Abstract Layer, 即网络抽象层。在H.264/AVC视频编码标准中，整个系统框架被分为了两个层面：视频编码层面（VCL）和网络抽象层面（NAL）。其中，前者负责有效表示视频数据的内容，而后者则负责格式化数据并提供头信息，以保证...
x86实模式下访问32位寄存器/指令
一点点
09-18 960
1、在16位实模式下，默认访问数据的大小是8位或者16位的；控制转移和内存访问时，偏移量也是16位的； 2、处理器在16位实模式下运行时，可以使用32位的寄存器，执行32位运算； 当处理器运行16位实模式下，既然把所有指令都看成16位的，那么怎么使用32位的寄存器，执行32位的运算呢？ 答案是利用指令前缀0x66和0x67。指令前缀0x66用来选择非默认值的操作数大小，0x67用来选择非默认值的地...
【C语言入门教程】2.5 字符型数据
weixin_33750452的博客
07-18 208
字符型数据用于在计算机上保存字符编码和一些文本控制命令，多个字符型数据和字符串结束符组成的序列称为字符串。Linux 系统与其他大多数操作系统一样，支持 ASCII编码对字符编码，每个字符占用 1 个字节的存储空间。   2.5.1 字符常量 字符常量是指用一对单引号包围起来的一个字符，例如'c'，'3'，'%'。字符常量中的单引号只起定界作用并不表示字符本身。单引号中的字符不能是单引号和反...
算法竞赛数论：0x50筛法与线性筛详析
"本文主要介绍了算法竞赛中用于数论计算的几种高效筛法，包括0x50筛法、0x51线性筛法及其变种，如求欧拉函数、莫比乌斯函数、约数个数函数和约数和函数。同时提到了杜教筛和Min_25筛等其他筛法，这些方法常用于解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值