多校第一场1006

最新推荐文章于 2023-07-20 21:39:19 发布
最新推荐文章于 2023-07-20 21:39:19 发布
阅读量306 收藏 1
点赞数
分类专栏： 动态规划-树形dp 比赛-15多校
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013625492/article/details/47029953
版权
题目描述：

给出一棵树,n~1e5,然后给出m~1e5条特殊的链,每个链有一个权值.现在在树上挑选不相交的链,使得最后的拿到的权值最大.

题解：

看一个点,是树形dp,但是发现如果u是root,枚举过u的链,发现要暴力求和链上周围的点的dp和.这样会超时. 于是想到快速求一条链的和. 为了好写,我们把求链上连接的儿子的dp值的和转化到链上的权值. sum[u]指u的所有儿子的dp和,这个好想,那么一条链上的其实就是(sum[u] - 所有链上儿子d+链上儿子的sum-链上儿子儿子的d….),总结就是链上除了root,其他的点权值都是sum[v]-d[v].而root的权值是sum[root]. 我们是算d[u]的时候才用的,当时d[u]肯定就是0. 所以求链上的权值和. 我们有两种求法
(1)邓爷教的标序+lca. 这样求的是路径,我们用一种常用的方法,把i的值归到i到他fa的那条边上. 这样我们求路径+sum[root]就行了.
(2)用树链剖分. 映射到树状数组上,每次求和.

重点：

(1)关键是求一条链上的和.
(2)把权值归到链上,简化写法.
(3)点的权值归到u到fa的边上.
(4)标序或者树链剖分求链的和
(5)标序+st表求lca

代码：
//这个是标序算链的和.
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const int maxn = 1e5 + 100;
const int maxRMQ = 4e5 + 100;
const int maxIND = 2e5 + 1000;
const int maxTree = 1e6 + 100;
int nn, m;
struct Edge
{
    int a, b, val;
};
vector<Edge> edge[maxn];
vector<int> G[maxn];
int st[maxRMQ][50], L2[maxRMQ], P2[50];

int dfn, index[maxn], fa_index[maxn], first_u[maxn];
int a_st[maxRMQ], an;

int dfx, getin[maxn], getout[maxn];
int d[maxn], sum[maxn];

//void pushUp(int rt)
//{
//    int lRt = (rt<<1), rRt = ((rt<<1)|1);
//    tree[rt] = tree[lRt]+tree[rRt];
//}
//void change(int pos, int key, int rt, int l, int r)
//{
//    if(l==r && l == pos)//主义同时修改tree
//    {
//        tree[rt] = key;
//        return;
//    }
//    pushDown(rt);
//    int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
//    if(pos <= mid)
//    {
//        change(pos,key, lRt, l, mid);
//    }
//    if(pos >= mid + 1)
//    {
//        change(pos, key, rRt, mid + 1, r);
//    }
//    pushUp(rt);//向上push
//}
//
//int query(int L, int R, int rt, int l, int r)
//{
//    if(L <= l && R >= r)//全包括
//    {
//        return tree[rt];
//    }
//    int ans =0, mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
//    if(L <= mid)
//    {
//        ans += query(L, R, lRt, l, mid);
//    }
//    if(R >= mid + 1)
//    {
//        ans += query(L, R, rRt, mid + 1, r);
//    }
//    return ans;
//}


void dfs_dfn(int u, int fa)//这是lca
{
    dfn++;
    index[u] = dfn;
    fa_index[dfn] = u;
    an++;
    a_st[an] = dfn;
    first_u[u] = an;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=fa)
        {
            dfs_dfn(v, u);
            an++;
            a_st[an] = index[u];
        }
    }
}
void getL2()
{
    L2[1] = 0;
    for(int i = 2; i<=400000; i++)
    {
        if((i&(i-1))==0)
        {
            L2[i] = L2[i-1]+1;
        }
        else
        {
            L2[i] = L2[i-1];
        }
        //printf("%d %d\n", i, L2[i]);
    }
}
void initail()
{
    P2[0] = 1;
    for(int i = 1; i<=30; i++)
    {
        P2[i] = 2*P2[i-1];
    }

    for(int i = 1; i <= an; i++)
    {
        st[i][0] = a_st[i];
        //printf(" i is %d  %d\n", i, a_st[i]);
    }
    for(int s = 1; s<=30; s++)
    {
        for(int i = 1; i+P2[s] - 1 <=an; i++)
        {
            int j = i+P2[s-1];
            st[i][s] = min(st[i][s-1], st[j][s-1]);
        }
    }
}
int st_query(int a, int b)
{
    int len = (b-a+1);
    int s = L2[len];
    return min(st[a][s], st[b-P2[s]+1][s]);
}
int getLca(int a, int b)//lca结束
{
    int l = first_u[a], r = first_u[b];
    if(l > r)
    {
        swap(l, r);
    }
    return fa_index[st_query(l, r)];
}

