hdu 1733 Escape

最新推荐文章于 2019-09-21 03:11:28 发布
最新推荐文章于 2019-09-21 03:11:28 发布
阅读量87 收藏
点赞数

拆点，假设 T 时间可以完全撤离，那么每个点就拆成2*T个点，为什么是2*T个点呢？因为在两点间还要有一个流量的限制，所以个数变成T的两倍。点和点之间的容量限制很原始，因为每位置最多只能有一个人，所以正向流量是1，因为时间是正向流动的，所以逆向容量是0.

最后根据实验，这题的答案不会超过50。亏哥还用了个二分搜索加dinic，早知道直接用ek加暴力枚举，更快更好写！！！如果不是最大流就增加一层，这样的话复杂度最多50*E ，100ms之内估计就能搞定~

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif

#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)         for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a)        for( int i = (a)-1 ; i >= 0 ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define SZ(a)           ((int)a.size())
#define PP(n,m,a)		puts("---");FF(i,n){FF(j,m)cout << a[i][j] << ' ';puts("");}
#define pb              push_back
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-8;
const double pi = acos(-1.0);
const int maxn = 256 * 50 * 2 + 1;
const int end = 256 * 50 *2;
const int ac = 256;
const int dir[5][2]={{0,0},{1,0},{0,1},{-1,0},{0,-1}};

struct zz
{
    int c;
    int from;
    int to;
    int id;
}zx,tz;

vector<zz>g[maxn];
queue<int>q;
int cen[maxn];
bool vis[20][20];
int n,m,total;
char cs[20][20];

bool yes(int x,int y)
{   
    if(1<=x && x<=n && 1<=y && y<=m)
    {
        return true;
    }                   
    return false;
}

inline int num(int x , int y , int xx = 0)
{   
    return (x-1)*16 + y + ac * xx;
}

int dx(int xx)
{
    return (((xx-1) % ac + 1)-1) / 16 + 1;
}

int dy(int xx)
{   
    return (((xx-1) % ac + 1)-1) % 16 + 1;
}

int dn(int xx)              
{
    return (xx - 1) / ac + 1;       
}

void build(int t)
{
    FF(i,maxn)
    {
        g[i].clear();
    }   
    FOR(i,1,n) FOR(j,1,m)
    {
        if(cs[i][j]=='X')
        {
            zx.from = 0;    
            zx.to = num(i,j);
            zx.id = g[zx.to].size();
            zx.c =1;
            g[0].pb ( zx );
            swap(zx.from,zx.to);
            zx.id = g[0].size() - 1;
            zx.c = 0;
            g[zx.from].pb(zx);
        }
    }    
    int nowx,nowy;
    int from,to;
    FOR(k,1,t)
    {
        FOR(i,1,n) FOR(j,1,m)
        {
            if(cs[i][j] == '#')
            {
                continue;
            }    
            from = num(i,j, 2*k - 2);
            FF(e,5)     
            {
                nowx = i + dir[e][0];
                nowy = j + dir[e][1];
                if(!yes(nowx,nowy))
                {
                    continue;
                }
                to = num(nowx,nowy,2*k-1);
                if(cs[nowx][nowy] != '#')
                {
                    zx.from =  from;
                    zx.to = to;
                    zx.c = 1;
                    zx.id = g[to].size(); 
                    g[from].pb(zx);
                    swap(zx.from,zx.to);
                    zx.c = 0;
                    zx.id = g[from].size()-1;
                    g[to].pb(zx);    
                }     
            }
            from = num(i,j,2*k - 1);
            to = num(i,j,2*k);
            zx.from = from;
            zx.to = to;
            zx.id = g[to].size();
            zx.c=1;
            g[from].pb(zx);
            swap(zx.from,zx.to);
            zx.c = 0;
            zx.id = g[from].size() - 1;
            g[to].pb(zx); 
            if(cs[i][j] == '@')
            {
                zx.from = to;
                zx.to = end;
                zx.id = g[end].size();
                zx.c = 1;
                g[zx.from].pb(zx);
                swap(zx.from,zx.to);
                zx.c=0;
                zx.id=g[to].size()-1;
                g[zx.from].pb(zx);  
            }
        }        
    }   
    return ;
}

