Van emde boas树Java实现

已于 2022-04-03 09:30:59 修改
阅读量388 收藏 2
点赞数
分类专栏： 算法 算法导论 文章标签： java 算法导论 算法
于 2022-01-21 18:25:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/azbh111/article/details/122627096
版权

简介

VEB树的基础理论在算法导论第三版第20章有详细介绍，这里不再赘述。

VEB树的优势

VEB树支持插入、删除、搜索、最大值、最小值、前驱、后继等操作。
这些操作的时间复杂度都是O(lglgu)，u为关键字的全域。

接口定义


/**
 * Van emde boas树
 * 下面时间复杂度中 u表示树的容量
 *
 * @author: zyp
 * @since: 2022/1/18 下午5:46
 */
public interface IVEBTree {
    int size();

    /**
     * u: 可能存储的最大值
     * O(lglgu)
     */
    boolean contains(int value);

    /**
     * 最小值
     * O(1)
     */
    Integer minmum();

    /**
     * 最大值
     * O(1)
     */
    Integer maxmum();

    /**
     * 后继节点
     * O(lglgu)
     */
    Integer successor(int x);

    /**
     * 前驱节点
     * O(lglgu)
     */
    Integer predecessor(int x);

    /**
     * 插入
     * O(lglgu)
     */
    boolean insert(int value);

    /**
     * 删除
     * O(lglgu)
     */
    boolean delete(int value);

    void clear();
}

Java实现


import java.util.Arrays;

/**
 * ProtoVEB原型树
 *
 * @author: zyp
 * @since: 2022/1/18 下午5:46
 */
public class VEBTree implements IVEBTree {
    private ProtoVEBNode root;

    public VEBTree(int capacity) {
        if (capacity < 16) {
            capacity = 16;
        }
        root = new ProtoVEBNode(getOffset(capacity));
    }

    //    插入VEB树, 如果元素存在, 则忽略
    @Override
    public boolean insert(int value) {
        ensureCapacity(value + 1);
        return root.insert(value);
    }

    //    是否包含指定元素
    @Override
    public boolean contains(int value) {
        return root.contains(value);
    }

    @Override
    public int size() {
        return root == null ? 0 : root.size;
    }

    //    最小值
    @Override
    public Integer minmum() {
        if (root.size == 0) {
            return null;
        }
        return root.min;
    }

    //    最大值
    @Override
    public Integer maxmum() {
        if (root.size == 0) {
            return null;
        }
        return root.max;
    }

    //    x的后继节点
    @Override
    public Integer successor(int x) {
        if (root == null) {
            return null;
        }
        return root.successor(x);
    }

    //    x的前驱结点
    @Override
    public Integer predecessor(int x) {
        if (root == null) {
            return null;
        }
        return root.predecessor(x);
    }

    //    删除指定元素, 如果树种包含该元素, 则返回true
    @Override
    public boolean delete(int value) {
        if (value >= root.capacity) {
            return false;
        }
        return root.delete(value);
    }

    @Override
    public void clear() {
        root = new ProtoVEBNode(16);
    }


    //    扩展容量
    private void ensureCapacity(int capacity) {
        int offset = getOffset(capacity);
        while (root.offset < offset) {
            ProtoVEBNode newRoot = new ProtoVEBNode(root.offset << 1);
            newRoot.size = root.size;
            if (root.size > 0) {
                newRoot.min = root.min;
                newRoot.max = root.max;
                root.delete(root.min);
                newRoot.getOrCreateSummary().insert(0);
            }
            newRoot.getOrCreateClusters(0)[0] = root;
            root = newRoot;
        }
    }

    /**
     * 2^n < capacity <= 2^(n+1)
     * 计算n
     */
    private static int getOffset(int capacity) {
        if (capacity <= 2) {
            return 0;
        }
        if (capacity <= 4) {
            return 1;
        }
        int offset = 1;
        while (((1 << offset) << offset) < capacity) {
            offset <<= 1;
            if (offset == 16) {
                return offset;
            }
        }
        return offset;
    }

