算法入门篇十 图

最新推荐文章于 2022-10-23 22:46:00 发布
最新推荐文章于 2022-10-23 22:46:00 发布
阅读量289 收藏 2
点赞数 1
分类专栏： 算法入门 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHYabc123456hh/article/details/106800487
版权

图的存储方式

  • 临接表
  • 临接矩阵

表达

  • 点集/边集
  • 有向图/无向图

Graph（大结构就是图）（包含点集合和边集合）

import java.util.HashMap;
import java.util.HashSet;
 
public class Graph {
    public HashMap<Integer, Node> nodes;//点集合
    public HashSet<Edge> edges;//边集合
 
    public Graph() {
        nodes = new HashMap<>();
        edges = new HashSet<>();
    }
}

Node（点集合） 

import java.util.ArrayList;
 
public class Node {
    public int value;//数值
    public int in;//入度
    public int out;//出度
    public ArrayList<Node> nexts;//从当前点出发，连接的数据点（出度连接的点）
    public ArrayList<Edge> edges;//从当前点出发，连接的边（出度的边）
 
    public Node(int value) {
        this.value = value;
        in = 0;
        out = 0;
        nexts = new ArrayList<>();
        edges = new ArrayList<>();
    }
}

Edge（边集合）

 public class Edge {
    public int weight;//边的权重
    public Node from;//有向边
    public Node to;//有向边
 
    public Edge(int weight, Node from, Node to) {
        this.weight = weight;
        this.from = from;
        this.to = to;
    }
 
}

接口函数（将未知的题目类型转化为我们所熟知的类型，如上图所示）

public class GraphGenerator {

	// matrix 所有的边
	// N*3 的矩阵
	// [weight, from节点上面的值，to节点上面的值]

	//example
	//【7，0，1】第一个代表from，第二个代表to，第三个代表weight
	//【6，1，2】
	//【4，2，0】
	public static Graph createGraph(Integer[][] matrix) {
		Graph graph = new Graph();
		for (int i = 0; i < matrix.length; i++) { // from：matrix[0][0], to：matrix[0][1]  权重（weight）：matrix[0][2]
			Integer from = matrix[i][0];
			Integer to = matrix[i][1];
			Integer weight = matrix[i][2];
			if (!graph.nodes.containsKey(from)) {//将未出现的from放入点集合
				graph.nodes.put(from, new Node(from));
			}
			if (!graph.nodes.containsKey(to)) {//将未出现的to放入点集合
				graph.nodes.put(to, new Node(to));
			}
			Node fromNode = graph.nodes.get(from);//获取from点
			Node toNode = graph.nodes.get(to);//获取to点
			Edge newEdge = new Edge(weight, fromNode, toNode);//创建边
			fromNode.nexts.add(toNode);//from邻居
			fromNode.out++;//出度++
			toNode.in++;//入度++
			fromNode.edges.add(newEdge);//将边放到我所拥有的边集合里面
			graph.edges.add(newEdge);//放入边值
		}
		return graph;
	}

}

图的遍历

宽度优先遍历

代码 

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;

public class Code01_BFS {

	// 从node出发，进行宽度优先遍历
	public static void bfs(Node node) {
		if (node == null) {
			return;
		}
		Queue<Node> queue = new LinkedList<>();
		HashSet<Node> set = new HashSet<>();//防止数据重复
		queue.add(node);
		set.add(node);
		while (!queue.isEmpty()) {
			Node cur = queue.poll();
			System.out.println(cur.value);
			for (Node next : cur.nexts) {
				if (!set.contains(next)) {
					set.add(next);
					queue.add(next);
				}
			}
		}
	}

}

深度优先遍历

代码

import java.util.HashSet;
import java.util.Stack;

public class Code02_DFS {