bool bfs0()
{
    CL(q);
    MM(vis,false);
    FOR(i,1,n) FOR(j,1,m)
    {  
        if(cs[i][j]=='@')
        {
            q.push(num(i,j));
            vis[i][j] = true;
        }
    }       
    int nowx,nowy,now;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        FOR(i,1,4)
        {
            nowx = dx(now) + dir[i][0];
            nowy = dy(now) + dir[i][1];
            if(cs[nowx][nowy] != '#' && !vis[nowx][nowy] && yes(nowx,nowy))
            {   
                q.push(num(nowx,nowy));
                vis[nowx][nowy] = true;
            }
        }
    }
    FOR(i,1,n) FOR(j,1,m)
    {
        if(cs[i][j] == 'X' && vis[i][j] == false)
        {                                   
            return false;
        }
    }                    
    return true;  
}                

bool bfs()
{  
    CL(q);
    MM(cen,-1);
    q.push(0);
    cen[0]=0;
    int now,to;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        FF(i,g[now].size()) 
        {
            to = g[now][i].to;
            if(g[now][i].c > 0 && cen[to] == -1)
            {   
                cen[to] = cen[now] + 1;
                q.push(to);
            }
        }    
    }
    return cen[end] != -1;
}

int dfs(int flow = inf , int now = 0)
{   
    if(now == end)  
    {   
        return flow;
    }
    int temp,sum=0;
    int to;
    FF(i,g[now].size())
    {
        to = g[now][i].to;
        if(cen[to] == cen[now] + 1 && flow > sum && g[now][i].c >0 )
        {
            temp = dfs ( min ( g[now][i].c , flow - sum ) , to );
            sum += temp;
            g[now][i].c -= temp;
            g[to][g[now][i].id].c += temp;
        }
    }
    if(!sum) cen[now] = -1;
    return sum;
}

bool dinic()
{  
    int ans=0;
    while(bfs())
    {
        ans += dfs();
    }     
    if(ans == total)
    {
        return true;
    }                   
    return false;
}

int bin(int l=1,int r=50)
{
    if( !bfs0 () )
    {   
        return -1;
    }      
    int mid;
    while(l<r)
    {
        mid = (l+r)/2;
        build(mid);
        if(dinic())
        {
            r = mid;        
        }   
        else
        {
            l = mid + 1;
        }
    }    
    return l;     
}

int main()
{
    while(cin>>n>>m)
    {   
        total = 0;
        FOR(i,1,n) FOR(j,1,m)   
        {
            cin>>cs[i][j];
            if(cs[i][j]=='X')
            {
                total++;
            }
        }
        cout<<bin()<<endl;
    }
    return 0;    
}


稍微改了一下，在当前的剩余图中继续增加流量，140ms 


#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<cassert>
#include<cstring>
#include<iomanip>
using namespace std;

#ifdef _WIN32
#define i64 __int64
#define out64 "%I64d\n"
#define in64 "%I64d"
#else
#define i64 long long
#define out64 "%lld\n"
#define in64 "%lld"
#endif

#define FOR(i,a,b)      for( int i = (a) ; i <= (b) ; i ++)
#define FF(i,a)         for( int i = 0 ; i < (a) ; i ++)
#define FFD(i,a)        for( int i = (a)-1 ; i >= 0 ; i --)
#define S64(a)          scanf(in64,&a)
#define SS(a)           scanf("%d",&a)
#define LL(a)           ((a)<<1)
#define RR(a)           (((a)<<1)+1)
#define SZ(a)           ((int)a.size())
#define PP(n,m,a)		puts("---");FF(i,n){FF(j,m)cout << a[i][j] << ' ';puts("");}
#define pb              push_back
#define CL(Q)           while(!Q.empty())Q.pop()
#define MM(name,what)   memset(name,what,sizeof(name))
#define read            freopen("in.txt","r",stdin)
#define write           freopen("out.txt","w",stdout)

const int inf = 0x3f3f3f3f;
const i64 inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-8;
const double pi = acos(-1.0);
const int maxn = 256 * 50 * 2 + 1;
const int end = 256 * 50 *2;
const int ac = 256;
const int dir[5][2]={{0,0},{1,0},{0,1},{-1,0},{0,-1}};

struct zz
{
    int c;
    int from;
    int to;
    int id;
}zx,tz;

vector<zz>g[maxn];
queue<int>q;
int cen[maxn];
bool vis[20][20];
int n,m,total,ans;
char cs[20][20];

bool yes(int x,int y)
{   
    if(1<=x && x<=n && 1<=y && y<=m)
    {
        return true;
    }                   
    return false;
}