    private static class ProtoVEBNode {
        private int offset;
        private int capacity; // 容量 为2的整数次幂 capacity== (1<<offset)<<offset
        private ProtoVEBNode summary; // 统计clusters中的bit
        private ProtoVEBNode[] clusters; // clusters.length == 1<<offset
        private int min;
        private int max;
        private int size;

        private ProtoVEBNode() {
        }

        public ProtoVEBNode(int offset) {
            this.offset = offset;
            if (offset == 16) {
                this.capacity = Integer.MAX_VALUE;
            } else {
                this.capacity = (1 << offset) << offset;
            }
        }

        private ProtoVEBNode(int offset, int capacity) {
            this.offset = offset;
            this.capacity = capacity;
        }

        @Override
        public String toString() {
            return String.format("offset=%s,capacity=%s,size=%s,min=%s,max=%s", offset, capacity, size, min, max);
        }

        public Integer predecessor(int x) {
            if (offset == 0) {
                if (size == 0) {
                    return null;
                }
                if (min < x) {
                    return 0;
                }
                return null;
            }
            if (size == 0 || x <= min) {
                return null;
            }
            if (x > max) {
                return max;
            }
            if (size == 1) {
                return null;
            } else if (size == 2) {
                return min;
            }
            int high = high(x);
            ProtoVEBNode cluster = getCluster(high);
            if (cluster != null) {
                Integer predecessor = cluster.predecessor(low(x));
                if (predecessor != null) {
                    return index(high, predecessor);
                }
            }
            if (summary == null) {
                return min;
            }
            Integer predecessor = summary.predecessor(high);
            if (predecessor == null) {
                return min;
            }
            cluster = clusters[predecessor];
            if (cluster == null) {
                return min;
            }
            return index(predecessor, cluster.max);
        }

        public Integer successor(int x) {
            if (offset == 0) {
                if (size == 0) {
                    return null;
                }
                if (max > x) {
                    return 1;
                }
                return null;
            }
            if (size == 0 || x >= max) {
                return null;
            }
            if (x < min) {
                return min;
            }
            if (size == 1) {
                return null;
            } else if (size == 2) {
                return max;
            }
            int high = high(x);
            ProtoVEBNode cluster = clusters[high];
            if (cluster != null) {
                Integer successor = cluster.successor(low(x));
                if (successor != null) {
                    return index(high, successor);
                }
            }
            if (summary == null) {
                return max;
            }
            Integer successor = summary.successor(high);
            if (successor == null) {
                return max;
            }
            cluster = clusters[successor];
            if (cluster == null) {
                return max;
            }
            return index(successor, cluster.min);
        }

//        因子是2的整数次幂时, 可以用位运算快速计算除法/乘法/取余
        public int low(int value) {
//            value % (1 << offset)
            int segSize = 1 << offset;
            return value & (segSize - 1);
        }

        public int high(int value) {
//            value / (1 << offset)
            int segSize = 1 << offset;
            return (value & (-segSize)) >> offset;
        }

        public int index(int x, int y) {
//            x * (1<<offset) + y
            return (x << offset) + y;
        }

        public ProtoVEBNode getOrCreateSummary() {
            if (summary == null) {
                summary = createSubNode();
            }
            return summary;
        }

        private ProtoVEBNode createSubNode() {
            if (offset == 1) {
                return new ProtoVEBNode(0, 2);
            } else {
                return new ProtoVEBNode(offset >> 1);
            }
        }

        private ProtoVEBNode[] getOrCreateClusters(int capacity) {
            if (clusters == null) {
                clusters = new ProtoVEBNode[Math.max(16, capacity)];
            } else {
                if (clusters.length < capacity) {
//                    扩容
                    int len = clusters.length;
                    while (len < capacity) {
                        len <<= 1;
                    }
                    clusters = Arrays.copyOf(clusters, len);
                }
            }
            return clusters;
        }

        public ProtoVEBNode getCluster(int idx) {
            if (clusters == null || idx >= clusters.length) {
                return null;
            }
            return clusters[idx];
        }