	public static void dfs(Node node) {
		if (node == null) {
			return;
		}
		Stack<Node> stack = new Stack<>();//保证深度的路径
		HashSet<Node> set = new HashSet<>();
		stack.add(node);
		set.add(node);
		System.out.println(node.value);
		while (!stack.isEmpty()) {
			Node cur = stack.pop();
			for (Node next : cur.nexts) {
				if (!set.contains(next)) {
					stack.push(cur);
					stack.push(next);
					set.add(next);
					System.out.println(next.value);
					break;
				}
			}
		}
	}

}

拓扑排序算法

  • 要求是有向图，入度为0的节点，且没有环

代码

package class06;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Code03_TopologySort {

	// directed graph and no loop
	public static List<Node> sortedTopology(Graph graph) {
		// key：某一个node
		// value：剩余的入度
		HashMap<Node, Integer> inMap = new HashMap<>();
		// 入度为0的点，才能进这个队列
		Queue<Node> zeroInQueue = new LinkedList<>();
		for (Node node : graph.nodes.values()) {
			inMap.put(node, node.in);
			if (node.in == 0) {
				zeroInQueue.add(node);
			}
		}
		// 拓扑排序的结果，依次加入result
		List<Node> result = new ArrayList<>();
		while (!zeroInQueue.isEmpty()) {
			Node cur = zeroInQueue.poll();
			result.add(cur);
			for (Node next : cur.nexts) {
				inMap.put(next, inMap.get(next) - 1);
				if (inMap.get(next) == 0) {
					zeroInQueue.add(next);
				}
			}
		}
		return result;
	}
}

Kruskal算法（并查集）

无向图

  • 加最小的边，只要不形成环，就加上，否则不加入

代码

package class06;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.Stack;

//undirected graph only
public class Code04_Kruskal {
	
	public static class MySets{
		public HashMap<Node, List<Node>>  setMap;
		public MySets(List<Node> nodes) {
			for(Node cur : nodes) {
				List<Node> set = new ArrayList<Node>();
				set.add(cur);
				setMap.put(cur, set);
			}
		}
		
		
		public boolean isSameSet(Node from, Node to) {//判断from和to是否在一个集合
			List<Node> fromSet  = setMap.get(from);
			List<Node> toSet = setMap.get(to);
			return fromSet == toSet;//内存地址
		}
		
		
		public void union(Node from, Node to) {//
			List<Node> fromSet  = setMap.get(from);
			List<Node> toSet = setMap.get(to);
			for(Node toNode : toSet) {
				fromSet.add(toNode);
				setMap.put(toNode, fromSet);
			}
		}
	}
	
	

	
	
	// Union-Find Set
	public static class UnionFind {
		// key 某一个节点， value key节点往上的节点
		private HashMap<Node, Node> fatherMap;
		// key 某一个集合的代表节点, value key所在集合的节点个数
		private HashMap<Node, Integer> sizeMap;

		public UnionFind() {
			fatherMap = new HashMap<Node, Node>();
			sizeMap = new HashMap<Node, Integer>();
		}
		
		public void makeSets(Collection<Node> nodes) {
			fatherMap.clear();
			sizeMap.clear();
			for (Node node : nodes) {
				fatherMap.put(node, node);
				sizeMap.put(node, 1);
			}
		}

		private Node findFather(Node n) {
			Stack<Node> path = new Stack<>();
			while(n != fatherMap.get(n)) {
				path.add(n);
				n = fatherMap.get(n);
			}
			while(!path.isEmpty()) {
				fatherMap.put(path.pop(), n);
			}
			return n;
		}

		public boolean isSameSet(Node a, Node b) {
			return findFather(a) == findFather(b);
		}

		public void union(Node a, Node b) {
			if (a == null || b == null) {
				return;
			}
			Node aDai = findFather(a);
			Node bDai = findFather(b);
			if (aDai != bDai) {
				int aSetSize = sizeMap.get(aDai);
				int bSetSize = sizeMap.get(bDai);
				if (aSetSize <= bSetSize) {
					fatherMap.put(aDai, bDai);
					sizeMap.put(bDai, aSetSize + bSetSize);
					sizeMap.remove(aDai);
				} else {
					fatherMap.put(bDai, aDai);
					sizeMap.put(aDai, aSetSize + bSetSize);
					sizeMap.remove(bDai);
				}
			}
		}
	}
	

