训练营code

最新推荐文章于 2024-07-17 20:40:47 发布
最新推荐文章于 2024-07-17 20:40:47 发布
阅读量148 收藏
点赞数
分类专栏： 算法
原文链接：https://blog.csdn.net/xiaotai1234/article/details/108919550
版权 
package 训练营01.class01;

import java.util.LinkedList;

public class Code01_SlidingWindowMaxArray {

	public static int[] getMaxWindow(int[] arr, int w) {
		if (arr == null || w < 1 || arr.length < w) {
			return null;
		}
		// 其中放的是位置，arr[位置]
		LinkedList<Integer> qmax = new LinkedList<Integer>();
		int[] res = new int[arr.length - w + 1];
		int index = 0;
		for (int i = 0; i < arr.length; i++) { // 当前让 i -> [i] 进窗口 ， i 就是 r
			while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[i]) {
				qmax.pollLast();
			}
			qmax.addLast(i);
			if (qmax.peekFirst() == i - w) {
				qmax.pollFirst();
			}
			if (i >= w - 1) {
				res[index++] = arr[qmax.peekFirst()];
			}
		}
		return res;
	}

	// for test
	public static int[] rightWay(int[] arr, int w) {
		if (arr == null || w < 1 || arr.length < w) {
			return null;
		}
		int[] res = new int[arr.length - w + 1];
		int index = 0;
		int L = 0;
		int R = w - 1;
		while (R < arr.length) {
			int max = arr[L];
			for (int i = L + 1; i <= R; i++) {
				max = Math.max(max, arr[i]);

			}
			res[index++] = max;
			L++;
			R++;
		}
		return res;
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * (maxValue + 1));
		}
		return arr;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		int testTime = 100000;
		int maxSize = 100;
		int maxValue = 100;
		System.out.println("test begin");
		for (int i = 0; i < testTime; i++) {
			int[] arr = generateRandomArray(maxSize, maxValue);
			int w = (int) (Math.random() * (arr.length + 1));
			int[] ans1 = getMaxWindow(arr, w);
			int[] ans2 = rightWay(arr, w);
			if (!isEqual(ans1, ans2)) {
				System.out.println("Oops!");
			}
		}
		System.out.println("test finish");
	}

}

package 训练营01.class01;

import java.util.LinkedList;

public class Code02_AllLessNumSubArray {

	public static int getNum(int[] arr, int num) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		LinkedList<Integer> qmin = new LinkedList<Integer>();
		LinkedList<Integer> qmax = new LinkedList<Integer>();
		int L = 0;
		int R = 0;
		int res = 0;
		while (L < arr.length) { // L是开头位置，尝试每一个开头
			// 如果此时窗口的开头是L,下面的while工作:R向右扩到违规为止
			while (R < arr.length) { // R是最后一个达标位置的再下一个
				while (!qmin.isEmpty() && arr[qmin.peekLast()] >= arr[R]) {
					qmin.pollLast();
				}
				qmin.addLast(R);
				// R -> arr[R],
				while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) {
					qmax.pollLast();
				}
				qmax.addLast(R);
				if (arr[qmax.getFirst()] - arr[qmin.getFirst()] > num) {
					break;
				}
				R++;
			}
			// R是最后一个达标位置的再下一个，第一个违规的位置
			res += R - L;
			// L向右移动之前，先将自身剔除出2个滑动窗口
			if (qmin.peekFirst() == L) {
				qmin.pollFirst();
			}
			if (qmax.peekFirst() == L) {
				qmax.pollFirst();
			}
			L++;
		}
		return res;
	}

	// for test
	public static int[] getRandomArray(int len) {
		if (len < 0) {
			return null;
		}
		int[] arr = new int[len];
		for (int i = 0; i < len; i++) {
			arr[i] = (int) (Math.random() * 10);
		}
		return arr;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr != null) {
			for (int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int[] arr = getRandomArray(30);
		int num = 5;
		printArray(arr);
		System.out.println(getNum(arr, num));

	}

}