        public ProtoVEBNode getOrCreateCluster(int idx) {
            ProtoVEBNode[] clusters = getOrCreateClusters(idx + 1);
            ProtoVEBNode cluster = clusters[idx];
            if (cluster == null) {
                cluster = createSubNode();
                clusters[idx] = cluster;
            }
            return cluster;
        }


        private boolean insertBase(int x) {
            if (size == 0) {
                min = max = x;
                size++;
                return true;
            } else if (size == 1) {
                if (min == x) {
                    return false;
                }
                if (x < min) {
                    min = x;
                } else {
                    max = x;
                }
                size++;
                return true;
            } else {
                return false;
            }
        }

        public boolean insert(int value) {
            if (offset == 0) {
                return insertBase(value);
            }
            if (size == 0) {
                min = max = value;
                size++;
                return true;
            } else {
                if (value == min || value == max) {
                    return false;
                }
                int insert;
                if (value < min) {
                    insert = min;
                    min = value;
                } else if (value > max) {
                    max = value;
                    insert = value;
                } else {
                    insert = value;
                }
                int high = high(insert);
                boolean ok = getOrCreateCluster(high).insert(low(insert));
                if (ok) {
                    getOrCreateSummary().insert(high);
                    size++;
                }
                return ok;
            }
        }

        private boolean deleteBase(int x) {
            if (size == 0) {
                return false;
            }
            if (size == 1) {
                if (min == x) {
                    size--;
                    return true;
                }
            } else {
                if (0 == x) {
                    min = max = 1;
                } else {
                    min = max = 0;
                }
                size--;
                return true;
            }
            return false;
        }

        public boolean delete(int value) {
            if (offset == 0) {
                return deleteBase(value);
            }
            if (size == 0 || value < min || value > max) {
                return false;
            }
            if (size == 1) {
                if (min == value) {
                    size--;
                    return true;
                } else {
                    return false;
                }
            }
            if (min == value) {
                int successor = successor(min);
                delete0(successor);
                min = successor;
                return true;
            } else if (max == value) {
                int predecessor = predecessor(max);
                delete0(value);
                max = predecessor;
                return true;
            } else {
                return delete0(value);
            }
        }

        private boolean delete0(int x) {
            int high = high(x);
            ProtoVEBNode cluster = clusters[high];
            boolean ok = cluster != null && cluster.delete(low(x));
            if (ok) {
                size--;
                if (cluster.size == 0) {
                    summary.delete(high);
                }
            }
            return ok;
        }

        public boolean contains(int value) {
            if (size == 0 || value < min || value > max) {
                return false;
            }
            if (min == value || max == value) {
                return true;
            }
            if (offset == 0) {
                return false;
            }
            if (size < 3) {
                return false;
            }
            int high = high(value);
            if (clusters != null && high < clusters.length) {
                ProtoVEBNode cluster = clusters[high];
                if (cluster != null) {
                    return cluster.contains(low(value));
                }
            }
            return false;
        }
    }
}

测试

分为正确性测试和性能测试

性能测试结果

TreeMap insert 15045 ms
ProtoVEB insert 11844 ms
TreeMap minimum 142 ms
ProtoVEB minimum 19 ms
TreeMap predecessor 14349 ms
ProtoVEB predecessor 7248 ms
TreeMap contains 13375 ms
ProtoVEB contains 2223 ms
TreeMap delete 14465 ms
ProtoVEB delete 6767 ms


import org.junit.Test;

import java.util.Objects;
import java.util.TreeMap;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author: zyp
 * @since: 2022/1/20 下午6:50
 */
public class SortedTreeTest {
    ThreadLocalRandom random = ThreadLocalRandom.current();

    //    VEB树正确性测试
    @Test
    public void testProtoVEB() {
        long start = System.currentTimeMillis();
        TreeHolder holder = new TreeHolder();
        int keyRange = 10000;
        int loopTimes = 10000000;
//        测试插入
        for (int i = 1; i <= loopTimes; i++) {
            int key = random.nextInt(keyRange);
            holder.insert(key);
            key = random.nextInt(keyRange);
            holder.delete(key);
        }
        long end = System.currentTimeMillis();
        System.out.println(String.format("cost %s ms", end - start));
    }

