【Leecode笔记】第十八周下（1.5-1.8）位运算专题

最新推荐文章于 2024-08-09 09:36:32 发布
最新推荐文章于 2024-08-09 09:36:32 发布
阅读量346 收藏
点赞数
分类专栏： Leecode 文章标签： java 位运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40335368/article/details/112232096
版权

【第一题】丢失的数字

在这里插入图片描述

分析：
1.位运算异或。
2.求和。由1到n项的数列和-目前的sum
3.哈希表/桶

//1.位运算异或。
//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.9 MB, 在所有 Java 提交中击败了63.68% 的用户
class Solution{
    public int missingNumber(int[] nums){
        int res = nums.length;
        for(int i = 0;i < nums.length;i++){
            res ^= nums[i] ^i;
        }
        return res;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：39.1 MB, 在所有 Java 提交中击败了36.75% 的用户
class Solution {
    public int missingNumber(int[] nums) {
        int sum = 0;
        for(int i = 0;i < nums.length;i++){
            sum += nums[i];
        }
        return nums.length *(nums.length + 1)/2-sum;
    }
}

【第二题】数字转换为十六进制数

在这里插入图片描述

分析：

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.7 MB, 在所有 Java 提交中击败了52.89% 的用户
class Solution {
    public String toHex(int num) {
        if(num == 0){return "0";}
        char[] chars = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        StringBuilder sb = new StringBuilder();
        while(sb.length() < 8 && num!=0){
            sb.append(chars[num & 0xf]);
            num >>=4;
        }
        return sb.reverse().toString();
    }
}

【第三题】2的幂

在这里插入图片描述

分析：
方法一：n&n-1 == 0?
方法二：n & -n == n?

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.4 MB, 在所有 Java 提交中击败了80.26% 的用户
class Solution {
    public boolean isPowerOfTwo(int n) {
        if(n <=0) return false;
        if((n & n-1) == 0){
            return true;
        }
        return false;
    }
}

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了89.05% 的用户
class Solution {
    public boolean isPowerOfTwo(int n) {
		return (n > 0) && (n & -n);
	}
}

【第四题】插入

在这里插入图片描述

分析：首先构造二进制位，根据需要插入的起始位和终止位，（也就是说，把起始位到终止位的部分都设置成0，其他的都是1），然后N=N&n，目的是使N的i-j位全部为0，便于下一步的插入。然后把M左移i位，这样末尾就是第i-j位，最后把M和N进行或运算，得出结果。
在这里插入图片描述

class Solution{
	public static insertBits(int N,int N,int i,int j){
		int n = ~((-1 >>>(31-j))&(-1<<i));
		N = N&n;
		M = M<<i;
		N=M|N;
		return N;
	}
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了43.37% 的用户
class Solution {
    public int insertBits(int N, int M, int i, int j) {
        int mask = ~(((1 << (j-i+1))-1) << i);
        N&=mask;
        M = M<<i;
        return M|N;
    }
}

【第四题】两整数之和

在这里插入图片描述

分析：两个整数a,b。假如没有进位，那么a^b就是两者之和；假如有进位，让无进位相加的结果与进位不断地异或，直到进位为0.

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.4 MB, 在所有 Java 提交中击败了24.37% 的用户
class Solution {
    public int getSum(int a, int b) {
        int sum,carry;
        sum = a^b;
        carry = (a & b) <<1;
        if(carry !=0){
           return getSum(sum,carry); 
        }
        return sum;
    }
}

【第五题】位1的个数

分析：
方法一：移位操作，假如末尾是1，count++，然后算术右移（不考虑符号位）。
方法二：

//执行用时：1 ms, 在所有 Java 提交中击败了95.41% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了68.12% 的用户
public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int cnt = 0;
        while(n !=0){
            n &= (n-1);
            cnt++;
        }
        return cnt;
    }
}

【第六题】二进制手表（挖坑等回溯算法）

https://leetcode-cn.com/problems/binary-watch/
在这里插入图片描述

分析：二进制手表第一排的四个灯表示（0-11），第二排的6个灯表示分钟（0-59），都是根据二进制位，亮灯为1，不亮为0.
给定亮灯数目，返回所有可能的时间。其实就是判断1的个数

要注意的是小时和分钟的格式，小时（是几位就是几位），分钟（一律两位数，不足两位高位补零）。

【第七题】多数元素

在这里插入图片描述

分析：这个题可以分成两道题做。

方法一：排序+双指针；
方法二：直接排序求中位数；
方法三：位运算（假如该数为众数，那么出现该数的次数一定大于n/2，同理它的二进制位上每个1的个数也大于n/2，只要统计每一位1出现的次数大于n/2的相加得出结果即可。假如出现最多次数的是0，那么没有一个数出现的1大于n/2，直接返回0即可）；
方法四：哈希表（杀鸡用牛刀的意思）
方法五：投票法（假如只有两种元素，那么可以直接用flag消除法。多种元素和消除法一样的思路，投票法，最后剩下的那个数一定是众数）

//执行用时：3 ms, 在所有 Java 提交中击败了43.19% 的用户
//内存消耗：41.7 MB, 在所有 Java 提交中击败了66.36% 的用户
class Solution {
    public int majorityElement(int[] nums) {
        if(nums.length == 1 || nums.length == 2){return nums[0];}
        // if(nums.length == 2){
        //     // if(nums[0] == nums[1]){
        //     //     return nums[0];
        //     // }else{
        //     //     return 0;
        //     // }
        //     return nums[0];
        // }
        Arrays.sort(nums);
        
        int count = 1;
        int i = 0,j = 1;
        while(j < nums.length){
            if(nums[j] == nums[i]){
                count++;
                j++;
            }else{
                if(count > nums.length/2){
                    return nums[i];
                }else{
                    i = j;
                    j++;
                }
            }
        }
        return count > nums.length/2? nums[i]:0;
    }
}

//执行用时：2 ms, 在所有 Java 提交中击败了74.14% 的用户
//内存消耗：41.6 MB, 在所有 Java 提交中击败了80.18% 的用户
class Solution {
    public int majorityElement(int[] nums) {
        if(nums.length == 1 || nums.length == 2){return nums[0];}
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

class Solution{
	public int majorityElement(int[] nums) {
        int result = 0, k = nums.length >> 1;
        for (int j = 0; j < 32; j++) {
            int count = 0;
            for (int num : nums) {
                count += num >> j & 1;
                if (count > k) {
                    result += 1 << j;
                    break;
                }
            }
        }
        return result;
    }
}

//执行用时：3 ms, 在所有 Java 提交中击败了43.19% 的用户
//内存消耗：44.4 MB, 在所有 Java 提交中击败了5.03% 的用户
class Solution{
	public int majorityElement(int[] nums){
		int count = 0;
		Integer candidate = null;
		for(int num:nums){
			if(count == 0){candidate = num;}
			count+=(num == candidate)?1:-1;
		}
		return candidate;
	}
}

【第八题】二进制表示中质数个计算置位

在这里插入图片描述分析：简简单单统计个数，简简单单判断质数。不是吧，看完官方题解表示还能这么搞？

//执行用时：41 ms, 在所有 Java 提交中击败了18.66% 的用户
//内存消耗：35.2 MB, 在所有 Java 提交中击败了77.65% 的用户
class Solution {
    public int countPrimeSetBits(int L, int R) {
        int cnt = 0;
        for(int i = L;i <= R;i++){
            if(isPrime(countOne(i))){
                cnt++;
            }
        }
        return cnt;
    }
    
    public int countOne(int n){
        int count = 0;
        while(n!=0){
            if((n & 1) == 1){
                count++;
            }
            n = n>>>1;
        }
        return count;
    }

    public boolean isPrime(int n){
        if(n == 1){return false;}
        
        for(int i = 2;i <= Math.sqrt(n);i++){
            if(n % i == 0){
                return false;
            }
        }
        return true;
    }
}

class Solution {
    public int countPrimeSetBits(int L, int R) {
        int ans = 0;
        for (int x = L; x <= R; ++x)
            if (isSmallPrime(Integer.bitCount(x)))
                ans++;
        return ans;
    }
    public boolean isSmallPrime(int x) {
        return (x == 2 || x == 3 || x == 5 || x == 7 ||
                x == 11 || x == 13 || x == 17 || x == 19);
    }
}

【第九题】配对交换

在这里插入图片描述

分析：

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了46.26% 的用户
class Solution {
    public int exchangeBits(int num) {
        int ans = 0;
        for (int i = 0; i < 30; i += 2) {
        	//取每个奇数位
            int a = num & (1 << i);
            //取每个偶数位
            int b = num & (1 << (i + 1));
            //将偶数位设置为a,将奇数位设置为b
            ans |= (a << 1);
            ans |= (b >> 1);
        }
        return ans;
    }
}

//这个题解太妙了
/*思路的话就是分别取出奇数位和偶数位，移动后做或运算。
题目规定 num 是int范围的数
0x55555555 = 0b0101_0101_0101_0101_0101_0101_0101_0101
0xaaaaaaaa = 0b1010_1010_1010_1010_1010_1010_1010_1010
用这两个数做与运算，就可以把奇数位和偶数位取出来，
然后位左移奇数位，右移偶数位，再把奇数位和偶数位做或运算

作者：releng-xing
链接：https://leetcode-cn.com/problems/exchange-lcci/solution/wei-yun-suan-jie-jue-by-releng-xing/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
*/
class Solution {
    public int exchangeBits(int num) {
        //奇数
        int odd = num & 0x55555555;
        //偶数
        int even = num & 0xaaaaaaaa;
        odd = odd << 1;
        even = even >>> 1;
        return odd | even;
    }
}

【第十题】颠倒二进制位

在这里插入图片描述

分析：初始化变量res存放num的位，每次获取num的最后一位，和res相或，然后将num右移，将res左移，循环32次，最后的结果就是res

//执行用时：1 ms, 在所有 Java 提交中击败了99.97% 的用户
//内存消耗：38.3 MB, 在所有 Java 提交中击败了38.97% 的用户
class Solution{
	public int reverseBits(int n){
		int res = 0;
		for(int i = 0;i < 32;++i){
			res = res << 1;
			res = n&1 | res;
			n = n >> 1;
		}
		return res;
	}
}

【第十一题】消失的数字

在这里插入图片描述

分析：重拳出击后发现，击败17%。
方法一：排序+数组元素与下标对比
方法二：异或（数字、下标一起异或，假如数字存在，那么必定有和它相同的下标，根据异或的交换律，就有异或结果为0，异或结果就是消失的那个数）
方法三：等差数列求和公式-sum

//执行用时：6 ms, 在所有 Java 提交中击败了17.77% 的用户
//内存消耗：39 MB, 在所有 Java 提交中击败了45.90% 的用户
class Solution {
    public int missingNumber(int[] nums) {
        Arrays.sort(nums);
        for(int i = 0;i < nums.length;i++){
            if(i!=nums[i]){
                return i;
            }
        }
        return nums.length;
    }
}

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.8 MB, 在所有 Java 提交中击败了74.32% 的用户
class Solution{
    public int missingNumber(int[]nums){
        int result=nums.length;
        for(int i=0;i<nums.length;i++){
            result^=i^nums[i];
        }
        return result;
    }
}

【第十二题】交替位二进制数

在这里插入图片描述

分析：
方法一：移位，直接取末尾数比较。
方法二：String str = Integer.toBinaryString(n);对字符串进行操作

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.2 MB, 在所有 Java 提交中击败了64.31% 的用户
class Solution {
    public boolean hasAlternatingBits(int n) {
        while(n!=0){
            int num1 = n&1;
            n >>=1;
            int num2 = n&1;
            if(num1 == num2){
                return false;
            }
        }
        return true;
    }
}

【第十三题】4的幂

在这里插入图片描述

分析：除了0以外，假如末尾有偶数个0，且首位为1，就是4的幂。也就是说，只有1个1，且出现在奇数位。

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了85.12% 的用户
class Solution{
    public boolean isPowerOfFour(int num){
        //检查是不是2的幂
        return (num > 0) && ((num & (num-1)) == 0 && (num % 3 == 1));
    }
}

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了81.43% 的用户
class Solution {
    public boolean isPowerOfFour(int n) {
        if(n < 0){return false;}
        if(n == 1){return true;}
        int temp = n;
        int Total = 0;//统计位数
        int countZero = 0;//统计0的个数
        while(n !=0){
            if((n&1) == 0){
                countZero++;
            }
            Total++;
            n >>=1;
        }
        temp = temp >> (Total-1);//保存首位
        if(temp == 1 && countZero+1==Total && countZero%2==0){
            return true;
        }
        return false;
    }
}

【第十四题】汉明距离

在这里插入图片描述

分析：重拳出击！

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35 MB, 在所有 Java 提交中击败了85.31% 的用户
class Solution {
    public int hammingDistance(int x, int y) {
        int count = 0;
        while(x !=0 || y !=0){
            if((x&1)!=(y&1)){
                count++;
            }
            x >>= 1;
            y >>= 1;
        }
        while(x!=0){
            x >>=1;
            count++;
        }
        while(y!=0){
            y >>=1;
            count++;
        }
        return count;
    }
}

【第十六题】翻转数位

在这里插入图片描述

分析：题意——将一个数位从0变为1，找出最长的1的长度。
注意负数！注意二进制32位全为1的数！注意注意二进制位是全1，但是不是32个1的数！

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35 MB, 在所有 Java 提交中击败了93.35% 的用户
class Solution {
    public int reverseBits(int num) {
        if(num == 0){return 1;}
        int maxLen = 0,curLen = 0;
        //只允许一次翻转
        boolean flag = true;
        int num1 = 0;
        //记录二进制位总数
        int count1 = 0;
        //记录1的个数
        int count2 = 0;
        while(num !=0){
            if((num & 1) == 1){
                curLen++;
                if(flag == false){
                    num1++;
                }
                count2++;
            }else{
                //第一次翻转
                if(flag == true){
                    curLen++;
                    flag = false;
                    
                }else{
                    //之后遇到0则num1重新计数
                    maxLen = Math.max(maxLen,curLen);
                    curLen = num1+1;
                    num1 = 0;
                }
            }
            //System.out.println(num&1);
            num >>>=1;
            count1++;
        }
        if(count1 == count2 && count1 < 32){
            curLen++;
        }
        maxLen = Math.max(maxLen,curLen);
        return maxLen;
    }
}

【第十七题】最大数值

在这里插入图片描述

分析：相减看是负数还是正数（看最高位是否为1）

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.3 MB, 在所有 Java 提交中击败了52.85% 的用户
class Solution {
    public int maximum(int a, int b) {
        long val = (long)a - (long)b;
        int[] r = new int[]{a,b};
        return r[(int)(val >>> 63)];
    }
}

【第十八题】数字的补数

在这里插入图片描述

分析：假如输入的数为num，num取反：num ^ (num.length个1)。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.4 MB, 在所有 Java 提交中击败了28.37% 的用户
class Solution {
    public int findComplement(int num) {
        int temp = num;
        int flag = 0;
        while(temp!=0){
            flag++;
            //相当于右移操作
            temp /=2;
        }
        return num^(int)(Math.pow(2,flag) - 1);
    }
}

【第十九题】整数转换

在这里插入图片描述

分析：其实就是输出两者的二进制位有几个不同——汉明距离。
两者异或之后，看1的个数。每执行一次x = x&(x-1)，会将x用二进制表示时最右边的一个1变为0，将所有的1都变为0，这时就统计出了二进制位中1的个数。

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.2 MB, 在所有 Java 提交中击败了55.59% 的用户
class Solution {
    public int convertInteger(int A, int B) {
        int x = A ^ B;
        int cnt = 0;
        while(x !=0){
            x &= (x-1);
            cnt++;
        }
        return cnt;
    }
}

【第二十题】不用加号的减法

在这里插入图片描述

分析：手动实现进位。
在这里插入图片描述

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：35.4 MB, 在所有 Java 提交中击败了31.25% 的用户
class Solution{
	public int add(int a,int b){
		while(b !=0){
			int sum = (a ^ b);
			int carry = (a & b) << 1;
			//迭代处理
			a = sum;
			b = carry;
		}
		return a;
	}
}
是菜鸟不是咸鱼
关注
专栏目录
[论文笔记] Qwen1.5 1.8B、4B、7B、14B、72B tp和pp
心宝的博客
05-06 257
TP=4，PP=1TP=4，PP=1TP=8，PP=4。
Leecode
03-29
Leecode
给你一个整数数组 nums 。 如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i ＜ j ，就可以认为这是一组 好数对 。 返回好数对的数目。 来源：力扣（Le
weixin_45942124的博客
10-05 1238
执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户 内存消耗：36 MB, 在所有 Java 提交中击败了93.38% 的用户 解题思路 数组对应下表存储对应值，先加结果，后自增 代码 class Solution { public int numIdenticalPairs(int[] nums) { int ans=0; int []temp=new int [100]; for(int n:nums){
LeetCode 100道题目和答案（面试必备）（一）
最新发布
qq_15557237的博客
08-09 1600
给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0单词 是指仅由字母组成、不包含任何空格字符的最大子字符串标签：字符串遍历从字符串末尾开始向前遍历，其中主要有两种情况第一种情况，以字符串"Hello World"为例，从后向前遍历直到遍历到头或者遇到空格为止，即为最后一个单词"World"的长度5。
给你一个整数数组 nums 。 如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i ＜ j ，就可以认为这是一组 好数对 。
weixin_44565532的博客
11-20 2657
给你一个整数数组 nums 。 如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。 返回好数对的数目。 示例 1： 输入：nums = [1,2,3,1,1,3] 输出：4 解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始 示例 2： 输入：nums = [1,1,1,1] 输出：6 解释：数组中的每组数字都是好数对 示例 3： 输入：nums = [1,2,3] 输出：0 来源
写一个C#程序：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答
2302_76702437的博客
04-03 278
该程序中，我们使用了哈希表来进行寻找目标值的过程。在遍历数组时，设置 complement 变量为目标值减去当前元素的差值。如果这个差值在哈希表中已经存储了，则说明找到了两个元素，返回这两个元素下标即可。否则，将当前元素及其下标存储在哈希表中，方便后续查找。 需要注意的是，程序中对于异常情况进行了判断，例如输入为空或者输入中没有满足条件的两个数等。此外，程序中只返回了一个满足条件的组合，如果存在多个组合也符合要求，需要根据题意自行修改。
LeeCode
zhongyifly的专栏
01-03 534
You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a link
联发科芯片MT7981应用笔记-MT7981-Application-Note-V1.5-20220310
02-16
《MT7981应用笔记》是针对联发科（MediaTek）的主控芯片MT7981的专业文档，该芯片广泛应用于WIFI6路由器。文档与MT7976C天线芯片和MT7531网络芯片共同构成解决方案，提供了详细的设计指导和注意事项。以下是关于MT...
Linux下64位JDK下载：jdk-1.8.0.381
12-28
Linux下64位JDK下载：jdk-1.8.0.381 如果采用微信支付建议使用此版本 安装配置详见：http://www.laobingbiji.com/note/detail.html?note_id=202311201549350000000010549904
AMS1117-1.8芯片资料
09-22
AMS1117-1.8芯片资料 AMS1117-1.8芯片是Advanced Monolithic Systems, Inc.生产的一款低压差线性稳压器芯片，能够提供高达800mA的输出电流。下面是该芯片的详细知识点： 一、功能特点： * 三端调整或固定电压输出...
3. 无重复字符的最长子串
f1766的博客
07-22 212
无重复字符的最长子串 .给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。 class Solution { public int lengthOfLongestSubstring(String s) { // 哈希集合，记录每个字符是否出现过 Set<Character> occ = new HashSet<Character>(); int n = s.length(); // 右指针.
leecode
SekFu的博客
02-21 218
def singleNumber(nums):     nums.sort()     i = 0     while i &lt; len(nums) - 1:         if (nums[i] != nums[i + 1]):             return nums[i]             i += 2     if i &gt;= len(nums) - 1:      ...
jdk新特性——1.5-1.8（主要）新特性
虚空掠夺者~
09-01 196
jdk1.5新特性：---->里程碑式的版本 静态导入： 可以导入静态方法，可以直接使用，静态导入的信息会优先加载 可变参数： 参数类型... 可以接收任意多个参数 底层是由数组来实现的，参数值都是存放在对应的数组元素中 可变参数只能出现在参数列表的最右边，最多只能出现一次 枚举： 将值一一列举 列举式枚举常常 构造方法一定要私有化 定义属性和方法 定义抽象方法 switch表达式类型支持枚举类型 方向：数据结构、java编
C语言谭浩强教程第三至十章核心笔记
第四章至第十章则进一步深入到C语言的核心概念： - 运算符与表达式：C语言提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、赋值运算符等，用于进行计算和逻辑判断。表达式是由这些运算符连接的常量、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值