E. Culture Code Educational Codeforces Round 69 (Rated for Div. 2)

最新推荐文章于 2024-07-19 22:36:19 发布
最新推荐文章于 2024-07-19 22:36:19 发布
阅读量370 收藏 9
点赞数 9
分类专栏： edu写题记录 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coding_farmer_ac/article/details/134853106
版权

codeforces传送门
luogu传送门
线段树优化建图+拓扑排序
zkw线段树优化建图模板

struct zkwSegtree_improve_graph {
    /* Author : atzk */
    int n , N , rf , r2 , r4 ;
    vector < vector < pair < int , int > > > map ;

    zkwSegtree_improve_graph ( int n ) {
        N = ( 1 << ( __lg ( n + 5 ) + 1 ) ) ;
        rf = N >> 1 , r2 = N << 1 , r4 = N << 2 ;
        map.resize ( r4 ) ;
        build () ;
    }

    void build () {
        for ( int i = 1 ; i < rf ; ++ i ) {
            ll fa = i , ls = i << 1 , rs = i << 1 | 1 ;
            map [ fa ].emplace_back ( ls , 0 ) ;
            map [ fa ].emplace_back ( rs , 0 ) ;
            // map [ ls + r2 ].emplace_back ( fa + r2 , 0 ) ;
            // map [ rs + r2 ].emplace_back ( fa + r2 , 0 ) ;
        }
        for ( int i = N ; i < r2 ; ++ i ) {
            ll fa = i >> 1 , now = i , son = fa + r2 ;
            map [ fa ].emplace_back ( now , 0 ) ;
            // map [ now ].emplace_back ( son , 0 ) ;
        }
    }
    void linkto ( ll now , ll l , ll r , ll w ) {
        now += N ;
        for ( l += N - 1 , r += N + 1 ; l ^ r ^ 1 ; l >>= 1 , r >>= 1 ) {
            if ( ~l & 1 ) map [ now ].emplace_back ( l ^ 1 , w ) ;
            if ( r & 1 ) map [ now ].emplace_back ( r ^ 1 , w ) ;
        }
    }
    void linkfrom ( ll now , ll l , ll r , ll w ) {
        now += N ;
        l += N - 1 , r += N + 1 ;
        if ( ~l & 1 ) map [ l ^ 1 ].emplace_back ( now , w ) ;
        if ( r & 1 ) map [ r ^ 1 ].emplace_back ( now , w ) ;       
        l >>= 1 ; r >>= 1 ;
        for ( ; l ^ r ^ 1 ; l >>= 1 , r >>= 1 ) {
            if ( ~l & 1 ) map [ l ^ 1 + r2 ].emplace_back ( now , w ) ;
            if ( r & 1 ) map [ r ^ 1 + r2 ].emplace_back ( now , w ) ;
        }
    }
    void linkpoint ( ll from , ll to , ll w ) {
        map [ from + N ].emplace_back ( to + N , w ) ;
    }
};

Ac code：

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

using ll = int64_t ;
using i64 = int64_t ;

namespace predefine {
const long long inf = 0x3f3f3f3f3f3f3f3f ;
using Int = __int128 ;
using pll = pair < ll , ll > ;
# define  IOS  iostream::sync_with_stdio ( 0 ) ; cin.tie ( 0 ) ;

# define af( i , a , b ) for ( ll i = a ; i <= b ; ++ i )
# define df( i , a , b ) for ( ll i = a ; i >= b ; -- i )

# define Dg( x ) cout << " ------- " <<  x << " ------- " << '\n'
# define Dged Dg ( "Debug ed" )
# define Dgop Dg ( "Debug op" )
# define pr( x ) cout << #x << " = " << x << '\n'
# define pr1( x ) cout << #x << " = " << x + 1 << '\n'
# define pn putchar ('\n') 
# define ps cout << "yes" 
# define __fin( a ) freopen ( a , "r" , stdin ) 
# define __fout( a ) freopen ( a , "w+" , stdout ) 

# define lowbit( x ) ( x & ( - x ) ) 
# define endl '\n'
}
using namespace predefine ;


//-----  板子  ---------------------------------------------------------------------------------------------------------
struct zkwSegtree_improve_graph {
    /* Author : atzk */
    int n , N , rf , r2 , r4 ;
    vector < vector < pair < int , int > > > map ;

    zkwSegtree_improve_graph ( int n ) {
        N = ( 1 << ( __lg ( n + 5 ) + 1 ) ) ;
        rf = N >> 1 , r2 = N << 1 , r4 = N << 2 ;
        map.resize ( r4 ) ;
        build () ;
    }