    //    VEB树性能测试
    @Test
    public void testProtoVEBTime() {
        long start;
        Integer zero = 0;
        int size = 10000000;
        int[] nums = new int[size];
        Integer[] numWrappers = new Integer[size];
        for (int i = 0; i < size; i++) {
            int v = random.nextInt(0, 100000000);
            nums[i] = v;
            numWrappers[i] = v;
        }
        TreeMap<Integer, Integer> map = new TreeMap<>();
//        ========================
        start = System.currentTimeMillis();
        for (Integer num : numWrappers) {
            map.put(num, zero);
        }
        System.out.println(String.format("TreeMap insert %s ms", System.currentTimeMillis() - start));
        VEBTree tree1 = new VEBTree(16);
        start = System.currentTimeMillis();
        for (int num : nums) {
            tree1.insert(num);
        }
        System.out.println(String.format("ProtoVEB insert %s ms", System.currentTimeMillis() - start));
//        ========================
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            map.firstKey();
        }
        System.out.println(String.format("TreeMap minimum %s ms", System.currentTimeMillis() - start));
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            tree1.minmum();
        }
        System.out.println(String.format("ProtoVEB minimum %s ms", System.currentTimeMillis() - start));


//        ========================
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            map.lowerKey(nums[i]);
        }
        System.out.println(String.format("TreeMap predecessor %s ms", System.currentTimeMillis() - start));
        start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            tree1.predecessor(nums[i]);
        }
        System.out.println(String.format("ProtoVEB predecessor %s ms", System.currentTimeMillis() - start));

//        ========================
        start = System.currentTimeMillis();
        for (Integer num : numWrappers) {
            map.containsKey(num);
        }
        System.out.println(String.format("TreeMap contains %s ms", System.currentTimeMillis() - start));
        start = System.currentTimeMillis();
        for (int num : nums) {
            tree1.contains(num);
        }
        System.out.println(String.format("ProtoVEB contains %s ms", System.currentTimeMillis() - start));
//        ========================
        start = System.currentTimeMillis();
        for (Integer num : numWrappers) {
            map.remove(num);
        }
        System.out.println(String.format("TreeMap delete %s ms", System.currentTimeMillis() - start));
        start = System.currentTimeMillis();
        for (int num : nums) {
            tree1.delete(num);
        }
        System.out.println(String.format("ProtoVEB delete %s ms", System.currentTimeMillis() - start));
//        ========================
    }


    private static class TreeHolder {
        private TreeMap<Integer, Integer> map = new TreeMap<>();
        private VEBTree tree1 = new VEBTree(16);
        private VEBTree tree2 = new VEBTree(16);

        public void delete(int key) {
            boolean remove = map.remove(key) != null;
            boolean delete;
            try {
                delete = tree1.delete(key);
            } catch (Throwable x) {
                tree2.delete(key);
                throw new RuntimeException(x);
            }
            if (!Objects.equals(remove, delete)) {
                tree2.delete(key);
                throw new RuntimeException("delete 错误");
            }
            try {
                if (tree1.contains(key)) {
                    tree2.delete(key);
                    throw new RuntimeException("delete 错误");
                }
            } catch (Throwable x) {
                tree2.delete(key);
                tree2.contains(key);
                throw new RuntimeException(x);
            }
            if (map.size() != tree1.size()) {
                tree2.delete(key);
                throw new RuntimeException("delete 错误");
            }

            tree2.delete(key);
        }

        public void insert(int key) {
            boolean ok = map.put(key, key) == null;
            boolean ok1;
            try {
                ok1 = tree1.insert(key);
            } catch (Throwable x) {
                tree2.insert(key);
                throw new RuntimeException(x);
            }
            if (!Objects.equals(ok, ok1)) {
                tree2.insert(key);
                throw new RuntimeException("insert 错误");
            }
            if (map.firstKey().intValue() != tree1.minmum().intValue()) {
                tree2.insert(key);
                tree2.minmum();
                throw new RuntimeException("minmum 错误");
            }
            if (map.lastKey().intValue() != tree1.maxmum().intValue()) {
                tree2.insert(key);
                tree2.maxmum();
                throw new RuntimeException("minmum 错误");
            }
            if (!tree1.contains(key)) {
                tree2.insert(key);
                tree2.contains(key);
                throw new RuntimeException("contains 错误");
            }
            Integer lowerKey = map.lowerKey(key);
            Integer predecessor;
            try {
                predecessor = tree1.predecessor(key);
            } catch (Throwable x) {
                tree2.insert(key);
                tree2.predecessor(key);
                throw new RuntimeException("predecessor 错误");
            }
            if (!Objects.equals(lowerKey, predecessor)) {
                tree2.insert(key);
                tree2.predecessor(key);
                throw new RuntimeException("predecessor 错误");
            }
            Integer higherKey = map.higherKey(key);
            Integer successor;
            try {
                successor = tree1.successor(key);
            } catch (Throwable x) {
                tree2.insert(key);
                tree2.successor(key);
                throw new RuntimeException("predecessor 错误");
            }
            if (!Objects.equals(higherKey, successor)) {
                tree2.insert(key);
                tree2.successor(key);
                throw new RuntimeException("successor 错误");
            }
            tree2.insert(key);
        }
    }
}