	public static class EdgeComparator implements Comparator<Edge> {

		@Override
		public int compare(Edge o1, Edge o2) {
			return o1.weight - o2.weight;
		}

	}

	public static Set<Edge> kruskalMST(Graph graph) {
		UnionFind unionFind = new UnionFind();
		unionFind.makeSets(graph.nodes.values());
		PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
		for (Edge edge : graph.edges) { // M 条边
			priorityQueue.add(edge);  // O(logM)
		}
		Set<Edge> result = new HashSet<>();
		while (!priorityQueue.isEmpty()) { // M 条边
			Edge edge = priorityQueue.poll(); // O(logM)
			if (!unionFind.isSameSet(edge.from, edge.to)) { // O(1)
				result.add(edge);
				unionFind.union(edge.from, edge.to);
			}
		}
		return result;
	}
}

prim算法

无向图

代码

package class06;

import java.util.Comparator;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;

// undirected graph only
public class Code05_Prim {

	public static class EdgeComparator implements Comparator<Edge> {

		@Override
		public int compare(Edge o1, Edge o2) {
			return o1.weight - o2.weight;
		}

	}

	public static Set<Edge> primMST(Graph graph) {
		// 解锁的边进入小根堆
		PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(
				new EdgeComparator());
		HashSet<Node> set = new HashSet<>();
		Set<Edge> result = new HashSet<>(); // 依次挑选的的边在result里
		for (Node node : graph.nodes.values()) { // 随便挑了一个点
			// node 是开始点
			if (!set.contains(node)) {
				set.add(node);
				for (Edge edge : node.edges) { // 由一个点，解锁所有相连的边
					priorityQueue.add(edge);
				}
				while (!priorityQueue.isEmpty()) {
					Edge edge = priorityQueue.poll(); // 弹出解锁的边中，最小的边
					Node toNode = edge.to; // 可能的一个新的点
					if (!set.contains(toNode)) { // 不含有的时候，就是新的点
						set.add(toNode);
						result.add(edge);
						for (Edge nextEdge : toNode.edges) {
							priorityQueue.add(nextEdge);
						}
					}
				}
			}
			//break;
		}
		return result;
	}

	// 请保证graph是连通图
	// graph[i][j]表示点i到点j的距离，如果是系统最大值代表无路
	// 返回值是最小连通图的路径之和
	public static int prim(int[][] graph) {
		int size = graph.length;
		int[] distances = new int[size];
		boolean[] visit = new boolean[size];
		visit[0] = true;
		for (int i = 0; i < size; i++) {
			distances[i] = graph[0][i];
		}
		int sum = 0;
		for (int i = 1; i < size; i++) {
			int minPath = Integer.MAX_VALUE;
			int minIndex = -1;
			for (int j = 0; j < size; j++) {
				if (!visit[j] && distances[j] < minPath) {
					minPath = distances[j];
					minIndex = j;
				}
			}
			if (minIndex == -1) {
				return sum;
			}
			visit[minIndex] = true;
			sum += minPath;
			for (int j = 0; j < size; j++) {
				if (!visit[j] && distances[j] > graph[minIndex][j]) {
					distances[j] = graph[minIndex][j];
				}
			}
		}
		return sum;
	}

	public static void main(String[] args) {
		System.out.println("hello world!");
	}

}

 Dijkstra算法（单元最远路径算法）

  • 要求没有权值为负的边

代码

package class06;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;

// no negative weight
public class Code06_Dijkstra {

