leetcode 141_206_24_24_142_20_232_225_703_239_242_15_98_236_235_50_169_122

最新推荐文章于 2023-03-20 11:17:12 发布
最新推荐文章于 2023-03-20 11:17:12 发布
阅读量452 收藏
点赞数
分类专栏： leetcode 文章标签： 极客时间覃超
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xw_Summer/article/details/88083201
版权

141 Linked List Cycle

在这里插入图片描述
在这里插入图片描述
Approach 1: Hash Table

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> set= new HashSet<>();
        while(head!=null){
            if(set.contains(head)) return true;
            else{
                set.add(head);
            }
                head=head.next;
        }
        return false;

    }
}

在这里插入图片描述
Approach 2: Two Pointers

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null||head.next==null) return false;
        ListNode slow = head;
        ListNode fast = head.next;
        while(fast!=slow){
            if(fast==null||fast.next==null) return false;
            slow=slow.next;
            fast=fast.next.next;
        }
        return true;
        
    }
}

在这里插入图片描述
在这里插入图片描述

206. Reverse Linked List

在这里插入图片描述
Approach #1 (Iterative) [Accepted]

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev=null;
        ListNode curr=head;
        while(curr!=null){
            ListNode nextTemp=curr.next;
            curr.next=prev;
            prev=curr;
            curr=nextTemp;
        }
        return prev;
        
    }
}

Approach #2 (Recursive)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode p=reverseList(head.next);
        head.next.next=head;
        head.next=null;
        return p;
        
    }
}

在这里插入图片描述

24. Swap Nodes in Pairs

在这里插入图片描述
recursion

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null||head.next==null) return head;
        ListNode n=head.next;
        head.next=swapPairs(head.next.next);
        n.next=head;
        return n;
        
    }
}

25. Reverse Nodes in k-Group

在这里插入图片描述
recursive:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (k==0) return head;
        ListNode curr =head;
        int count=0;
        while(curr!=null&&count<k){
            curr=curr.next;
            count++;
        }
        if(count==k){
            curr=reverseKGroup(curr,k);
            while(count-->0){
                ListNode temp=head.next;
                head.next=curr;
                curr=head;
                head=temp;        
            }   
            head=curr;
        }
       return head; 
    }
}

142. Linked List Cycle II

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null||head.next==null) return null;
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                slow=head;
                while(slow!=fast){
                    slow=slow.next;
                    fast=fast.next;
                }
                return slow;
            }
        }
        return null;      
    }
}

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null||head.next==null) return null;
        Set<ListNode> nodeset =new HashSet<ListNode>();
        while(head!=null){
            if(nodeset.contains(head)) return head;
            nodeset.add(head);
            head=head.next;
        }
        return null;
        
    }
}

20. Valid Parentheses

在这里插入图片描述

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack =new Stack<>();
        for(char c:s.toCharArray()){
            if(c=='('||c=='['||c=='{') stack.push(c);
            else if(c==')'&&!stack.empty()&& stack.peek()=='(') stack.pop();
            else if(c==']'&&!stack.empty()&& stack.peek()=='[') stack.pop();
            else if(c=='}'&&!stack.empty()&& stack.peek()=='{') stack.pop();
            else return false;
            
        }
        return stack.empty();
        
    }
}

232. Implement Queue using Stacks

在这里插入图片描述

class MyQueue {
        Stack<Integer> input= new Stack<>();
        Stack<Integer> output=new Stack<>();

    /** Initialize your data structure here. */
    public MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        input.push(x);
        
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        peek();
        return output.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        if(output.empty()) {
            while(!input.empty()){
                output.push(input.pop());
            }
        }
            
            return output.peek();
        
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return input.empty()&&output.empty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225. Implement Stack using Queues

在这里插入图片描述

class MyStack {
    
    Queue<Integer> queue=new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {
        
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue.add(x);
        for(int i=1;i<queue.size();i++)
            queue.add(queue.remove());
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue.remove();
    }
    