    void build () {
        for ( int i = 1 ; i < rf ; ++ i ) {
            ll fa = i , ls = i << 1 , rs = i << 1 | 1 ;
            map [ fa ].emplace_back ( ls , 0 ) ;
            map [ fa ].emplace_back ( rs , 0 ) ;
            // map [ ls + r2 ].emplace_back ( fa + r2 , 0 ) ;
            // map [ rs + r2 ].emplace_back ( fa + r2 , 0 ) ;
        }
        for ( int i = N ; i < r2 ; ++ i ) {
            ll fa = i >> 1 , now = i , son = fa + r2 ;
            map [ fa ].emplace_back ( now , 0 ) ;
            // map [ now ].emplace_back ( son , 0 ) ;
        }
    }
    void linkto ( ll now , ll l , ll r , ll w ) {
        now += N ;
        for ( l += N - 1 , r += N + 1 ; l ^ r ^ 1 ; l >>= 1 , r >>= 1 ) {
            if ( ~l & 1 ) map [ now ].emplace_back ( l ^ 1 , w ) ;
            if ( r & 1 ) map [ now ].emplace_back ( r ^ 1 , w ) ;
        }
    }
    void linkfrom ( ll now , ll l , ll r , ll w ) {
        now += N ;
        l += N - 1 , r += N + 1 ;
        if ( ~l & 1 ) map [ l ^ 1 ].emplace_back ( now , w ) ;
        if ( r & 1 ) map [ r ^ 1 ].emplace_back ( now , w ) ;       
        l >>= 1 ; r >>= 1 ;
        for ( ; l ^ r ^ 1 ; l >>= 1 , r >>= 1 ) {
            if ( ~l & 1 ) map [ l ^ 1 + r2 ].emplace_back ( now , w ) ;
            if ( r & 1 ) map [ r ^ 1 + r2 ].emplace_back ( now , w ) ;
        }
    }
    void linkpoint ( ll from , ll to , ll w ) {
        map [ from + N ].emplace_back ( to + N , w ) ;
    }
};

/* jiangly 取模类（偷个懒使用，这样就不用取模力）*/
using i64 = long long;
template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

constexpr i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}
template<i64 P>
struct MLong {
    i64 x;
    constexpr MLong() : x{} {}
    constexpr MLong(i64 x) : x{norm(x % getMod())} {}
    