	public static HashMap<Node, Integer> dijkstra1(Node head) {
		// 从head出发到所有点的最小距离
		// key : 从head出发到达key
		// value : 从head出发到达key的最小距离
		// 如果在表中，没有T的记录，含义是从head出发到T这个点的距离为正无穷
		HashMap<Node, Integer> distanceMap = new HashMap<>();
		distanceMap.put(head, 0);
		// 已经求过距离的节点，存在selectedNodes中，以后再也不碰
		HashSet<Node> selectedNodes = new HashSet<>();
		Node minNode = getMinDistanceAndUnselectedNode(distanceMap, selectedNodes);
		while (minNode != null) {
			int distance = distanceMap.get(minNode);
			for (Edge edge : minNode.edges) {
				Node toNode = edge.to;
				if (!distanceMap.containsKey(toNode)) {
					distanceMap.put(toNode, distance + edge.weight);
				} else {
					distanceMap.put(edge.to, Math.min(distanceMap.get(toNode), distance + edge.weight));
				}
			}
			selectedNodes.add(minNode);
			minNode = getMinDistanceAndUnselectedNode(distanceMap, selectedNodes);
		}
		return distanceMap;
	}

	public static Node getMinDistanceAndUnselectedNode(HashMap<Node, Integer> distanceMap, HashSet<Node> touchedNodes) {
		Node minNode = null;
		int minDistance = Integer.MAX_VALUE;
		for (Entry<Node, Integer> entry : distanceMap.entrySet()) {
			Node node = entry.getKey();
			int distance = entry.getValue();
			if (!touchedNodes.contains(node) && distance < minDistance) {
				minNode = node;
				minDistance = distance;
			}
		}
		return minNode;
	}

	public static class NodeRecord {
		public Node node;
		public int distance;

		public NodeRecord(Node node, int distance) {
			this.node = node;
			this.distance = distance;
		}
	}

	public static class NodeHeap {
		private Node[] nodes; // 实际的堆结构
		// key 某一个node， value 上面数组中的位置
		private HashMap<Node, Integer> heapIndexMap;
		// key 某一个节点， value 从源节点出发到该节点的目前最小距离
		private HashMap<Node, Integer> distanceMap;
		private int size; // 堆上有多少个点

		public NodeHeap(int size) {
			nodes = new Node[size];
			heapIndexMap = new HashMap<>();
			distanceMap = new HashMap<>();
			size = 0;
		}

		public boolean isEmpty() {
			return size == 0;
		}

		// 有一个点叫node，现在发现了一个从源节点出发到达node的距离为distance
		// 判断要不要更新，如果需要的话，就更新
		public void addOrUpdateOrIgnore(Node node, int distance) {
			if (inHeap(node)) {
				distanceMap.put(node, Math.min(distanceMap.get(node), distance));
				insertHeapify(node, heapIndexMap.get(node));
			}
			if (!isEntered(node)) {
				nodes[size] = node;
				heapIndexMap.put(node, size);
				distanceMap.put(node, distance);
				insertHeapify(node, size++);
			}
		}

		public NodeRecord pop() {
			NodeRecord nodeRecord = new NodeRecord(nodes[0], distanceMap.get(nodes[0]));
			swap(0, size - 1);
			heapIndexMap.put(nodes[size - 1], -1);
			distanceMap.remove(nodes[size - 1]);
			// free C++同学还要把原本堆顶节点析构，对java同学不必
			nodes[size - 1] = null;
			heapify(0, --size);
			return nodeRecord;
		}

		private void insertHeapify(Node node, int index) {
			while (distanceMap.get(nodes[index]) < distanceMap.get(nodes[(index - 1) / 2])) {
				swap(index, (index - 1) / 2);
				index = (index - 1) / 2;
			}
		}

		private void heapify(int index, int size) {
			int left = index * 2 + 1;
			while (left < size) {
				int smallest = left + 1 < size && distanceMap.get(nodes[left + 1]) < distanceMap.get(nodes[left])
						? left + 1
						: left;
				smallest = distanceMap.get(nodes[smallest]) < distanceMap.get(nodes[index]) ? smallest : index;
				if (smallest == index) {
					break;
				}
				swap(smallest, index);
				index = smallest;
				left = index * 2 + 1;
			}
		}

		private boolean isEntered(Node node) {
			return heapIndexMap.containsKey(node);
		}