inline int num(int x , int y , int xx = 0)
{   
    return (x-1)*16 + y + ac * xx;
}

int dx(int xx)
{
    return (((xx-1) % ac + 1)-1) / 16 + 1;
}

int dy(int xx)
{   
    return (((xx-1) % ac + 1)-1) % 16 + 1;
}

int dn(int xx)              
{
    return (xx - 1) / ac + 1;       
}

void build()
{
    FF(i,maxn)
    {
        g[i].clear();
    }   
    FOR(i,1,n) FOR(j,1,m)
    {
        if(cs[i][j]=='X')
        {
            zx.from = 0;    
            zx.to = num(i,j);
            zx.id = g[zx.to].size();
            zx.c =1;
            g[0].pb ( zx );
            swap(zx.from,zx.to);
            zx.id = g[0].size() - 1;
            zx.c = 0;
            g[zx.from].pb(zx);
        }
    }    
    return ;
}

void add(int t)
{
    int nowx,nowy;
    int from,to;
    FOR(k,t,t)
    {
        FOR(i,1,n) FOR(j,1,m)
        {
            if(cs[i][j] == '#')
            {
                continue;
            }    
            from = num(i,j, 2*k - 2);
            FF(e,5)     
            {
                nowx = i + dir[e][0];
                nowy = j + dir[e][1];
                if(!yes(nowx,nowy))
                {
                    continue;
                }
                to = num(nowx,nowy,2*k-1);
                if(cs[nowx][nowy] != '#')
                {
                    zx.from =  from;
                    zx.to = to;
                    zx.c = 1;
                    zx.id = g[to].size(); 
                    g[from].pb(zx);
                    swap(zx.from,zx.to);
                    zx.c = 0;
                    zx.id = g[from].size()-1;
                    g[to].pb(zx);    
                }     
            }
            from = num(i,j,2*k - 1);
            to = num(i,j,2*k);
            zx.from = from;
            zx.to = to;
            zx.id = g[to].size();
            zx.c=1;
            g[from].pb(zx);
            swap(zx.from,zx.to);
            zx.c = 0;
            zx.id = g[from].size() - 1;
            g[to].pb(zx); 
            if(cs[i][j] == '@')
            {
                zx.from = to;
                zx.to = end;
                zx.id = g[end].size();
                zx.c = 1;
                g[zx.from].pb(zx);
                swap(zx.from,zx.to);
                zx.c=0;
                zx.id=g[to].size()-1;
                g[zx.from].pb(zx);  
            }
        }        
    }       
}

bool bfs0()
{
    CL(q);
    MM(vis,false);
    FOR(i,1,n) FOR(j,1,m)
    {  
        if(cs[i][j]=='@')
        {
            q.push(num(i,j));
            vis[i][j] = true;
        }
    }       
    int nowx,nowy,now;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        FOR(i,1,4)
        {
            nowx = dx(now) + dir[i][0];
            nowy = dy(now) + dir[i][1];
            if(cs[nowx][nowy] != '#' && !vis[nowx][nowy] && yes(nowx,nowy))
            {   
                q.push(num(nowx,nowy));
                vis[nowx][nowy] = true;
            }
        }
    }
    FOR(i,1,n) FOR(j,1,m)
    {
        if(cs[i][j] == 'X' && vis[i][j] == false)
        {                                   
            return false;
        }
    }                    
    return true;  
}                

bool bfs()
{  
    CL(q);
    MM(cen,-1);
    q.push(0);
    cen[0]=0;
    int now,to;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        FF(i,g[now].size()) 
        {
            to = g[now][i].to;
            if(g[now][i].c > 0 && cen[to] == -1)
            {   
                cen[to] = cen[now] + 1;
                q.push(to);
            }
        }    
    }
    return cen[end] != -1;
}

int dfs(int flow = inf , int now = 0)
{   
    if(now == end)  
    {   
        return flow;
    }
    int temp,sum=0;
    int to;
    FF(i,g[now].size())
    {
        to = g[now][i].to;
        if(cen[to] == cen[now] + 1 && flow > sum && g[now][i].c >0 )
        {
            temp = dfs ( min ( g[now][i].c , flow - sum ) , to );
            sum += temp;
            g[now][i].c -= temp;
            g[to][g[now][i].id].c += temp;
        }
    }
    if(!sum) cen[now] = -1;
    return sum;
}

