209. 长度最小的子数组；445. 两数相加 II；836. 矩形重叠；892. 三维形体的表面积；289. 生命游戏；392. 判断子序列

最新推荐文章于 2021-05-17 14:15:37 发布
最新推荐文章于 2021-05-17 14:15:37 发布
阅读量170 收藏
点赞数
分类专栏： LeetCode
本文为LifelongLearningPan博主原创文章，转载请注明出处。
本文链接：https://blog.csdn.net/qq_24854861/article/details/107573425
版权

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

 

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。


 

进阶：


    如果你已经完成了 O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

class Solution {//滑动窗口
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        if(nums.size()==0)return 0;
        int le=0,ri=0,sum=0,res=INT_MAX;
        while(ri<nums.size()){
            sum+=nums[ri++];
            while(sum>=s){
                res=min(res,ri-le);
                sum-=nums[le++];
            }
        }
        return res==INT_MAX?0:res;
    }
};
    int minSubArrayLen(int s, vector<int>& nums){
        if(nums.size()==0)return 0;
        vector<int>sum(nums.size()+1,0);//s<=sumij=sum[j+1]-sum[i];
        int res=INT_MAX;
        for(int i=1;i<sum.size();++i)
            sum[i]=sum[i-1]+nums[i-1];
        for(int i=0;i<nums.size();++i){//
            int pos=search(sum,i,sum.size()-1,s+sum[i]);
            if(pos!=-1)res=min(res,pos-i);
        }
        return res==INT_MAX?0:res;
    }
    //lower_bound(nums.begin(),nums.end(),target)
    int search(vector<int>&nums,int low,int high,int target){
        if(low>high)return -1;
        int le=low,ri=high,pos=-1;
        while(le<=ri){
            int mid=le+((ri-le)>>1);
            if(nums[mid]>=target){
                pos=mid;
                ri=mid-1;
            }
            else le=mid+1;
        }
        return pos;
    }

 

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

 

进阶：

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

 

示例：

输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 8 -> 0 -> 7

class Solution {
//如果输入链表不能修改该如何处理？用vector存储起来，从后遍历相加
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        l1=reverse(l1);
        l2=reverse(l2);
        ListNode *LN=new ListNode(0),*cur=LN;
        int carry=0;
        while(l1&&l2){
            int sum=l1->val+l2->val+carry;
            carry=sum/10;            
            auto tmp=new ListNode(sum%=10);
            cur->next=tmp;
            cur=tmp;
            l1=l1->next;
            l2=l2->next;
        }
        while(l1){
            int sum=l1->val+carry;
            carry=sum/10;            
            auto tmp=new ListNode(sum%=10);
            cur->next=tmp;
            cur=tmp;
            l1=l1->next;
        }
        while(l2){
            int sum=l2->val+carry;
            carry=sum/10;            
            auto tmp=new ListNode(sum%=10);
            cur->next=tmp;
            cur=tmp;
            l2=l2->next;
        }
        if(carry){
            auto tmp=new ListNode(1);
            cur->next=tmp;
        }
        cur=LN->next;
        delete LN;
        return reverse(cur);
    }
    ListNode* reverse(ListNode* head){
        ListNode *pre=nullptr,*cur=head,*next=nullptr;
        while(cur){
            next=cur->next;
            cur->next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
    }
};

矩形以列表 [x1, y1, x2, y2] 的形式表示，其中 (x1, y1) 为左下角的坐标，(x2, y2) 是右上角的坐标。

如果相交的面积为正，则称两矩形重叠。需要明确的是，只在角或边接触的两个矩形不构成重叠。

给出两个矩形，判断它们是否重叠并返回结果。

 

示例 1：

输入：rec1 = [0,0,2,2], rec2 = [1,1,3,3]
输出：true


示例 2：

输入：rec1 = [0,0,1,1], rec2 = [1,0,2,1]
输出：false


 

提示：


    两个矩形 rec1 和 rec2 都以含有四个整数的列表的形式给出。
    矩形中的所有坐标都处于 -10^9 和 10^9 之间。
    x 轴默认指向右，y 轴默认指向上。
    你可以仅考虑矩形是正放的情况。