		private boolean inHeap(Node node) {
			return isEntered(node) && heapIndexMap.get(node) != -1;
		}

		private void swap(int index1, int index2) {
			heapIndexMap.put(nodes[index1], index2);
			heapIndexMap.put(nodes[index2], index1);
			Node tmp = nodes[index1];
			nodes[index1] = nodes[index2];
			nodes[index2] = tmp;
		}
	}

	// 改进后的dijkstra算法
	// 从head出发，所有head能到达的节点，生成到达每个节点的最小路径记录并返回
	public static HashMap<Node, Integer> dijkstra2(Node head, int size) {
		NodeHeap nodeHeap = new NodeHeap(size);
		nodeHeap.addOrUpdateOrIgnore(head, 0);
		HashMap<Node, Integer> result = new HashMap<>();
		while (!nodeHeap.isEmpty()) {
			NodeRecord record = nodeHeap.pop();
			Node cur = record.node;
			int distance = record.distance;
			for (Edge edge : cur.edges) {
				nodeHeap.addOrUpdateOrIgnore(edge.to, edge.weight + distance);
			}
			result.put(cur, distance);
		}
		return result;
	}

}

 

MY CUP OF TEA
关注
专栏目录
算法入门习题100道
03-08
100道入门级算法题～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
图论算法的简单入门
不可以庸俗堕落的博客
05-18 521
1.图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G（V,E），其中G表示一个图，V是图G的顶点的集合，E 是图G中边的集合；
算法基础笔记_图
coding
11-29 278
一. 图的认识 1. 图的分类： 按照方向性： 无向图（Undirected Graph）:边是没有方向的 有向图(（Directed Graph）：边具有方向性，有向图的不对称性会催生出一些比较复杂的算法 按照权重性： 无权图（Unweighted Graph） 有权图（Weighted Graph） 2.图的连通性： 在一张图中，并不一定所有的节点都是连通的。 3.简单图 ...
图算法(1) - 基础知识
LeoGIS1987的博客
09-05 386
图 G=(V,E) V：顶点的非空有限集合E：边集合，V×V的子集，V中顶点对，边的有限集合。|E| = O(|V|^2) 定义 简单图 （Simple Graph） 任意两个顶点最多只有一条边，且每个点都没有连接到自身的边（圈）。 完全图 （Complete Graph） 若有n个顶点的无向图有n(n-1)/2条边，则此图为完全图。 连通图（Connected Gr
图算法入门1：基础表示方法和深度优先搜索实现
fangfanglovezhou的博客
05-25 389
图结构表示和深度优先访问算法实现
遗传算法入门篇_遗传算法
07-14
通过阅读"002____遗传算法入门篇"中的文件，你可以系统地学习遗传算法的基本概念、基本操作和具体实现，逐步掌握如何利用遗传算法解决实际问题。同时，不断实践和调试，加深理解，你将能够灵活运用遗传算法解决各种...
哈希算法>>入门篇
01-07
哈希算法把字符串转换成整数，这样时间复杂度从O(N)变成了O(1)。类似于二进制，用P进制将字符串装换成整数，为避免重复，一般认为P取131或者1331，使用unsigned long long 就可以，默认对结果模一个2^64，会有溢出的...
算法竞赛入门基础篇（个人整理）
最新发布
05-07
### 算法竞赛入门基础篇（个人整理） #### 一、常用函数及算法 **1. 进制转换** - **十进制转R进制（2)** ```cpp string DtoR(int n, int r){ string s = ""; int x; if(n == 0){ s = "0"; } while(n){ ...
算法入门经典全篇
12-21
ACM算法入门经典全篇，讲述所有的算法，入门简单易懂，有大量经典案例
pid算法入门
12-23
通过以上的分析，我们可以看出PID算法入门这篇文档旨在为读者提供一套从PID算法基础到在STM32F427微控制器上进行CAN总线电机PID回环控制的完整知识体系，对于初学者或者希望在嵌入式系统中应用PID控制的工程师来说，...
关于图算法 & 图分析的基础知识概览
jshazhang的专栏
02-20 1213
网址：https://learning.oreilly.com/library/view/graph-algorithms-/9781492060116/ 你肯定没有读...
【算法竞赛进阶指南】兔子与兔子
zhaohaibo的博客
04-18 487
Description 很久很久以前，森林里住着一群兔子。有一天，兔子们想要研究自己的 DNA 序列。我们首先选取一个好长好长的 DNA 序列（小兔子是外星生物，DNA 序列可能包含 26 个小写英文字母），然后我们每次选择两个区间，询问如果用两个区间里的 DNA 序列分别生产出来两只兔子，这两个兔子是否一模一样。注意两个兔子一模一样只可能是他们的 DNA 序列一模一样。 Input 第一行一个 ...
算法 小兔齐齐跑无向图（待解决）
longxpzhh的专栏
12-21 426
给定一个无向图，小兔齐齐一开始位于某个节点上(我们不知道他具体在哪个节点上)。我们知道每一秒小兔都必定会向他所在的节点的某一个邻居节点出发(如果存在邻居节点；假设小兔的移动速度很快，移动时间可以忽略)。在每一秒你可以做不超过2次的询问,每次可以询问某个节点是否有小兔！ 现在假设小兔不想被我们找到，同时小兔非常聪明，那么我们需要至少几秒才能必定找到小兔的位置？ Input: 输入数据第一行包含一
c语言 兔子数列螺线图,经典算法大全51例——2.斐波那契数列(兔子数列)
weixin_36282234的博客
05-23 1469
经典算法大全51例——2.斐波那契数列算法目录合集地址说明题目原理分析代码实现——Java相关题目其他变形：1.爬楼梯(来源：力扣LeetCode)2.兔子成熟期拉长官方题解分析代码——C语言拓展1.黄金矩形2.等角螺线3.设计算法目录合集地址算法目录合集说明该地址指向所有由本人自己所经历的算法习题(也有可能仅仅是一个入门的案例或者是经典案例)，仅仅为我做过而且比较有意思的，也许还会有一些我自己想...
神奇的兔子数列——算法学习笔记
m0_57158496的博客
10-23 2822
这是我参加“14天阅读挑战赛”第一周第二篇 点击查看“14天阅读挑战赛”详情，《趣学算法第二版》1.4 神奇的兔子数列。 跟着小玉老师学算法 神奇的“兔子数列” (递归、循环，哪个更好？)   假设第1个月有1对初生的兔子，第2个月进入成熟期，第3个月开始生育兔子，而1对成熟的兔子每月会生1对兔子，兔子永不死去……那么，由1对初生的兔子开始，12个月后会有多少对兔子呢？  兔子数列即斐波那契数列，它的发明者是意大利数学家莱奥纳尔多·斐波那契（Leonardo Fibonacci，1170—
基础算法（二）---数据结构之图
狮锅艺
04-30 598
数据结构---图
java基础算法优化解决兔子数量以及拓展
热门推荐
易庞宙的博客
04-25 1万+
package javaBlog; /* 古典问题：3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 分析：首先我们要明白题目的意思指的是每个月的兔子总对数；假设将兔子分为小中大三种，兔子从出生后三个月后每个月就会生出一对兔子， 那么我们假定第一个月的兔子为小兔子，第二个月为中兔子，第三个月之后就为大兔子，那么第一个月分别有1、0、...
斐波那契数列
观月执白
07-03 1146
斐波那契数列又译为黄金分割数列。最经典的问题就是兔子问题。 第一个月初有一对刚诞生的兔子第二个月之后（第三个月初）它们可以生育每月每对可生育的兔子会诞生下一对新兔子兔子永不死去 假设在n月有兔子总共a对，n+1月总共有b对。在n+2月必定总共有a+b对。 1，1，2，3，5，8，13，21，…… 开普勒发现数列前、后两项之比1/2 ,2/3 , 3/5 ,5
单源最短路径算法之Dijkstra
明朗晨光的专栏
08-22 546
Dijkstra算法讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值