bool dinic()
{  
    while(bfs())
    {
        ans += dfs();
    }     
    if(ans == total)
    {
        return true;
    }                   
    return false;
}

int bin()
{
    ans=0;
    if( !bfs0 () )
    {   
        return -1;
    }  
    build();   
    for(int tt=1;;tt++)
    {
        add(tt);
        if(dinic())
        {
            return tt;
        }
    }    
}

int main()
{
    while(cin>>n>>m)
    {   
        total = 0;
        FOR(i,1,n) FOR(j,1,m)   
        {
            cin>>cs[i][j];
            if(cs[i][j]=='X')
            {
                total++;
            }
        }
        cout<<bin()<<endl;
    }
    return 0;    
}


iteye_6233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HDU 1733 escape(最大流 + dinic算法)
duoerbasilu
07-21 105
/* 超时，不过不想找错误了！做这道题开始接触dinic算法 如果想要学dinic算法，参见： http://wenku.baidu.com/view/98deaf06b52acfc789ebc91a.html### http://www.cnblogs.com/ltang/archive/2010/11/17/1879573.html 题意： X代表人，@代表教室门，问所有的人都跑出教室需要多...
hdu1733(Escape)
Achiberx
04-23 1110
Escape                                                   Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)                                                      Tota
hdu 1733 Escape（分层最大流）
TUT我好菜啊
08-01 449
Escape Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1396    Accepted Submission(s): 399 Problem Description Loneknight hates att
HDU 1733 Escape（分层网络流）
Remilia's
11-10 1240
HDU 1733 Escape 题目链接 题意：给定一个图，#是墙，@是出口，.可以行走，X是人，每个时间每个格子只能站一个人，问最少需要多少时间能让人全部撤离（从出口出去） 思路：网络流，把每个结点每秒当成一个结点，这样枚举时间，每多一秒就在原来的网络上直接加一层继续增广即可，注意考虑方向的时候，要考虑上原地不动 代码： #include #include #i
STL中vector转C风格的数组
bigwindlee的专栏
05-25 1539
摘要： 将std::vector转为c风格的数组：if( !v.empty() ) { doSomething( &v[0], v.size() ); } 转载自《effective stl》。     std::vector很方便，但有时调用的函数的参数规定是数组，
【HDU1733 Escape】 网络流
baidui8622的博客
09-21 180
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1733 题目大意：有一个类似于迷宫搜索的图，‘.’代表的是无人的路，'X'代表有人的点，'#'代表此点不可通过，'@'代表门口。每个位置每一秒钟只能站一个人，每个位置到上下左右点的时间为1，问你所有人能不能出去，能出去输出所有人都出去的最小时间，否则输出-1. 解题思路: 第...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
Rightmost Digit_hdu_
10-03
【标题】"Rightmost Digit HDU" 这道题目来源于HDU（杭州电子科技大学）的在线判题系统，通常这类题目是编程竞赛或者算法训练的一部分。"Rightmost Digit"直译为“最右边的数字”，我们可以推测这是一个关于数字...
Flash-制作旋转动画教程.doc
07-23
flash
小波去噪的Matlab仿真程序，对一维序列进行去噪
最新发布
07-23
本程序包含一个简单示例，利用Matlab代码对一维时间序列进行噪声去除，主要过程调用了Matlab自带的函数。小波分析的有关知识：Donoho提出的小波阀值去噪的基本思想是将信号通过小波变换（采用Mallat算法）后，信号产生的小波系数含有信号的重要信息，将信号经小波分解后小波系数较大，噪声的小波系数较小，并且噪声的小波系数要小于信号的小波系数，通过选取一个合适的阀值，大于阀值的小波系数被认为是有信号产生的，应予以保留，小于阀值的则认为是噪声产生的，置为零从而达到去噪的目的。
ThinkPHP短视频系统关注点赞任务平台系统源码美化整修最终版[可封装双端APP]
07-23
拇指赚ThinkPHP短视频系统关注点赞任务平台系统源码[可封装双端APP] 易支付 微信支付宝官方支付 提现秒到账微信零钱 Thinkphp框架 对接第三方支付paysapi易支付微信支付宝官方支付提现秒到账微信零钱 源码内附详细安装说明
GooFlow工作流引擎压缩包
07-23
《GooFlow——Web流程设计实现详解》 在数字化时代，高效的工作流程设计与管理是提升企业运营效率的关键。GooFlow作为一个强大的在线流程设计工具，以其简洁的界面和丰富的功能，深受用户喜爱。本文将深入探讨GooFlow在Web流程设计中的实现，以及其与jQuery库的结合应用。 我们来看GooFlow的核心特性。GooFlow提供了一个直观的拖放界面，允许用户轻松创建和编辑流程图。文件"Gooflow.js"是这一核心功能的实现载体，它包含了一系列用于绘制和操作流程图的函数。通过这些函数，开发者可以定制化地构建出各种复杂的业务流程，满足不同行业的定制需求。 在Web开发中，jQuery库扮演了重要角色。"jquery.min.js"是轻量级的JavaScript库，简化了DOM操作、事件处理和Ajax交互。在GooFlow中，jQuery被用来优化用户交互体验，例如，通过jQuery选择器快速定位页面元素，动态响应用户的点击、拖动等操作，使得流程设计过程更加流畅。 "defaul.css"是GooFlow的样式文件，它定义了流程图的显示样式，包括节点形状、线条样式、背景
西门子-Opc协议AE 源 码.rar
07-23
OPC（OLE for Process Control）协议是一种在工业自动化领域广泛使用的通信标准，它允许不同的设备和软件应用程序之间进行数据交换。OPC AE（Automation Events）是OPC规范的一部分，主要用于实时事件和报警管理。本资源包含的是使用C#语言编写的OPC AE客户端和服务器的源代码。
b064疫情居家办公系统-springboot+vue.zip（可运行源码+sql文件+文档）
07-23
疫情居家办公系统管理系统按照操作主体分为管理员和用户。管理员的功能包括办公设备管理、部门信息管理、字典管理、公告信息管理、请假信息管理、签到信息管理、留言管理、外出报备管理、薪资管理、用户管理、公司资料管理、管理员管理。用户的功能等。该系统采用了MySQL数据库，Java语言，Spring Boot框架等技术进行编程实现。 疫情居家办公系统管理系统可以提高疫情居家办公系统信息管理问题的解决效率，优化疫情居家办公系统信息处理流程，保证疫情居家办公系统信息数据的安全，它是一个非常可靠，非常安全的应用程序。 管理员权限操作的功能包括管理公告，管理疫情居家办公系统信息，包括外出报备管理，培训管理，签到管理，薪资管理等，可以管理公告。 外出报备管理界面，管理员在外出报备管理界面中可以对界面中显示，可以对外出报备信息的外出报备状态进行查看，可以添加新的外出报备信息等。签到管理界面，管理员在签到管理界面中查看签到种类信息，签到描述信息，新增签到信息等。公告管理界面，管理员在公告管理界面中新增公告，可以删除公告。公告类型管理界面，管理员在公告类型管理界面查看公告的工作状态，可以对公告的数据进行导出，可以添加新公告的信息，可以编辑公告信息，删除公告信息
高项信息系统相关管理师超级全面的备考资料2024版
07-23
高项文件包含了历年的真题解析，各种高项的常考知识点，例如项目启动：确定项目目标、范围及利益相关者。 项目规划：制定项目计划、资源分配、时间估算和风险管理。 项目执行：组织团队、实施项目计划、监控进度和质量。 项目控制：跟踪项目绩效，调整计划以应对变化。 项目收尾：评估项目成果、文档整理和经验总结。 相关工具：项目管理软件（如Gantt图、KPI等）和敏捷方法。 大约30个pdf文件，超级详细！！！
hdu 2297 run
06-21
HDOJ（ HDU Online Judge）是一个知名的中文编程题库和在线评测系统，题号2297的题目通常会有一个具体的名字，没有直接提供，所以我无法给你详细介绍“run”。不过，我可以给你一般性的描述和可能涉及的编程知识点。 在HDOJ上，一道题目通常包含题目描述、输入输出样例、限制条件等信息。2297可能是一道算法或数据结构题目，比如字符串处理、动态规划、图论、搜索算法等。"run"可能是题目中的关键词，可能表示程序运行过程或要求编写一个能够高效运行的解决方案。 如果你想了解具体的HDOJ 2297，你应该访问HDOJ官网，查看题目详情。在那里，你可以找到详细的题目描述，以及如何使用各种编程语言提交代码并获取运行结果。如果你遇到了编程问题，也可以根据提供的样例测试你的代码，或者查阅官方给定的测试用例和样例解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值