class Solution {
public:
    //横坐标+纵坐标重叠的情况
    bool isRectangleOverlap(vector<int>& rec1, vector<int>& rec2) {
        int lx1=rec1[0],ly1=rec1[1],lx2=rec1[2],ly2=rec1[3];
        int rx1=rec2[0],ry1=rec2[1],rx2=rec2[2],ry2=rec2[3];
        return max(lx1,rx1)<min(lx2,rx2)&&max(ly1,ry1)<min(ly2,ry2);
    }
    /*反向思考：不重叠的情况
    bool isRectangleOverlap(vector<int>& rec1, vector<int>& rec2) {
        int lx1=rec1[0],ly1=rec1[1],lx2=rec1[2],ly2=rec1[3];
        int rx1=rec2[0],ry1=rec2[1],rx2=rec2[2],ry2=rec2[3];
        return !(lx2<=rx1||lx1>=rx2||ly1>=ry2||ly2<=ry1);
    }
    */
};

在 N * N 的网格上，我们放置一些 1 * 1 * 1  的立方体。

每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。

请你返回最终形体的表面积。

 

 


示例 1：

输入：[[2]]
输出：10


示例 2：

输入：[[1,2],[3,4]]
输出：34


示例 3：

输入：[[1,0],[0,2]]
输出：16


示例 4：

输入：[[1,1,1],[1,0,1],[1,1,1]]
输出：32


示例 5：

输入：[[2,2,2],[2,1,2],[2,2,2]]
输出：46


 

提示：


    1 <= N <= 50
    0 <= grid[i][j] <= 50

class Solution {
    vector<int>dx={1,0,-1,0},dy={0,1,0,-1};
public:
    int surfaceArea(vector<vector<int>>& grid){
        int n=grid.size();
        int cnt=0;
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j){
                if(grid[i][j]==0)continue;
                cnt+=2;//上下
                for(int k=0;k<4;++k){//四周
                    auto x=i+dx[k],y=j+dy[k];
                    if(x<0||y<0||x==n||y==n){
                        cnt+=grid[i][j];
                        continue;
                    }
                    cnt+=max(grid[i][j]-grid[x][y],0);
                }
            }
        return cnt;
    }
    /*每一次遍历没有充分利用上下左右，虽然都是O(n^2)
    int surfaceArea(vector<vector<int>>& grid) {
        int n=grid.size();
        int cnt=0;
        for(auto &i:grid)
            for(auto &j:i)
                cnt+=j==0?0:6*j-2*(j-1);//6*j:总 2*(j-1):自身重叠
        for(int i=0;i<n;++i)
            for(int j=0;j<n-1;++j){
                auto tmp=min(grid[i][j],grid[i][j+1]);//每一行左右重叠
                cnt-=tmp==0?0:2*tmp;
            }
        for(int i=0;i<n;++i)
            for(int j=0;j<n-1;++j){
                auto tmp=min(grid[j][i],grid[j+1][i]);//每一列上下重叠
                cnt-=tmp==0?0:2*tmp;
            }
        return cnt;
    }*/
};

根据 百度百科 ，生命游戏，简称为生命，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1 即为活细胞（live），或 0 即为死细胞（dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：


    如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
    如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
    如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
    如果死细胞周围正好有三个活细胞，则该位置死细胞复活；


根据当前状态，写一个函数来计算面板上所有细胞的下一个（一次更新后的）状态。下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。

 

示例：

输入： 
[
  [0,1,0],
  [0,0,1],
  [1,1,1],
  [0,0,0]
]
输出：
[
  [0,0,0],
  [1,0,1],
  [0,1,1],
  [0,1,0]
]

 

进阶：


    你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
    本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？