azbh111
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
van Emde Boas树的C#实现
04-24
主要操作有求最大值、求最小值，判断是否是成员，求前驱和后继，插入操作和删除操作，使用C#实现，分别实现了proto vEB 和VEB
线性表--数组数据结构python实现
魏少
09-03 767
维基定义 在计算机科学中，数组数据结构或简称数组是由元素集合（值或变量）组成的数据结构，每个元素由至少一个数组索引或键标识。存储阵列使得可以通过数学公式从其索引元组计算每个元素的位置。[1][2][3]最简单的数据结构类型是线性数组，也称为一维数组。 例如，具有索引0到9的10个32位整数变量的数组可以在存储器地址2000,2004,2008，... 2036处存储为10个字，使得具有索引...
算法导论 van Emde Boas 树
beimuaihui的专栏
03-29 623
算法导论 van Emde Boas 树 结构 vEB(u)表示全域值为{0,1,2,…,u-1} vEB 树 min 表示 vEB 树中最小值,该值元素不出现在任何递归的子树(簇) vEB(u↓\sqrt[\downarrow]{u}↓u​)中 max 表示 vEB 树中最大值 summary 指向 vEB(u↑\sqrt[\uparrow]{u}↑u​)新的树，summary[i]表示子树 cluster[i]的逻辑或 cluster[0…u↑\sqrt[\uparrow]{u}↑u​－1]表示u
算法导论-van Emde Boas树
hxlove123456的博客
10-23 6129
van Emde Boas树 van Emde Boas树中文名不知道，所以暂且叫它v树吧。v树是一种数据结构，和二叉树、红黑树类似。一种数据结构被创建出来，肯定有其特别的优点，v树的优点就是实现数据的基本操作的最差的时间复杂度为O(lglgn),在算法导论前面知识可以知道，红黑树的性能是最好的，基本操作最坏的时间复杂度为O(lg(n)),所以v树的性能相对于红黑树要好很多，如果真的这样
数据结构总结---树
steven_miao的专栏
07-04 1045
仅以此文纪念过往岁月 数据结构中，树是一种非常重要的数据结构，常见的树分为 1.二叉树    最常见的数据结构 2.红黑树 3.B树 4.vEB树 5.KD树
《算法导论3rd第二十章》van Emde Boas树
懒猫的脚印
12-15 1775
算法导论 第二十章 vEB树
contigconstructor:使用van Emde Boas树构建轻巧高效的DNA重叠群
03-31
Contig构造函数 动机 重叠群是基因组序列。我们想了解周围环境与已知目标序列有关。 方法 依存关系 ContigConstructor是在Python 3.6.8下专门构建的，并使用NumPy 1.17.2。 尽管无法保证，但我们希望...
通过duplicate创建cdb、EMDE等
01-11
ORACLE 19c 创建容器CDB 创建EMDE
算法导论 + 算法导论 教师手册 +答案
10-03
算法导论 + 算法导论 教师手册 +答案算法导论 + 算法导论 教师手册 +答案算法导论 + 算法导论 教师手册 +答案算法导论 + 算法导论 教师手册 +答案算法导论 + 算法导论 教师手册 +答案
高级算法-随机算法
04-03
随机算法，使用概率统计方法实现随机算法，一般比确定性的算法速度更快！
van Emde Boas 树 数据结构说解
Foliciatarier的博客
03-04 4492
直观上看，vEB 树保存了一个有序的集合，并支持以 O(lglgn) 的时间复杂度在 vEB 树上进行最小最大值查询、单值存在性查询、单值前驱后继查询、单值插入维护、单值删除维护的数据结构。
go专业数据结构与算法
12-05
本节为go专业数据结构与算法，主要讲解go中的数据结构以及相关的算法，如排序算法等。
The van Emde Boas tree in java
houzhizhen的专栏
02-23 300
class VEBNode { private int u; private int uSquart; private VEBNode summary; private VEBNode[] cluster; private boolean[] element; private Integer max; private Integer mi...
详解Van emde boas tree
zhuziyu_edward的博客
02-16 1593
详解Van Emde Boas Tree 在这篇文章中， 我将带大家走进Van Emde Boas tree这种数据结构 Motivation 在读这篇文章之前， 相信大家都已经很了解二叉搜索树了， 如果对二叉搜索树不太了解的同学， 可以参考这篇文章。 https://www.geeksforgeeks.org/binary-search-tree-data-structure/ 我们知道， 对于...
vEB Tree算法分析 von Emde Boas tree分析（草稿）
mhp111111的博客
03-30 3420
O(lglgn)解法，如果希望能够实现O(lglgn)解法的话，一种思路是在O(lgn)个数上进行binary Search。 而另一种思路则是产生一种解是O（lglgn）的递归关系。 而van Emde Boas Tree则采取了后一种方式 考虑一下关系: T(v)=T(√v)+O(1) T^′ (lgu)=T^′ (lg√u)+O(1)   T^′ (lgu)=T(v) T
van Emde Boas Trees(vEB树)(Introduction to Algorithms, 算法导论，CLRS)学习笔记
qq_38356492的博客
10-12 607
van Emde Boas Trees 1. Predecessor search/ordered sets predecessor: return the nearest left neighbor successor: return the nearest right neighbor 2.Naive: O(∣U∣)O(|U|)O(∣U∣) space predecessor/successor: if x∈Sx\in Sx∈S then it’s O(1)O(1)O(1); insert:
java实现VEBTree
chenzhichao的博客
05-30 880
昨天弄明白veb树的原型之后，今天把veb树赶了出来，因为书上的delete代码在第13行的缩进有问题，给学习带来了困扰。我之前看书有个坏习惯，直接看代码，不看文字讲解，事实证明，这是错的，好多时候只有把理论弄懂才知道为什么要那么写，不过在这里要吐槽一下译本，我看过的书，虽说译本的整体质量高于国人的书，可是糟糕的翻译简直要人命，甚至导致看代码都知道是什么意思了看他讲解还看不明白。 package
BZOJ3685 普通 van Emde Boas 树 题解（vEB 树模板题）
Foliciatarier的博客
03-04 1079
数据结构：van Emde Boas 树
bzoj3685普通VEB树
zx2003的博客
09-04 569
这是一种来自xehoth大爷的奇技淫巧 我改造了一下，从232^3叉7层改成242^4叉5层，以适应2202^{20}左右的值域，但这可能缓存不优？因为辅助数组长度为65536，可能装不进缓存，感觉不太懂这套理论。 把5层改成6层（值域变成16777216）后测了一下: 插入10710^7个随机数是870ms左右； 删除10710^7个随机数是335ms左右（因为随出来的不一定在集合里）
van Emde Boas树的定义
最新发布
03-06
van Emde Boas树是一种数据结构，用于实现字典数据结构，支持插入、删除、查找等操作，具有较快的时间复杂度。它是一种树形结构，每个节点包含一个二进制数，用于表示子树中存在的元素的范围。它的时间复杂度为O(log log n)，空间复杂度为O(n)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值