int tree[maxn << 1];//树状数组
int getsum(int x)
{
    int ret = 0;
    while (x)
    {
        ret += tree[x];
        x -= (x & (-x));
    }
    return ret;
}
void update(int x, int y)
{
    while (x <= dfx)
    {
        tree[x] += y;
        x += (x & (-x));
    }
}


void dfs_xu(int u, int fa)
{
    dfx++;
    getin[u] = dfx;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=fa)
        {
            dfs_xu(v, u);
        }
    }
    dfx++;
    getout[u] = dfx;
}

int getT(int a, int b)
{
    if(a==1)
    {
        return getsum(b);
    }
    return getsum(b)-getsum(a-1);
}

int getSum_t(int a, int b, int lca)
{
    int l = getin[lca];
    int r = getin[a];
    int ans = 0;
    ans += getT(l, r);
    r = getin[b];
    ans += getT(l, r);
    return ans;
}

void dfs(int u, int fa)//树形dp,求和链上.
{
    sum[u] = 0;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=fa)
        {
            dfs(v, u);
            sum[u] += d[v];
        }
    }
    d[u] = sum[u];
    REP(i, 0, edge[u].size())
    {
        Edge e = edge[u][i];
        int a = e.a, b = e.b, val = e.val;
//        if(u == 2)
//        {
//            for(int i = 1; i<=dfx; i++)
//            {
//                printf("tree i is %d  %d\n", i, tree[i]);
//            }
//        }
        int tmp = getSum_t(a, b, u);
        d[u] = max(d[u], tmp + sum[u] + val);
    }
    //printf("%d  %d %d\n", u, sum[u], d[u]);
    update(getin[u], sum[u]-d[u]);
    update(getout[u], d[u]-sum[u]);

    //change(getin[u], sum[u]-d[u], 1, 1, dfx);
    //change(getout[u], d[u]-sum[u], 1, 1, dfx);
}
void solve()
{
    REP_D(i, 1, nn)
    {
        G[i].clear();
        edge[i].clear();
    }
    REP_D(i, 1, nn - 1)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        G[a].push_back(b);
        G[b].push_back(a);
    }
    dfn = 0;
    an = 0;
    dfs_dfn(1, 0);
    initail();
    REP_D(i, 1, m)
    {
        int a, b, val;
        scanf("%d%d%d", &a, &b, &val);
        int lca = getLca(a, b);
        Edge t;
        t.a = a;
        t.b = b;
        t.val = val;
        edge[lca].push_back(t);
        //printf("lca %d %d %d\n", a, b, lca);
    }
    CLR(tree);
    CLR(sum);
    CLR(d);
    dfx = 0;
    dfs_xu(1,0);
    dfs(1, 0);
    printf("%d\n", d[1]);
}

int main()
{
   // freopen("13Min.txt", "r", stdin);
    //freopen("1out.txt", "w", stdout);
    int t;
    getL2();
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &nn,&m);
        solve();
    }
    return 0;
}

//这个是树链剖分,但是线段树要re....所以没有过
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const int maxn = 1e5 + 100;
const int maxLMQ = 4*maxn+100;
const int MAXL = 30;
int st[maxLMQ][MAXL];
int an, a[maxLMQ];
int index[maxn], fa_index[maxn], first_byindex[maxn];
int dfn;
vector<int> G[maxn];

struct Edge
{
    int a, b, val, lca;
};
Edge edge[maxn];
vector<Edge> lca_edge[maxn];
int edge_n;

int P2[maxn], L2[maxn];

int d[maxn], sum[maxn];
int dep[maxn], w[maxn], fa[maxn], top[maxn], son[maxn], siz[maxn];
int z;
int tree[maxLMQ];

int n;

void getP2()
{
    P2[0] = 1;
    for(int i = 1; i<=30; i++)
    {
        P2[i] = P2[i-1]*2;
    }
}
void getL2()
{
    L2[1] = 0;
    for(int i = 2; i<=400000; i++)
    {
        if((i&(i-1))==0)
        {
            L2[i] = L2[i-1]+1;
        }
        else
        {
            L2[i] = L2[i-1];
        }
        //printf("%d %d\n", i, L2[i]);
    }
}