package 训练营01.class01;

import java.util.List;
import java.util.ArrayList;
import java.util.Stack;

public class Code03_MonotonousStack {

	public static int[][] getNearLessNoRepeat(int[] arr) {
		int[][] res = new int[arr.length][2];
		Stack<Integer> stack = new Stack<>();
		for (int i = 0; i < arr.length; i++) {
			while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
				int popIndex = stack.pop();
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
				res[popIndex][0] = leftLessIndex;
				res[popIndex][1] = i;
			}
			stack.push(i);
		}
		while (!stack.isEmpty()) {
			int popIndex = stack.pop();
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
			res[popIndex][0] = leftLessIndex;
			res[popIndex][1] = -1;
		}
		return res;
	}

	public static int[][] getNearLess(int[] arr) {
		int[][] res = new int[arr.length][2];
		// List<Integer> -> 放的是位置，同样值的东西，位置压在一起
		Stack<List<Integer>> stack = new Stack<>();
		for (int i = 0; i < arr.length; i++) { // i -> arr[i] 进栈
			// 底 -> 顶， 小 -> 大
			while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) {
				List<Integer> popIs = stack.pop();
				// 取位于下面位置的列表中，最晚加入的那个
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
				for (Integer popi : popIs) {
					res[popi][0] = leftLessIndex;
					res[popi][1] = i;
				}
			}
			// 相等的、比你小的
			if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]) {
				stack.peek().add(Integer.valueOf(i));
			} else {
				ArrayList<Integer> list = new ArrayList<>();
				list.add(i);
				stack.push(list);
			}
		}
		while (!stack.isEmpty()) {
			List<Integer> popIs = stack.pop();
			// 取位于下面位置的列表中，最晚加入的那个
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
			for (Integer popi : popIs) {
				res[popi][0] = leftLessIndex;
				res[popi][1] = -1;
			}
		}
		return res;
	}

	// for test
	public static int[] getRandomArrayNoRepeat(int size) {
		int[] arr = new int[(int) (Math.random() * size) + 1];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		for (int i = 0; i < arr.length; i++) {
			int swapIndex = (int) (Math.random() * arr.length);
			int tmp = arr[swapIndex];
			arr[swapIndex] = arr[i];
			arr[i] = tmp;
		}
		return arr;
	}

	// for test
	public static int[] getRandomArray(int size, int max) {
		int[] arr = new int[(int) (Math.random() * size) + 1];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * max) - (int) (Math.random() * max);
		}
		return arr;
	}

	// for test
	public static int[][] rightWay(int[] arr) {
		int[][] res = new int[arr.length][2];
		for (int i = 0; i < arr.length; i++) {
			int leftLessIndex = -1;
			int rightLessIndex = -1;
			int cur = i - 1;
			while (cur >= 0) {
				if (arr[cur] < arr[i]) {
					leftLessIndex = cur;
					break;
				}
				cur--;
			}
			cur = i + 1;
			while (cur < arr.length) {
				if (arr[cur] < arr[i]) {
					rightLessIndex = cur;
					break;
				}
				cur++;
			}
			res[i][0] = leftLessIndex;
			res[i][1] = rightLessIndex;
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[][] res1, int[][] res2) {
		if (res1.length != res2.length) {
			return false;
		}
		for (int i = 0; i < res1.length; i++) {
			if (res1[i][0] != res2[i][0] || res1[i][1] != res2[i][1]) {
				return false;
			}
		}

		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int size = 10;
		int max = 20;
		int testTimes = 2000000;
		for (int i = 0; i < testTimes; i++) {
			int[] arr1 = getRandomArrayNoRepeat(size);
			int[] arr2 = getRandomArray(size, max);
			if (!isEqual(getNearLessNoRepeat(arr1), rightWay(arr1))) {
				System.out.println("Oops!");
				printArray(arr1);
				break;
			}
			if (!isEqual(getNearLess(arr2), rightWay(arr2))) {
				System.out.println("Oops!");
				printArray(arr2);
				break;
			}
		}
	}
}