    /** Get the top element. */
    public int top() {
        return queue.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

703. Kth Largest Element in a Stream

在这里插入图片描述

class KthLargest {
    final PriorityQueue<Integer> q;
    final int k;

    public KthLargest(int k, int[] nums) {
        this.k=k;
        q=new PriorityQueue<>(k);
        for(int i:nums) add(i);
    }
    
    public int add(int val) {
        if(q.size()<k) q.offer(val);
        else if(q.peek()<val){
            q.poll();
            q.offer(val);
        }
        return q.peek();
        
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest obj = new KthLargest(k, nums);
 * int param_1 = obj.add(val);
 */

在这里插入图片描述

239. Sliding Window Maximum

在这里插入图片描述
Java O(n) solution using deque

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums==null||k<=0) return new int[0];
        int[] result=new int[nums.length-k+1];
        Deque<Integer> q=new ArrayDeque<>();
        int ri=0;
        for(int i=0;i<nums.length;i++){
            while(!q.isEmpty()&&q.peekFirst()<i-k+1)
                q.poll();
            while(!q.isEmpty()&&nums[q.peekLast()]<nums[i])
                q.pollLast();
            q.add(i);
            if(i>=k-1) result[ri++]=nums[q.peekFirst()];
        }
        return result;
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums==null||k<=0) return new int[0]; 
        int[] result =new int[nums.length-k+1];
        int ri=0;
        
        final PriorityQueue<Integer> q=new PriorityQueue<>(
            new Comparator<Integer>(){
                @Override
                public int compare(Integer o1,Integer o2){
                    return Integer.compare(o2,o1);  
                }
            }
        );
        for(int i=0;i<k;i++){
            q.offer(nums[i]);
        }
        result[ri++]=q.peek();
        for(int i=k;i<nums.length;i++){
            q.remove(nums[i-k]);
            q.offer(nums[i]);
            result[ri++]=q.peek();
        }
        return result;
        
    }
}

242. Valid Anagram

在这里插入图片描述
(Sorting)

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()) return false;
        char[] str1=s.toCharArray();
        char[] str2=t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1,str2);
        
    }
}

在这里插入图片描述
Hash Table

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()) return false;
        int[] table =new int[26];
        for(int i=0;i<s.length();i++){
            table[s.charAt(i)-'a']++;
        }
        for(int i=0;i<t.length();i++){
            table[t.charAt(i)-'a']--;
            if(table[t.charAt(i)-'a']<0) return false;
        }
        return true;
        
    }
}

在这里插入图片描述

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()) return false;
        Map<Character,Integer> m=new HashMap<>();
        
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            if(m.containsKey(c)){
                Integer k=m.get(c);
                k=k+1;
                m.put(c,k);
            }
            else{
                m.put(c,1);
            }
        }
        for(int i=0;i<t.length();i++){
            char c=t.charAt(i);
            if(!m.containsKey(c)) return false;
            else{
                Integer k=m.get(c);
                if(k==1) m.remove(c);
                else{
                    k=k-1;
                    m.put(c,k);
                }
            }
        }
        return true;
        
    }
}

1. Two Sum

在这里插入图片描述

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> m=new HashMap<>();
        int[] res=new int[2];
        for(int i=0;i<nums.length;i++){
            
            if(m.containsKey(target-nums[i])){
                res[0]=i;
                res[1]=m.get(target-nums[i]);
                return res;
            }
            m.put(nums[i],i);
        }
        return res;
        
    }
}

在这里插入图片描述

15. 3Sum

在这里插入图片描述
Linkedlist O(n2)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res =new LinkedList<>();
        if(nums==null||nums.length<3) return res;
        Arrays.sort(nums);
     //   List<Integer> temp=new List<>();
        int i=0;
        while(i<nums.length-2){
            if(nums[i]>0) break;
            int j=i+1;
            int k=nums.length-1;
            while(j<k){
                int sum=nums[i]+nums[j]+nums[k];
                if(sum==0) res.add(Arrays.asList(nums[i],nums[j],nums[k]));
                if(sum<=0) while(nums[j]==nums[++j]&&j<k);
                if(sum>=0) while(nums[k]==nums[--k]&&j<k);
            }
            while(nums[i]==nums[++i]&&i<nums.length-2);
        }
        return res;
        
    }
}

98. Validate Binary Search Tree

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValid(root,null,null);
        
    }
    public boolean isValid(TreeNode root,Integer min,Integer max){
        if(root==null) return true;
        if((min!=null&&root.val<=min)||(max!=null&&root.val>=max)) return false;
        return isValid(root.left,min,root.val)&&isValid(root.right,root.val,max);
    }
}

在这里插入图片描述
Approach 3: Inorder traversal

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        if(root==null) return true;
        Stack<TreeNode> stack =new Stack<>();
        double pre =-Double.MAX_VALUE;
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            if(root.val<=pre) return false;
            pre=root.val;
            root=root.right;
        }
        return true;
        
    }
}

在这里插入图片描述