void initail()
{
    for(int i = 1; i <= an; i++)
    {
        st[i][0] = a[i];
    }
    for(int s = 1; s<=30; s++)
    {
        for(int i = 1; i<= an; i++)
        {
            int j = i+P2[s-1];
            if(j>=an)
                continue;
            st[i][s]= min(st[i][s-1],st[j][s-1]);
        }
    }
}
int query(int l, int r)
{
    int len = (r-l+1);
    int s = L2[len];
    int tmp = P2[s];
    return min(st[l][s], st[r - tmp + 1][s]);
}
int getLca(int a, int b)
{
    a = index[a];
    b = index[b];
    int l = first_byindex[a], r = first_byindex[b];
    if(l > r)
    {
        swap(l, r);
    }
    return fa_index[query(l, r)];
}

void dfs_dfn(int u, int fa)
{
    ++an;
    a[an] = dfn;
    first_byindex[dfn] = an;
    index[u] = dfn;
    fa_index[dfn] = u;
    dfn++;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=fa)
        {
            dfs_dfn(v, u);
            an++;
            a[an] = index[u];
        }
    }
}

void getEdge()
{
    REP_D(i, 1, n)
    {
        lca_edge[i].clear();
    }
    REP(i, 0, edge_n)
    {
        scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].val);
        edge[i].lca = getLca(edge[i].a, edge[i].b);
        lca_edge[edge[i].lca].push_back(edge[i]);
    }
}

void dfs_1(int u, int pat)//先准备
{
    siz[u] = 1;
    son[u] = 0;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=pat)
        {
            fa[v] = u;
            dep[v] = dep[u]+1;
            dfs_1(v, u);
            if(son[u]==0)
            {
                son[u] = v;
            }
            else if(siz[v] > siz[son[u]])
            {
                son[u] = v;
            }
            siz[u] += siz[v];
        }
    }
}

void dfs_2(int u, int pat, int tp)//标号边
{
    if(pat != 0)
    {
        z++;
        w[u] = z;
    }
    top[u] = tp;
    if(son[u] !=0)
    {
        dfs_2(son[u], u, top[u]);
    }
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=pat&&v!=son[u])
        {
            dfs_2(v, u, v);
        }
    }
}

int query_tree(int LL, int RR, int rt, int l, int r)
{
    if(LL<=l && RR>= r)
    {
        return tree[rt];
    }
    int ans = 0;
    int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
    if(LL<=mid)
    {
        ans += query_tree(LL, RR, lRt, l, mid);
    }
    if(RR>=mid+1)
    {
        ans += query_tree(LL, RR, rRt, mid+1, r);
    }
    return ans;
}
void pushUp(int rt)
{
    int lRt = (rt<<1), rRt = ((rt<<1)|1);
    tree[rt] = tree[lRt]+ tree[rRt];
}
void update(int pos, int x, int rt, int l, int r)
{
    if(pos == l && pos == r)
    {
        tree[rt] = x;
        return;
    }
    int mid = ((l + r)>>1), lRt = (rt<<1), rRt = ((rt<<1)|1);
    if(pos <= mid)
    {
        update(pos, x, lRt, l, mid);
    }
    else
    {
        update(pos , x, rRt, mid +1, r);
    }
    pushUp(rt);
}

int getSum(int a, int b)
{
    int f1 = top[a], f2 = top[b];
    int ans = 0;
    while(f1 != f2)
    {
        if(dep[f1] < dep[f2])
        {
            swap(f1, f2);
            swap(a, b);
        }
        ans += (query_tree(w[f1], w[a], 1, 1, z));
        a = fa[f1];
        f1 = top[a];
    }
    if(a==b)
        return ans;
    if(dep[a] > dep[b])
    {
        swap(a, b);
    }
    ans += query_tree(w[son[a]], w[b], 1, 1, z);
    return ans;
}

void dfs(int u, int pat)
{
    sum[u]= 0;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i];
        if(v!=pat)
        {
            dfs(v, u);
            sum[u] += d[v];
        }
    }
    d[u] = sum[u];
    REP(i, 0, lca_edge[u].size())
    {
        Edge &e = lca_edge[u][i];
        int a = e.a, b = e.b, val = e.val;
        int temp = getSum(e.a, e.b);
        d[u]=max(d[u], temp+sum[u]+val);
    }
    if(u!=1)
    {
        update(w[u], sum[u]-d[u], 1, 1, z);
    }
    //printf("%d %d  %d \n", u, sum[u], d[u]);
}