package 训练营01.class01;

import java.util.Stack;

public class Code04_AllTimesMinToMax {

	public static int max1(int[] arr) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j < arr.length; j++) {
				int minNum = Integer.MAX_VALUE;
				int sum = 0;
				for (int k = i; k <= j; k++) {
					sum += arr[k];
					minNum = Math.min(minNum, arr[k]);
				}
				max = Math.max(max, minNum * sum);
			}
		}
		return max;
	}

	public static int max2(int[] arr) {
		int size = arr.length;
		int[] sums = new int[size];
		sums[0] = arr[0];
		for (int i = 1; i < size; i++) {
			sums[i] = sums[i - 1] + arr[i];
		}
		int max = Integer.MIN_VALUE;
		Stack<Integer> stack = new Stack<Integer>();
		for (int i = 0; i < size; i++) {
			while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) {
				int j = stack.pop();
				max = Math.max(max, (stack.isEmpty() ? sums[i - 1] : (sums[i - 1] - sums[stack.peek()])) * arr[j]);
			}
			stack.push(i);
		}
		while (!stack.isEmpty()) {
			int j = stack.pop();
			max = Math.max(max, (stack.isEmpty() ? sums[size - 1] : (sums[size - 1] - sums[stack.peek()])) * arr[j]);
		}
		return max;
	}

	public static int[] gerenareRondomArray() {
		int[] arr = new int[(int) (Math.random() * 20) + 10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 101);
		}
		return arr;
	}

	public static void main(String[] args) {
		int testTimes = 2000000;
		System.out.println("test begin");
		for (int i = 0; i < testTimes; i++) {
			int[] arr = gerenareRondomArray();
			if (max1(arr) != max2(arr)) {
				System.out.println("FUCK!");
				break;
			}
		}
		System.out.println("test finish");
	}

}

package 训练营01.class04;

public class Code01_KMP {

	public static int getIndexOf(String s, String m) {
		if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
			return -1;
		}
		char[] str1 = s.toCharArray();
		char[] str2 = m.toCharArray();
		int x = 0;
		int y = 0;
		int[] next = getNextArray(str2);
		while (x < str1.length && y < str2.length) {
			if (str1[x] == str2[y]) {
				x++;
				y++;
			} else if (next[y] == -1) {
				x++;
			} else {
				y = next[y];
			}
		}
		return y == str2.length ? x - y : -1;
	}

	public static int[] getNextArray(char[] ms) {
		if (ms.length == 1) {
			return new int[] { -1 };
		}
		int[] next = new int[ms.length];
		next[0] = -1;
		next[1] = 0;
		int i = 2;
		// cn代表，cn位置的字符，是当前和i-1位置比较的字符
		int cn = 0;
		while (i < next.length) {
			if (ms[i - 1] == ms[cn]) {
				next[i++] = ++cn;
			} else if (cn > 0) {
				cn = next[cn];
			} else {
				next[i++] = 0;
			}
		}
		return next;
	}

	// for test
	public static String getRandomString(int possibilities, int size) {
		char[] ans = new char[(int) (Math.random() * size) + 1];
		for (int i = 0; i < ans.length; i++) {
			ans[i] = (char) ((int) (Math.random() * possibilities) + 'a');
		}
		return String.valueOf(ans);
	}

	public static void main(String[] args) {
		int possibilities = 5;
		int strSize = 20;
		int matchSize = 5;
		int testTimes = 5000000;
		System.out.println("test begin");
		for (int i = 0; i < testTimes; i++) {
			String str = getRandomString(possibilities, strSize);
			String match = getRandomString(possibilities, matchSize);
			if (getIndexOf(str, match) != str.indexOf(match)) {
				System.out.println("Oops!");
			}
		}
		System.out.println("test finish");
	}

}

 