236. Lowest Common Ancestor of a Binary Tree

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null||root==p||root==q) return root;
        TreeNode left=lowestCommonAncestor(root.left,p,q);
        TreeNode right=lowestCommonAncestor(root.right,p,q);
        return left==null?right:right==null?left:root;
        
    }
}

在这里插入图片描述

235. Lowest Common Ancestor of a Binary Search Tree

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root.val>p.val&&root.val>q.val) return lowestCommonAncestor(root.left,p,q);
        else if(root.val<p.val&&root.val<q.val) return lowestCommonAncestor(root.right,p,q);
        else return root;
        
    }
}

在这里插入图片描述

50. Pow(x, n)

在这里插入图片描述
O (logn)

class Solution {
    public double myPow(double x, int n) {
        if(n == 0)
            return 1;
        if(n<0){
            n = -n;
            x = 1/x;
        }
        if(-n<=Integer.MIN_VALUE) return x*myPow(x,n-1);   //解决边界溢出的问题
        
        return (n%2 == 0) ? myPow(x*x, n/2) : x*myPow(x*x, n/2);        
    }
}

二分快速幂（logn）

class Solution {
    public double myPow(double x, int n) {
        int exp;
        double res=1,curr=x;
        if(n>0) exp=n;
        else if(n<0) {
            if(x==0) throw new RuntimeException("分母不能为0");
            exp=-n;
        }
        else return 1;
        while(exp!=0){
            if((exp&1)==1) res*=curr;
            exp>>=1;
            curr*=curr;
        }
        return n>0?res:1/res;
        
    }
}

169. Majority Element

在这里插入图片描述
Approach 1: Brute Force

class Solution {
    public int majorityElement(int[] nums) {
        int majoritylength=nums.length/2;
        for(int i=0;i<nums.length;i++){
            int count=1;
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]==nums[j])
                    count++;
            }
            if(count>majoritylength)  return nums[i];
            
        }
        return -1;
        
    }
}

在这里插入图片描述
Approach 3: Sorting

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
        
    }
}

在这里插入图片描述

class Solution {
    public int majorityElement(int[] nums) {
        Map<Integer,Integer> m=new HashMap<>();
        Integer k;
        for(int i=0;i<nums.length;i++){
            if(m.containsKey(nums[i])){
                k=m.get(nums[i])+1;   
            }
            else
                k=1;
            if(k>nums.length/2) return nums[i];
            m.put(nums[i],k);

        }
        return -1;
        
    }
}

在这里插入图片描述

122. Best Time to Buy and Sell Stock II

在这里插入图片描述
在这里插入图片描述
贪心：O（n)

class Solution {
    public int maxProfit(int[] prices) {
        int total=0;
        
        for(int i=0;i<prices.length-1;i++){
            if(prices[i+1]>prices[i]) total+=prices[i+1]-prices[i];
        }
        return total;
        
    }
}

遍历比较 O（n)