void solve()
{
    CLR(tree);
    dfn = 1;
    an = 0;
    dfs_dfn(1, 0);
    initail();
    getEdge();
    dep[1] = 0;
    dfs_1(1, 0);
    z = 0;
    dfs_2(1, 0, 1);
    dfs(1, 0);
    printf("%d\n", d[1]);
}

int main()
{
    //freopen("6Fin.txt", "r", stdin);
    //freopen("6Fout.txt", "w", stdout);
    getP2();
    getL2();
    int t;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &edge_n);
        REP_D(i, 1, n)
        {
            G[i].clear();
        }
        REP_D(i, 1, n-1)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        solve();
    }
    return 0;
}
ruclion
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021杭电多校第一场 1006 xor sum
weixin_45765224的博客
07-22 187
题意 给你n个数和k，问最短的区间长度，使得区间异或值>=k，输出左端点最小答案。
hdu 6768 2020杭电多校 第二场 1006
TieWay59的博客
07-24 231
1006 The Oculus 哈希 http://acm.hdu.edu.cn/showproblem.php?pid=6768 题意 给你两个极大数字a和b的斐波那契编码表达式，还有他们乘积c的有误表达式。 其中c的错误是恰有某一个1变成了0。 要求你找出这个错误发生的位置。 思路 最直接的想法是构造出真正的c的表达式。(参考这篇文章) 但显然这样的时间是过不了的，出题人卡掉了这样的做法。 然后考虑假如我们在取模意义下计算出a，b，c’(c+Fibo(i))，在一定概率允许之下，是可以验证的。 单哈希的
2023杭电多校赛第二场1006
txt040208的博客
07-20 159
m个点，所以需要先判断边的合法性，具体来说，对于n个点两两组成的边，所有的m个点都必须在该边的同侧，进一步说是内侧，所以选择有向存图，按照输入的点的顺序，确定有向边，规定所有的点都必须在该边的左侧，不然就不合法，该边的边权是无穷，合法即为1.处理完这一步，接下来就是找最小环的过程，这里可以直接使用弗洛伊德算法，o(n3)的时间复杂度，与最短路不同的是，邻接表中e[i][i]初始化是无穷，并且要遍历，表示环。n和m给的数据都比较小，所以，n3也可以过，本来很明显是一个凸包，但是，要围住的是给定的。
2017多校第一场 1006 Function
Joseph_Z7的博客
07-26 415
这道题的题意好理解，但是具体做题的思路就很绕，但是懂了的话就好做了，题意就是给你个函数关系和定义域和值域，问有多少种不同的函数F满足关系式。 思路：a数组的值和下标有一种关系，b数组的值和下标也有一种关系，这两种关系组合在一起就是题给的函数关系，满足这种函数关系f(i)=b[f(a[i])]需要a数组的环内的节点数是b数组环内的节点数的倍数，因为a数组的环是确定的（题给的），要使a数组满足这样的
2016多校第一场 1006 hdu 5728 PowMod
单木的专栏
07-20 848
解题思路：考虑由于φ(i)\varphi (i)是积性函数，因此我们对于每个质因子求出其贡献即可。 考虑nn的某个质因子pp,我们设sum(n,m)=∑mi=1φ(i∗n)sum(n,m)=\sum_{i=1}^{m} \varphi (i*n).那么考虑将质因子pp的贡献单独处 理，可以得到φ(i∗n)=φ(p)∗∑mi=1φ(i∗np)+∑m/pi=1φ(i∗n)\varphi (i*n) =
2021杭电多校第1场 1006.Xor sum（字典树）
Sankkl1的博客
07-20 269
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6955 分析 用字典树存下每个前缀异或，每次放入建树的时候给每个点一个最新的标号。 每次加入后进行查询，判断是否有数可以使其达到大于等于k的目的，每次更新最右边的符合的位置。 具体看代码。 代码 #include <bits/stdc++.h> using namespace std; #define fi first #define se second #define MP make_pair #d
2020杭电多校第六场1006
weixin_43916777的博客
08-07 138
题意：给你n个点，每个点被标记为0或者1，边权与给定的输入顺序有关。输入的第i条边的权值为。求所有0和1的点之间的最短路径之和。 思路：，构建一个最小生成树，求最小生成树之内的所有0和1的点最短路径之和即可。只需要算每条边两侧的01对即可。显然枚举每条边爆搜会超时，通过树形dp可以压缩复杂度。dp[i][j]表示第i个点及之后的标记为j的点有几个。那么这条边的两侧的01对就可以计算出来，比如某个点u，它之后的标记为1的点有x个，那么，在这条边的另一侧，标记为0的点有（总的标记为0的点数-u及之后标记为0的点
2015多校第一场1006 hdu 5293 Tree chain problem
ZJiaQ1994的博客
07-29 418
题意：给定一棵树，然后在给定一些链，链放在树上某条路径上，每条链有价值，要求取链，并且所取的链不能相交，使得取得的链的总价值最大。 做法：树上做动态规划，开个dp[i]表示第i个点为根的子树里面的取链最大价值，sum[i]表示i的儿子节点的dp值得和。考虑取一条链时，把一条链的路径上的所有sum[i]-dp[i]加起来（lca那点只需把sum[i]加进去就好了）再加上这条链的价值，这样做的目的是
hdu 多校第七场 1006
KyleChennn的博客
08-13 68
最开始思路错误 原始代码： #include<iostream> using namespace std; #define ll long long int main() { int T; ll n,m,k; scanf("%d",&T); while(T--) { scanf("%lld %lld %lld",&...
多校第四场1001标程
08-18
2014多校1001标程，里面有详细的注释，还有等，其实没什么了，懂的一看就懂
2017hdu多校联合训练第一场标程及数据
07-26
2017hdu多校联合训练第一场标程及数据
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2013暑期多校联合训练第一场0723-解题报告
08-14
2013暑期多校联合训练第一场0723-解题报告
HDU2013暑期多校联合训练第一场0723-解题报告和标程
07-26
HDU2013暑期多校联合训练第一场0723-解题报告和标程
动态规划-树形dp总结
ruclion的专栏
06-17 2339
一.简单的从下到上和从上到下的统计 1.      dp[u]表示以u为根的一共有多少个节点.可以用来求重心. 2.      每个点出发能够走得最远的长度.dpm[u], dps[u]用来保存u为根到子树的最长距离,注意两者区别是不同的儿子(不想交路径).另外有一个f[u]指的是去掉u的儿子们之后,u可以发出的最长链.这样的是一个规范的从上往下的dp.我是这样定的:定状态f[u]要求不能考虑
多角度思考 创造性思维 几乎整个Byteland王国都被森林和河流所覆盖 题
ruclion的专栏
06-12 1784
题目描述：几乎整个Byteland王国都被森林和河流所覆盖。小点的河汇聚到一起，形成了稍大点的河。就这样，所有的河水都汇聚并流进了一条大河，最后这条大河流进了大海。这条大河的入海口处有一个村庄——名叫Bytetown。 在Byteland国，有n个伐木的村庄，这些村庄都座落在河边。目前在Bytetown，有一个巨大的伐木场，它处理着全国砍下的所有木料。 木料被砍下后，顺着河流而被运到Bytetow
恐怖分子炸桥
ruclion的专栏
05-26 1111
HDU - 4679题目描述：n~1e5个点的树,边的长度都是1,但是每一条边都有一个破坏的值,恐怖分子可以随便破坏一条边,剩下两棵书的直径的较大值*破坏边的值设为t,求所有的边中最小的t对应的id,如果一样的话输出较小的id题解：很综合的一道树形dp.首先是搞出来dia[u],以u为根的树的直径.然后需要求另一个的直径:我们这样定义:key[u]指将u的所有儿子都删掉,之后剩下的子树的直径.那么怎
算有几个简单路径对
ruclion的专栏
05-26 898
HDU 4705题目描述：一棵树n~1e5,求出有多少个无序对(A,B,C),使得没有一个简单路径能够一笔画过ABC.题解：没有简单路径,不好弄.我们更熟悉的是简单路径.一笔带过,那么就是求出有几个简单路径的对数.简单路径3个点,一定要想到中间的那个点,枚举中间的那个点是谁,那么剩下的两个分别分布在岔路上,就是正常的横着dp.重点：一个转化,把非简单路径转化为简单路径,之后3个点枚举强制是中间的那个
2020牛客多校(第三场)
最新发布
10-02
这段代码是一个用于解决2020牛客多校（第三场）的问题的代码。它使用了C++语言，并且通过输入和输出字符数组来处理数据。代码中使用了一个变量pos来记录开始位置，左移操作是将开始位置设置为pos * x，右移操作是将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值