    static i64 Mod;
    constexpr static i64 getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(i64 Mod_) {
        Mod = Mod_;
    }
    constexpr i64 norm(i64 x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr i64 val() const {
        return x;
    }
    explicit constexpr operator i64() const {
        return x;
    }
    constexpr MLong operator-() const {
        MLong res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MLong inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MLong &operator*=(MLong rhs) & {
        x = mul(x, rhs.x, getMod());
        return *this;
    }
    constexpr MLong &operator+=(MLong rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MLong &operator-=(MLong rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MLong &operator/=(MLong rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MLong operator*(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MLong operator+(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MLong operator-(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MLong operator/(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MLong &a) {
        i64 v;
        is >> v;
        a = MLong(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MLong &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MLong lhs, MLong rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MLong lhs, MLong rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
i64 MLong<0LL>::Mod = i64(1E18) + 9;

template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}
    
    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }    
	explicit constexpr operator i64() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
int MInt<0>::Mod = 998244353;

template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 1e9 + 7 ;
using Z = MInt<P>;

//-----  板子  ---------------------------------------------------------------------------------------------------------


ll Pow ( ll a , ll b , ll mod ) { 
	a = a % mod ; ll ans = 1 ; 
	for ( ; b ; b >>= 1 ) { if ( b & 1 ) ans = ( a * ans ) % mod ; a = ( a * a ) % mod ; } 
	return ans ; }

inline ll sum1 ( ll _a ) { return ( _a * ( _a + 1 ) ) >> 1 ; }
inline ll sum2 ( ll _b ) { return _b * ( _b + 1 ) * ( 2 * _b + 1 ) / 6  ; }

ll dx [ 4 ] = { -1 , 0 , 1 , 0 } ;
ll dy [ 4 ] = { 0 , 1 , 0 , -1 } ;

// using ll = long long ;!!!

ll cnt = 0 ;

/*
*/

void solve () {
    ll n ; cin >> n ;
    vector < pll > v ( n ) ;
    ll min = inf ;
    for ( auto& [ in , out ] : v ) {
        cin >> out >> in ;
        min = std::min ( min , out ) ;
    }
    sort ( v.begin () , v.end () ) ;
    
    // Dgop ;
    // for ( auto [ l , r ] : v ) {
    // 	cout << l << ' ' << r << endl ;
	// } cout << endl ;
    // Dged ;
    zkwSegtree_improve_graph g ( n ) ;
    auto r4 = g.r4 ;
    vector < ll > size ( r4 ) ;
    for ( int i = 0 ; i < n ; ++ i ) {
        size [ i + g.N ] = v [ i ].second - v [ i ].first ;
    }
    auto next = [ & ] ( ll now ) {
        auto it = lower_bound ( v.begin () , v.end () , make_pair ( v [ now ].second , 0ll ) ) ;
        if ( it == v.end () ) return -1ll ;
        else return ( it - v.begin () ) ;
    };
    set < ll > is ;
    vector < Z > tans ( r4 ) ;
    vector < ll > used ( r4 ) ;
    vector < ll > sum ( n + 1 ) ;
    for ( int i = 0 ; i < n ; ++ i ) {
    	// Dgop ;
        ll l = next ( i ) ;
        if ( l == -1 ) {
            // pr1 ( i + g.N ) ; 
            is.emplace ( i + g.N ) ;
            continue ;
        }
        ll r = next ( l ) ;
        if ( r == -1 ) r = n - 1 ;
        else -- r ;
        // pr1 ( i ) ; pr1 ( l ) ; pr1 ( r ) ;
        g.linkto ( i , l , r , 0 ) ;
        ++ sum [ l ] ;
        -- sum [ r + 1 ] ;
        // if ( v [ i ].first < min ) 
        //     tans [ i + g.N ] += 1 ;
        // Dged ;
    }
    // Dgop ;
    if ( sum [ 0 ] == 0 ) tans [ 0 + g.N ] = 1 ;
    // cout << tans [ 0 + g.N ] << ' ' ;
    for ( int i = 1 ; i < n ; ++ i ) {
        sum [ i ] += sum [ i - 1 ] ;
        if ( sum [ i ] == 0 ) tans [ i + g.N ] = 1 ;
        // cout << tans [ i ] << ' ' ;
    }
    // cout << endl ;
    // Dged ;
    auto& map = g.map ;
    vector < ll > din ( r4 ) ;
    for ( int i = 0 ; i < r4 ; ++ i ) {
        for ( auto [ u , w ] : map [ i ] ) {
            ++ din [ u ] ;
        }
    }
    ll ansin = inf ;
    Z ans = 0 ;
    queue < ll > q ;
    for ( int i = 0 ; i < r4 ; ++ i ) {
        if ( din [ i ] == 0 ) {
            q.emplace ( i ) ;
        }
    }
    while ( !q.empty () ) {
        ll now = q.front () ;
        q.pop () ;
        for ( auto [ here , w ] : map [ now ] ) {
            -- din [ here ] ;
            if ( din [ here ] == 0 ) {
                q.emplace ( here ) ;
            }
            if ( used [ here ] == used [ now ] + size [ now ] ) {
                tans [ here ] += tans [ now ] ;
            }
            else if ( used [ here ] < used [ now ] + size [ now ] ) {
                // ps ;
                used [ here ] = used [ now ] + size [ now ] ;
                tans [ here ] = tans [ now ] ;
            }
        }
        // pr ( now ) ;
        if ( is.count ( now ) ) {
            // pr1 ( now ) ;
            // pr ( tans [ now ] ) ;
            if ( ansin == v [ now - g.N ].first - used [ now ] ) {
                ans += tans [ now ] ;
            }
            else if ( ansin > v [ now - g.N ].first - used [ now ] ) {
                ansin = v [ now - g.N ].first - used [ now ] ;
                ans = tans [ now ] ;
            }
        }
    }
    cout << ans << endl ;
}

/*

*/

int  main () {
//	 IOS ;
//	__fin ( "in.in" ) ;
	ll _ = 1 ;
	// rd ( _ ) ;
 	// cin >> _ ;
	while ( _ -- ) {
        solve () ;
	} 
	return 0 ;
}

/*
//-----  数据  ---------------------------------------------------------------------------------------------------------

----------
*/
atzk
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
Educational Codeforces Round 83 (Rated for Div. 2) E. Array Shrinking
01-03
葫芦聚聚说可以n^2搞。。 还好没卡我n^3 的做法。。 核心思路就是f[i]表示 前i个数最小能分成几个数。 然后由于前i个数都分好了，我们只需要取min f[k]+1( 满足k<i>n; for(int i=1;i>a[i],d
Educational Codeforces Round 159（Rated for Div. 2）
wyzz_yz的博客
12-06 1163
Educational Codeforces Round 159（Rated for Div. 2）
Educational Codeforces Round 131 (Rated for Div. 2)
cfd205554的博客
07-09 419
B. Permutation A. Grass Field C. Schedule Management
Educational Codeforces Round 146 (Rated for Div. 2)
WQhuanm的博客
04-09 486
【代码】Educational Codeforces Round 146 (Rated for Div. 2)
Educational Codeforces Round 133 (Rated for Div. 2)
weixin_45446715的博客
08-05 381
Educational Codeforces Round 133 虽然只是第一题但是和其他人不同
Educational Codeforces Round 145 (Rated for Div. 2) A-D
Mango.
04-01 533
Educational Codeforces Round 145 (Rated for Div. 2) A-D
Educational Codeforces Round 139 (Rated for Div. 2)题解
Kicamon的博客
12-13 718
以上19种情况，一位和二位去满各有九种情况，三位只能取一种情况，所以共19种。只要有两个相同的两位子串，就说明可以用小于n次操作将字符串输入。然后通过差值寻找答案即可，当差值为k的时候，长度一定是k的因数。这里的话，我们将每一纵坐标标记为三种状态，状态1(2), 偶数个状态3，状态2(1)状态1(2), 偶数个状态3，状态1(2)有且仅有两者差值为1的时候，链可以无限长。，满足题目要求的情况有。当n为3位数时，例如。
【Educational Codeforces Round 126 (Rated for Div. 2) A题解】
weixin_63444513的博客
04-10 487
A 【题目简述】可交换a[n]、b[n]下标相同的元素，找的最小值 【错误示例】思路：分别在a，b数组中，比较交换前后相邻俩元素的最小值，谁小取谁累加。 #include <iostream> #include <cmath> using namespace std; long long a[30],b[30],q[4000]; int main() { long int i,t,n,s=0,m=0; cin>>t; w..
Educational Codeforces Round 150 (Rated for Div. 2)
qq_61657632的博客
06-13 1913
今晚看完电影再回来补。
Educational Codeforces Round 103 (Rated for Div. 2) D Journey
yangzijiangac的博客
01-30 1257
随便水篇题解： 定义一个dp[i][2]dp[i][2]dp[i][2]数组 dp[i][0]dp[i][0]dp[i][0]代表从iii点向右最多能走多少个城市 dp[i][1]dp[i][1]dp[i][1]代表从iii点向左最多能走多少个城市 显然我们向右走时如果是 RLRLRL 交替形式呢么能一直走下去，并且也可以原路返回 我们向左走时如果是 LRLRLR 交替，也可以一直走下去，并且原路返回 样例： LRRRLL 绘制成图: 0<−−1−−>2−−>3−−>4<−
Educational Codeforces Round 160 (Rated for Div. 2)
maisui12138的博客
12-19 782
思路：首先分别记录01字符的数量，然后遍历字符串s，遍历时需要记录走过的可以交换的0和1，若前方有可交换的字符时，就减去该字符，否则查看剩余01字符，选择交换然后同时减去两字符并将当前字符记录到交换字符中。思路：位运算，每次添加的元素均为二进制的x位，记录二进制中存入的位，当查询时只需要从后往前遍历二进制数，看当前位存储的是否足够，不够就*2累加到下一位尝试减去。将操作后的字符串定为t，字符串t与原字符串s左对齐对每一位进行比较，若均不相等则t为好字符串，空字符串默认为好字符串；
Educational Codeforces Round 85 (Rated for Div. 2) B. Middle Class（贪心）
01-03
目录传送门题意：思路：代码： 传送门 题意： 思路： 排个序，然后从最大的开始判断是否合适即可 代码： #include #include #include #include #include #include #include ...#define SZ(x) (
Educational Codeforces Round 83 (Rated for Div. 2) C. Adding Powers
01-03
传送门 题意： 思路： 每步可加kik^iki，也可以跳过不加，看能否构成给定数组 数组中的0是不需要处理的 ... }// l=3 b[i]=1+9+9^2 if(p[l]!=1){ flag=0; break; } p[l]=
Educational Codeforces Round 85 (Rated for Div. 2) A. Level Statistics
01-03
目录传送门题意：思路：代码： 传送门 题意： 思路： 就是让判断给出的数据是否合理 两个p,c p,c肯定是是增加的，要么不变 p不变的话，c肯定不能变 始终p应该是大于等于c的 如果两个同时增加，p增加的应该大于等于c...
【18】输出字符菱形
2301_78786609的博客
07-19 375
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 254
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 317
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 239
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
educational codeforces round 103 (rated for div. 2)
09-06
"educational codeforces round 103 (rated for div. 2)"是一个Codeforces平台上的教育性比赛，专为2级选手设计评级。以下是有关该比赛的回答。 "educational codeforces round 103 (rated for div. 2)"是一场...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值