class Solution {
public:
    void gameOfLife(vector<vector<int>>& board){
        /*更新后状态<-当前状态：二进制第1位为更新后的状态，第0位为当前状态
        0<-0:00 0//
        1<-0:10 2
        0<-1:01 1//
        1<-1:11 3
        */
        int n,m;
        if((m=board.size())==0||(n=board[0].size())==0)return;
        vector<int>dx={1,0,-1,0,1,1,-1,-1};
        vector<int>dy={0,1,0,-1,1,-1,1,-1};
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j){
                int cnt=0;
                for(int k=0;k<8;++k){
                    int x=i+dx[k],y=j+dy[k];
                    if(x<0||y<0||x==m||y==n)continue;
                    cnt+=board[x][y]&1?1:0;//判断(x,y)当前状态是0是1
                }
                if(board[i][j]&1){//判断(i,j)当前状态是0是1
                    if(cnt==2||cnt==3)board[i][j]=0b11;//1<-1
                    //else board[i][j]=0b01;//0<-1 起始值就是1所以可以省略
                }
                else if(cnt==3)board[i][j]=0b10;//1<-0 
                //else board[i][j]=0b00;//0<-0 起始值就是0所以可以省略
            }
        for(auto &i:board)
            for(auto &j:i)
                j>>=1;//因为二进制第1位为更新后的状态，第0位为当前状态
    }
    /*
    void gameOfLife(vector<vector<int>>& board) {
        int n,m;
        if((m=board.size())==0||(n=board[0].size())==0)return;
        vector<int>dx={1,0,-1,0,1,1,-1,-1};//2
        vector<int>dy={0,1,0,-1,1,-1,1,-1};
        vector<vector<int>>res(m,vector<int>(n,0));
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j){
                int cnt=0;
                for(int k=0;k<8;++k){
                    int x=i+dx[k],y=j+dy[k];
                    if(x<0||y<0||x==m||y==n)continue;
                    cnt+=board[x][y]==1?1:0;
                }
                if(board[i][j]==1){
                    if(cnt==2||cnt==3)res[i][j]=1;
                }
                else if(cnt==3)res[i][j]=1;
            }
        board=res;//1 board.swap(res);
    }*/
};

 

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = "abc", t = "ahbgdc"

返回 true.

示例 2:
s = "axc", t = "ahbgdc"

返回 false.

后续挑战 :

如果有大量输入的 S，称作S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

方法一：双指针
思路及算法
本题询问的是，sss 是否是 ttt 的子序列，因此只要能找到任意一种 sss 在 ttt 中出现的方式，即可认为 sss 是 ttt 的子序列。
而当我们从前往后匹配，可以发现每次贪心地匹配靠前的字符是最优决策。

假定当前需要匹配字符 ccc，而字符 ccc 在 ttt 中的位置 x1x_1x1​ 和 x2x_2x2​ 出现（x1<x2x_1 < x_2x1​<x2​），那么贪心取 x1x_1x1​ 是最优解，因为 x2x_2x2​ 后面能取到的字符，x1x_1x1​ 也都能取到，并且通过 x1x_1x1​ 与 x2x_2x2​ 之间的可选字符，更有希望能匹配成功。

这样，我们初始化两个指针 iii 和 jjj，分别指向 sss 和 ttt 的初始位置。每次贪心地匹配，匹配成功则 iii 和 jjj 同时右移，匹配 sss 的下一个位置，匹配失败则 jjj 右移，iii 不变，尝试用 ttt 的下一个字符匹配 sss。
最终如果 iii 移动到 sss 的末尾，就说明 sss 是 ttt 的子序列。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.length(), m = t.length();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == n;
    }
};

 

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int sl=s.size(),tl=t.size();
        vector<vector<int>>dp(tl+1,vector<int>(26,-1));
        for(int i=tl-1;i>=0;--i)
            for(int j=0;j<26;++j)
                if(t[i]==j+'a')
                    dp[i][j]=i;
                else dp[i][j]=dp[i+1][j];
        for(int i=0,j=0;i<sl;++i){
            j=dp[j][s[i]-'a'];
            if(j++==-1)return false;
        }
        return true;
    }
};

 