氯雷他定.
关注
专栏目录
算法基础13-《进阶》单调栈和窗口及其更新结构
weixin_42503072的博客
04-01 331
文章目录1 单调栈和窗口及其更新结构1.1 窗口1.1.1 滑动窗口是什么？1.1.2 滑动窗口能做什么？1.1.3 维护窗口滑动的更新结构1.1.4 高频题：求滑动窗口最大值1.1.5 高频题二：达标子数组数量问题---560（不算）1.1.6 如何优化一个问题？1.2 单调栈1.2.1 单调栈结构1.2.2 单调栈的应用 1 单调栈和窗口及其更新结构 1.1 窗口 1.1.1 滑动窗口是什么？ 窗口只是我们脑海中的一个范围，用过L和R来规定我们窗口的边界。保证L<=R这个条件 1、滑动窗口是一
100-Days-of-Code:基于100天代码的挑战-Udemy上提供了2021课程的完整Python Pro训练营。 主要目标是在创建一致的编程例程的同时改善Phython
03-17
Udemy上的"2021年完整Python Pro训练营"是一个专门针对这个挑战设计的课程，它涵盖了Python语言的各个方面，帮助学员从零基础到精通。 Python是一种高级编程语言，以其简洁明了的语法和强大的功能而受到广大开发者...
窗口及窗口内最大值或最小值的更新结构（单调双向队列）详解（java实现）
宇翔XGT的博客
06-22 332
package advanced_class_02;import java.util.HashMap;import java.util.LinkedList;/* * 窗口及窗口内最大值或最小值的更新结构（单调双向队列） *  * 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。 * 例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他...
算法:Sliding Window Maximum(滑动窗口最大值)
AI架构师易筋
03-09 2012
说明 算法：Sliding Window Maximum LeetCode地址：https://leetcode.com/problems/sliding-window-maximum/ 题目： Given an array nums, there is a sliding window of size k which is moving from the very left of the arr...
单调栈结构
Harrison的学习博客
03-26 253
单调栈是什么? 一种特别设计的栈结构，为了解决如下的问题： 给定一个可能含有重复值的数组arr，i位置的数一定存在如下两个信息 arr[i] 的左侧离 i 最近并且小于(或者大于)arr[i]的数在哪? arr[i] 的右侧离 i 最近并且小于(或者大于)arr[i]的数在哪? 如果想得到arr中所有位置的两个信息，怎么能让得到信息的过程尽量快。 那么到底怎么设计呢? 要求时间复杂度为O(N) package com.harrison.class14; import java.util.ArrayLi
算法数据结构（二十三）----单调栈（一）
u011624267的博客
08-16 307
单调栈是什么？ 一种特别设计的栈结构，为了解决如下的问题： 给定一个可能含有重复值的数组arr，i位置的数一定存在如下两个信息 1）arr[i]的左侧离i最近并且小于(或者大于)arr[i]的数在哪？ 2）arr[i]的右侧离i最近并且小于(或者大于)arr[i]的数在哪？ 如果想得到arr中所有位置的两个信息，怎么能让得到信息的过程尽量快。 那么到底怎么设计呢？ 题目一 单调栈实现 没重复值的单调栈实现： 1）栈中元素存数组下标 2）栈按元素值从小到大排序 3）当新来的一个.
百度前端实战训练营
m0_56475481的博客
07-05 2614
学前端Day1
极客大学python训练营目录_极客大学算法训练营笔记
weixin_39552286的博客
12-16 3334
一、数据结构和算法总览image.pngimage.png1.刻意练习过遍数：五毒神掌 ； 刻意练习自己的弱项练习基本功很重要主动式反馈 ： 寻求更好的方法和方式：leetcode高手代码被动式反馈 ： code review 教练指点image.pngimage.pngimage.pngimage.png需要得到肌肉式记忆2.环境配置及工具类command + left/right : 去到行头...
算法训练营0515
qq_39368111的博客
05-18 315
如何高效学习 如何系统学习数据结构与算法 注重预习 课堂互动 课后作业（切题方法） 精通一个领域 切碎知识点 刻意练习 反馈 切碎知识点 数据结构 算法（八大点） 三个基础+5个高级 刻意练习 一只脚在舒适区，一只脚在… 切题四件套 Clarification（看清题目） Possible Solutions（所有能想到的解法） compare(time/spare) optimal(加强） Coding Test cases 五毒神掌（五遍刷题法） 1.第一遍：读题+思考
嘉立创暑期训练营——温湿度检测仪
m0_74245657的博客
07-17 527
温湿度检测仪，stm32g030k6t6
100_Days_Of_Code:Udemy课程“ 100天的代码-2021年完整的Python Pro训练营”中的编码挑战存储库，作者：Angela Yu博士
03-31
标题 "100_Days_of_Code" 指的是一个编程学习挑战，源自Angela Yu博士在Udemy平台上开设的“100天的代码 - 2021年完整的Python Pro训练营”。这个挑战旨在帮助学员通过连续100天的编程实践，系统地学习和提升Python...
Code_Refactor:第一次训练营作业
03-17
在“Code_Refactor:第一次训练营作业”中，我们聚焦于HTML（超文本标记语言）这一重要的网页制作技术。HTML是构建网页结构的基础，通过它我们可以定义内容的标题、段落、链接、图像等元素。这次训练营的作业可能是...
Code-Refactor:训练营分配1
05-23
你的任务 注意：开始作业前，请务必阅读《和《 ！ 这个星期是一个奇数周，因此您的作业是在职票，这意味着您将从需要修改的入门代码开始。 本周的作业涉及Web开发的一个非常重要的方面：可访问性。...
Week4-A-Code-Quiz:编码训练营-作业-第四周-代码测验
03-22
编码训练营-作业-第四周-代码测验 目录 基本信息 这项作业的任务是建立一个包含多项选择题的定时编码测验。 此应用必须在浏览器中运行，并具有动态更新HTML和CSS（由JavaScript代码提供支持），并且全部是从头开始...
BS23-287基于Python的期货程序化交易系统的设计与实现-206jhypi.zip
11-06
本系统的开发与设计是基于vue为前端页面核心框架为django/flask，技术方面主要采用了Html、Js、CSS3、python、Mysql。 本课题使用Python语言进行开发。代码层面的操作主要在PyCharm中进行，将系统所使用到的表以及数据存储到MySQL数据库中，方便对数据进行操作本课题基于WEB的开发平台 ②前端开发选择：Vue。 ②后端开发选择：python、django/flask。 ③数据库选择：MySQL。 ④开发工具选择：pycharm、Navicat for MySQL。 包含了我的信息、用户管理、期货公司管理、开户信息管理、充值信息管理、期货期货信息管理、期货投资管理、取消投资管理、投资风险管理、意见反馈、系统管理
springboot052基于Springboot+Vue旅游管理系统毕业源码案例设计.zip
最新发布
11-06
springboot052基于Springboot+Vue旅游管理系统毕业源码案例设计 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
Matlab实现牛顿拉夫逊优化算法NRBO-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
11-06
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现樽海鞘优化算法SSA-GRU实现风电数据预测算法研究.rar
11-06
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
基于向量加权平均算法INFO-Kmean-Transformer-GRU实现数据回归预测算法研究Matlab代码.rar
11-06
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
Python 00-1903训练营课程内容概览
资源摘要信息:"Python 00-1903训练营.zip" 在本次的文件信息中，我们关注的焦点是一个名为“Python 00-1903训练营.zip”的压缩文件。虽然文件的具体内容没有详细列出，但是从标题中我们可以推测出这个压缩包可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值