class Solution {
    public int maxProfit(int[] prices) {
        int i=0,buy,sell,total=0;
        while(i<prices.length-1){
            while (i<prices.length-1 && prices[i+1]<prices[i]) i++;  //注意边界条件，一不小心就出错
            buy=prices[i];
            while(i<prices.length-1 && prices[i+1]>=prices[i]) i++;
            sell=prices[i];
            total+=sell-buy;
        }
        return total;
        
    }
}
Carmen_W
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode-solution15.zip_idea leetcode_leetcode_leetcode python
09-20
Leetcode 题目解答 python版本
LeetCode___888.公平的糖果交换
有木的博客
03-15 2万+
爱丽丝和鲍勃有不同大小的糖果棒：A[i] 是爱丽丝拥有的第 i 块糖的大小，B[j] 是鲍勃拥有的第 j 块糖的大小。 因为他们是朋友，所以他们想交换一个糖果棒，这样交换后，他们都有相同的糖果总量。（一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。） 返回一个整数数组 ans，其中 ans[0] 是爱丽丝必须交换的糖果棒的大小，ans[1] 是 Bob 必须交换的糖果棒的大小。 如果有多个...
LeetCode解题汇总目录
Michael是个半路程序员
09-06 7万+
此篇为学习完《数据结构与算法之美》后，在LeetCode刷题的汇总目录，方便大家查找（Ctrl+Find），一起刷题，一起PK交流！如果本文对你有帮助，可以给我点赞加油！ Updated on 2022.6.12刷题可以按照不同的专题进行，便于加强某个知识点的理解。另有《剑指Offer》面试题（更新完毕）、《程序员面试金典》面试题（更新完毕）、LintCode代码能力测试CAT。LeetCode MySQL 数据库解题目录点击访问 我的 LeetCode 主页我的 GitHub 主页注：本文超过字数限制，
LeetCode 700题 题解答案集合 Python
热门推荐
Keep Coding
03-27 10万+
2019.5.12更新至题号796，目前共有265题。 2019.5.26更新至题号72， 目前共有347题。 2019.6.16更新至题号70，目前共有382题。 2019.7.7更新至题号5120，目前共有442题。 2019.8.5更新至题号1147，目前共有502题。 2019.9.6更新至题号288， 目前共有551题。 2019.11.13更新至题号426，目前共有602题...
LeetCode刷题攻略
carrots
11-11 4671
作者：Rocky0429 链接：https://www.zhihu.com/question/280279208/answer/2159525933 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 【数组】 精讲： 蛋蛋惨遭数组滑铁卢，面试官建议回村养猪。​mp.weixin.qq.com/s?__biz=MzI0NjAxMDU5NA==&mid=2475918890&idx=1&sn=b5dbd85bbe358d7b1668e2d9c27.
LeetCode刷题汇总
weixin_44171872的博客
09-19 2万+
剑指offer 剑指 Offer 03 数组中重复的数字 剑指 Offer 04 二维数组中的查找 剑指 Offer 05 替换空格 剑指 Offer 06 从尾到头打印链表 剑指 Offer 07 重建二叉树 剑指 Offer 09 用两个栈实现队列 剑指 Offer 10- I 斐波那契数列 剑指 Offer 10- II 青蛙跳台阶问题 剑指 Offer 11 旋转数组的最小数字 剑指 Offer 12 矩阵中的路径 剑指 Offer 13 机器人的运动范围 剑指 Offer 14- I 剪绳子 剑指
leetcode每日一题27
weixin_40530554的博客
03-20 981
leetcode263&268&278
Leetcode刷题记录
一只禾的博客
12-15 349
Leetcode刷题结构目录，按数据结构类型划分。
LeetCode详细题解-Java版
听雪楼
12-12 5万+
LeetCode 1- 100 **1. 两数之和 : ** https://blog.csdn.net/love905661433/article/details/84779586 **2. 两数相加 : **https://blog.csdn.net/love905661433/article/details/84842140 **3. 无重复字符的最长子串 : **https://blog....
[LeetCode]135.Candy
SmartSi
01-25 2万+
【题目】 There are N children standing in a line. Each child is assigned a rating value. You are giving candies to these children subjected to the following requirements: Each child must have a
LeetCode_No80.rar_leetcode_leetcode c++代码
09-24
找工作刷题，这是个很好的选择。每天刷上一个两个的题，不错。
leetcode部分题解.rar_java_leet 程序员_leetcode
09-21
通用语言程序员面试，leet部分题目详细解答
易语言模块模块_与狡兔三窟建立关联.rar
03-29
易语言模块模块_与狡兔三窟建立关联.rar 易语言模块模块_与狡兔三窟建立关联.rar 易语言模块模块_与狡兔三窟建立关联.rar 易语言模块模块_与狡兔三窟建立关联.rar 易语言模块模块_与狡兔三窟建立关联.rar ...
leetcode题解_leetcode_leetcode题解_
09-29
leetcode题解 算法和数据结构题目及解答
Dynamic Programming(easy四道题)（medium十五道题）
xw_Summer的博客
01-23 906
53. Maximum Subarray Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum. Example: Input: [-2,1,-3,4,-1,2,1,-5,4],...
Dipth-First Search(easy)两道题
xw_Summer的博客
01-24 557
101. Symmetric Tree Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center). Note: Bonus points if you could solve it both recursively and iteratively. Recursi...
时间空间效率的平衡4+时间效率5
xw_Summer的博客
01-25 421
1. 丑数 题目描述 把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。 链接：https://www.nowcoder.com/questionTerminal/6aa9e04fc3794f68acf8778237ba065b 来源：牛客网 class Sol...
Array(easy)七道题
xw_Summer的博客
01-23 368
Two Sum(easy) Given an array of integers, return indices of the two numbers such that they add up to a specific target.Given an array of integers, return indices of the two numbers such that they a...
leetcode451_根据字符出现频率排序。用java语言编写
最新发布
05-29
题目描述： 给定一个字符串，请将字符串里的字符按照出现的频率降序排列。 示例 1: 输入: "tree" ...最后遍历排序后的List，将每个字符按照出现次数依次添加到StringBuilder中，并返回StringBuilder的字符串形式。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值