LifelongLearningPan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 892. 三维形体的表面积（方向数组）（2020.3.25）
Sophia_fez的博客
03-25 236
【题目】 在 N * N 的网格上，我们放置一些 1 * 1 * 1 的立方体。 每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。 请你返回最终形体的表面积。 示例 1： 输入：[[2]] 输出：10 示例 2： 输入：[[1,2],[3,4]] 输出：34 示例 3： 输入：[[1,0],[0,2]] 输出：16 示例 4： 输入：[[1,1,...
LeetCode刷题总结之一
Lifelong Learning Pan
05-20 1258
1.*数据结构：字典树/前缀树/Trie树-immutable；红黑树/对称二叉B树；AVL/二叉平衡查找树；二叉查找/排序/搜索树；最大/小堆-优先队列；二叉树；树； 2.*基础算法： https://github.com/azl397985856/leetcode/blob/master/thinkings/basic-algorithm.md 3.*思路： (1)没有排序则先排序！！！ (2)O(n) 时间复杂度& O(1) 空间复杂度||两数和:双指针（滑动窗口） ①while(l<r
滑动窗口求最小子序列，子序列只能有两种不同的数(904水果成篮)
qq_40896190的博客
05-17 146
import java.util.HashMap; public class leetcode3 { public static void main(String[] args) { int []tree = {1,2,3,1,2,2,2,1,1}; int ans= totalFruit(tree); System.out.println(ans); } public static int totalFruit(int[] tre.
Leetcode 1403：非递增顺序的最小子序列（超详细的解法！！！）
coordinate的博客
04-07 1026
给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和 严格 大于未包含在该子序列中的各元素之和。 如果存在多个解决方案，只需返回 长度最小 的子序列。如果仍然有多个解决方案，则返回 元素之和最大 的子序列。 与子数组不同的地方在于，「数组的子序列」不强调元素在原数组中的连续性，也就是说，它可以通过从数组中分离一些（也可能不分离）元素得到。 注意，题目数据保证满足所有约束条件的解决...
满足特定顺序的字典序列中最小子序列
tmax52HZ的博客
08-20 435
题目： 输入12345，找出全部的字典序排序(12345,12354,12435,12453···,21345···，31245···，41235···，51234···54321)。并且在所有字典序中，找出，满足序列2 1 5排序的最小的子序列 举例：12345不满足2 1 5 3 2 4 1 5满足，2 1 3 4 5也满足，相比较21345为满足要求的最小的子序列 思路：1.求出所有字典序排序(见博客Main38，输入abc,输出abc,acb,bac,bca,cab,cba)； 2.过滤满足满足条件
xiaodao.zip_matlab 求面积_site:www.pudn.com_分形维数 面积_小岛法_面积周长法
07-15
在本压缩包“xiaodao.zip”中，包含了一个名为“xiaodao.m”的MATLAB文件，该文件主要关注的是利用“周长面积法”（也称为“小岛法”）来计算分形维数。分形维数是数学中的一个概念，用于描述具有自相似性质的复杂...
C#数组、结构和枚举PPT.ppt
10-31
C#数组支持一维数组、多维数组（矩形数组）和数组的数组（交错数组）。一维数组可以使用索引来访问元素，例如：`movies[0] = "功夫熊猫"`。多维数组可以使用多个索引来访问元素，例如：`movies[0, 0] = "功夫熊猫"`...
求三个矩形的位置关系与重叠面积-3个矩形.c
04-05
求三个矩形的位置关系与重叠面积
imaderectangle.rar_ imaderectangle_matlab求矩形_site:www.pudn.com_外
07-14
本程序用matlab实现了求不规则图形的最小外接矩形和最大内接矩形，实验用的图形也附在了文件中，可直接运行
4-14-4(多矩形碰撞).7z
02-03
标题中的“4-14-4(多矩形碰撞).7z”可能是一个关于游戏开发或计算机图形学的压缩文件，特别关注多矩形碰撞检测的技术。在游戏和实时模拟中，碰撞检测是核心部分，它允许计算物体之间的交互，如物理反应、障碍物避免...
两字符串最值问题->动态规划dp[i][j]:编辑距离+最长公共子序列;一字符串最值问题->动态规划dp[i][j]:最长回文子序列
Lifelong Learning Pan
05-09 1001
https://labuladong.github.io/ebook/动态规划系列/ 最值+最优子结构+重叠子问题： 两个数组/字符串 dp[i][j]:SelArray1[0~i] SelArray2[0~j] 一般与dp[i-1][j-1],dp[i-1][j],dp[i][j-1]有关 一个数组/字符串 dp[i]:以i为尾的... dp[i][j]:SelArray[i,i+1,,,j-1,j] 一般与dp[i+1][j-1],dp[i][j-1],.
343整数拆分；357计算各个位数不同的数字个数；368最大整除子集；374猜数字大小；375猜数字大小 II
Lifelong Learning Pan
04-17 622
给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。 示例 1: 输入: 2 输出: 1 解释: 2 = 1 + 1, 1 × 1 = 1。 示例 2: 输入: 10 输出: 36 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。 说明: 你可以假设 n 不小于 2 且不大于 58。 class Solutio...
动态规划：0-1背包+完全背包，满包+二维dp优化成一维dp
Lifelong Learning Pan
05-09 447
1. 01背包 有N件物品和一个容量为W 的背包。放入第i（i=0,1,,,N-1)件物品耗费的容量是W[i]，得到的价值是V[i]。求解将哪些物品装入背包可使价值总和最大。 dp[i][j]:可选物品为0~i,容量为j时的最大价值和 vector<vector<int>>dp(N,vector<int>(W+1,0)); for(int i=1;i<N;i++) for(int j=0;j<=W;++j) if(j>=
代码风格规范-谷歌
Lifelong Learning Pan
08-07 393
Google C++ 风格指南 头文件 self-contained头文件：头文件本身依赖的其它头文件，需要全部包含。 #define保护：<PROJECT>_<PATH>_<FILE>_H_ #ifndef FOO_BAR_BAZ_H_ #define FOO_BAR_BAZ_H_ ... #endif // FOO_BAR_BAZ_H_ 前置声明：尽可能地避免使用前置声明。使用 #include 包含需要的头文.
717. 1比特与2比特字符；89. 格雷编码-镜像反射法-2进制码转格雷码；92反转链表 II
Lifelong Learning Pan
05-29 379
有两种特殊字符。第一种字符可以用一比特0来表示。第二种字符可以用两比特(10 或 11)来表示。 现给一个由若干比特组成的字符串。问最后一个字符是否必定为一个一比特字符。给定的字符串总是由0结束。 示例 1: 输入: bits = [1, 0, 0] 输出: True 解释: 唯一的编码方式是一个两比特字符和一个一比特字符。所以最后一个字符是一比特字符。 示例 2: 输入: bits = [1, 1, 1, 0] 输出: False 解释: 唯一的编码方式是两比特字符和两比特字符。所以最...
621任务调度器；经典贪心算法（理解区分动态和贪心）：55跳跃游戏+45跳跃游戏 II
Lifelong Learning Pan
05-13 340
给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务，或者在待命状态。 然而，两个相同种类的任务之间必须有长度为 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。 你需要计算完成所有任务所需要的最短时间。 示例 ： 输入：tasks = ["A","A","A","B".
判断两个数是否互质；409. 最长回文串；面试题 01.06. 字符串压缩；面试题 17.16. 按摩师
Lifelong Learning Pan
07-24 318
bool gcd(int a,int b){ if(a==1||b==1)return true; if(b==0)return false; return helper1(b,a%b); } 给定N和K，求互不相同的正整数x,y,z使得x+y+z=N，且gcd(x,y)=gcd(x,z)=gcd(y,z)=K。 条件：1 ≤N, K≤ 1e18 思路：等式两边除K，得到x'+y'+z'=N'=N/K，且x',y',z'两两互素。 当N'为偶数，直接构造x'=1, y..
C++ lambda；329. 矩阵中的最长递增路径(dfs+记忆化/拓扑排序)；图出发是否能返回远点（dfs/拓扑排序）；最短路径（Floyd+迪杰斯特拉）；785. 判断二分图；
Lifelong Learning Pan
07-25 309
//1 一号节点出发能否遍历回一号节点 无向图 dfs可bfs不可 struct Point{ int x,y,weight; }; bool Gdfs(int cur,vector<vector<bool>> &GMarix){ for(int i=1;i<GMarix.size();++i) if(GMarix[cur][i]){ if(i==1)return true; GMarix[.
836. 矩形重叠 c++
最新发布
09-03
836. 矩形重叠是一道经典的计算几何问题。给定两个矩形的左下角和右上角坐标，我们需要判断这两个矩形是否重叠。 要判断两个矩形是否重叠，我们可以比较它们的位置关系。如果第一个矩形的右上角坐标小于第二个矩形...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值