Dijkstra算法大师:轻松应对LeetCode难题

已于 2024-07-26 22:32:18 修改
阅读量816 收藏 1
点赞数
分类专栏： # 算法 文章标签： 算法
于 2023-06-09 00:48:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzhcoder/article/details/130624162
版权

目录

算法背景

算法描述

算法模版

力扣刷题

参考文章

算法背景

地图中的导航功能就是基于迪杰斯特拉算法(Dijkstra)实现的,力扣周赛中经常出现基于这个算法的变种题

算法描述

算法目标：给出一个起始点，我们可以求出到达其他所有点的最短路径

第一步：     初始化：起始点到各个顶点的权重都是INF，且各个顶点都没有被访问过，每个顶点都没有父节点。

第二步：     循环执行下面的步骤，直到所有顶点都被访问：        

1、把当前的节点u设置为被访问状态；（刚开始时，当前顶点就是起始点，后边都是获取代价最小的顶点作为下一步要走的顶点，即优先队列的第一个）     

2、考察当前可行走的所有边及其对应的顶点tempv， 更新从起始点经过当前顶点到可到达的所有顶点的代价，然后放入优先队列（从小到大排序）         

a, 如果被考察的边对应的顶点被访问过，则跳过，继续考察下一条边及其对应的顶点，         

b, 如果从其起始到对应顶点tempv的权重比从当前点u到tempv的权重大，则更新权重和父节点，并加入到优先队列中

假设有一个加权图如下所示：

边的权重标在边上。假设起点是 A。

初始化

  • 权重：A=0, B=INF, C=INF, D=INF, E=INF
  • 父节点：A=null, B=null, C=null, D=null, E=null
  • 优先队列：[(A, 0)]

第一步

  • 选择权重最小的顶点 A，标记为已访问，从优先队列中弹出A。
  • 更新 A 的邻接顶点：
    • 对 B：A->B 权重是 2，更新 B 的权重为 2，父节点为 A，加入优先队列。
    • 对 D：A->D 权重是 1，更新 D 的权重为 1，父节点为 A，加入优先队列。
  • 权重：A=0, B=2, C=INF, D=1, E=INF
  • 父节点：A=null, B=A, C=null, D=A, E=null
  • 优先队列：[(D, 1), (B, 2)]

第二步

  • 选择权重最小的顶点 D，标记为已访问，从优先队列中弹出D。
  • 更新 D 的邻接顶点：
    • 对 A：D->A 权重是 1，A 已被访问，跳过。
    • 对 B：D->B 权重是 1 + 1 = 2，不更新，因为 B 的权重已是 2。
    • 对 E：D->E 权重是 1 + 3 = 4，更新 E 的权重为 4，父节点为 D，加入优先队列。
  • 权重：A=0, B=2, C=INF, D=1, E=4
  • 父节点：A=null, B=A, C=null, D=A, E=D
  • 优先队列：[(B, 2), (E, 4)]

第三步

  • 选择权重最小的顶点 B，标记为已访问，从优先队列中弹出B。
  • 更新 B 的邻接顶点：
    • 对 A：B->A 权重是 2，A 已被访问，跳过。
    • 对 D：B->D 权重是 2 + 1 = 3，不更新，因为 D 的权重已是 1。
    • 对 C：B->C 权重是 2 + 4 = 6，更新 C 的权重为 6，父节点为 B，加入优先队列。
    • 对 E：B->E 权重是 2 + 5 = 7，不更新，因为 E 的权重已是 4。
  • 权重：A=0, B=2, C=6, D=1, E=4
  • 父节点：A=null, B=A, C=B, D=A, E=D
  • 优先队列：[(E, 4), (C, 6)]

第四步

  • 选择权重最小的顶点 E，标记为已访问, 从优先队列中弹出E。
  • 更新 E 的邻接顶点：
    • 对 D：E->D 权重是 4 + 3 = 7，不更新，因为 D 的权重已是 1。
    • 对 B：E->B 权重是 4 + 5 = 9，不更新，因为 B 的权重已是 2。
    • 对 C：E->C 权重是 4 + 5 = 9，不更新，因为 C 的权重已是 6。
  • 权重：A=0, B=2, C=6, D=1, E=4
  • 父节点：A=null, B=A, C=B, D=A, E=D
  • 优先队列：[(C, 6)]

第五步

  • 选择权重最小的顶点 C，标记为已访问，从优先队列中弹出C。
  • C 没有需要更新的邻接顶点。
  • 权重：A=0, B=2, C=6, D=1, E=4
  • 父节点：A=null, B=A, C=B, D=A, E=D
  • 优先队列：[]

所有顶点都已被访问，算法结束。

最终，从起点 A 到各顶点的最短路径权重和路径如下：

  • 到 B：权重 2，路径 A -> B
  • 到 C：权重 6，路径 A -> B -> C
  • 到 D：权重 1，路径 A -> D
  • 到 E：权重 4，路径 A -> D -> E

通过这个例子，可以看到 Dijkstra 算法是如何一步步找到从起点到各个顶点的最短路径的。

算法模版

public class Dijkstra {
	
	static class Node {
		int x; // 节点编号
		int lenth;// 用于记录起点到该节点的最短路径的临时变量

		public Node(int x, int lenth) {
			this.x = x;
			this.lenth = lenth;
		}
	}

	public static void main(String[] args) {

		int[][] map = new int[6][6];// 记录权值，顺便记录链接情况，可以考虑附加邻接表
		initmap(map);// 初始化
		boolean visited[] = new boolean[6];// 判断是否已经确定
		int len[] = new int[6];// 用于记录起点到对应节点的最终的最短路径长度
		for (int i = 0; i < 6; i++) {
			len[i] = Integer.MAX_VALUE;
		}
 
		
		PriorityQueue<Node> q1 = new PriorityQueue<>((a, b) -> {
			return a.lenth - b.lenth;
		});
		
		len[0] = 0;// 从0这个点开始
		q1.add(new Node(0, 0));


		while (!q1.isEmpty()) {
			Node t1 = q1.poll();
			int index = t1.x;// 节点编号
			int length = t1.lenth;// 节点当前点距离
			visited[index] = true;// 抛出的点确定
			for (int i = 0; i < map[index].length; i++) {
				if (map[index][i] > 0 && !visited[i]) {
					Node node = new Node(i, length + map[index][i]);
					if (len[i] > node.lenth)// 需要更新节点的时候更新节点并加入队列
					{
						len[i] = node.lenth;
						q1.add(node);
					}
				}
			}
		}
		for (int i = 0; i < 6; i++) {
			System.out.println(len[i]);
		}
	}

	static Comparator<Node> com = new Comparator<Node>() {

		public int compare(Node o1, Node o2) {
			return o1.lenth - o2.lenth;
		}
	};

	private static void initmap(int[][] map) {
		map[0][1] = 2;
		map[0][2] = 3;
		map[0][3] = 6;
		map[1][0] = 2;
		map[1][4] = 4;
		map[1][5] = 6;
		map[2][0] = 3;
		map[2][3] = 2;
		map[3][0] = 6;
		map[3][2] = 2;
		map[3][4] = 1;
		map[3][5] = 3;
		map[4][1] = 4;
		map[4][3] = 1;
		map[5][1] = 6;
		map[5][3] = 3;
	}
}

力扣刷题

public class LeetCode1976到达目的地的方案数 {

	public int countPaths(int n, int[][] roads) {

		boolean visited[] = new boolean[n];// 判断是否已经确定
		int len[] = new int[n]; // 记录从起点到各节点的最短路径长度
		int[] cnt = new int[n]; // 记录从起点到各节点的最短路径数量

		for (int i = 0; i < n; i++) {
			len[i] = Integer.MAX_VALUE;
		}

		int[][] map = initmap(roads, n);

		PriorityQueue<Node> q1 = new PriorityQueue<>((a, b) -> {
			return a.lenth - b.lenth;
		});

		len[0] = 0;// 从0这个点开始
		q1.add(new Node(0, 0));
		cnt[0] = 1; // start -> start的最短路径只有一条

		while (!q1.isEmpty()) {
			Node t1 = q1.poll();
			int index = t1.x;// 节点编号
			int length = t1.lenth;// 节点当前点距离
			visited[index] = true;// 抛出的点确定
			for (int i = 0; i < map[index].length; i++) {
				if (map[index][i] > 0 && !visited[i]) {
					Node node = new Node(i, length + map[index][i]);
					if (len[i] > node.lenth)// 需要更新节点的时候更新节点并加入队列
					{
						cnt[i] = cnt[index];
						len[i] = node.lenth;
						q1.add(node);
					} else if (len[i] == node.lenth) {
						// 如果当前最短路径长度相等，则累加路径数量
						// 如果发现有另一个路径，它的长度和当前的最短路径长度相等，那么这条路径也是最短路径之一。
						// 因此，我们需要将这条路径的数量加到当前节点的最短路径数量 cnt[i] 中
						cnt[i] = (cnt[i] + cnt[index]) % 1000000007;
					}
				}
			}
		}
		return cnt[n - 1];

	}

	private int[][] initmap(int[][] roads, int n) {

		int[][] map = new int[n][n];

		for (int i = 0; i < roads.length; i++) {
			map[roads[i][0]][roads[i][1]] = roads[i][2];
			map[roads[i][1]][roads[i][0]] = roads[i][2];
		}

		return map;

	}

	class Node {
		int x; // 节点编号
		int lenth;// 用于记录起点到该节点的最短路径的临时变量

		public Node(int x, int lenth) {
			this.x = x;
			this.lenth = lenth;
		}
	}

	public static void main(String[] args) {

		int[][] roads = { { 1, 0, 10 } };
		new LeetCode1976到达目的地的方案数().countPaths(2, roads);
	}
}
public class LeetCode2642设计可以求最短路径的图类 {

	class Graph {

		int[][] map = null;
		boolean visited[] = null;
		int len[] = null;

		public Graph(int n, int[][] edges) {

			map = new int[n][n];
			visited = new boolean[n];// 判断是否已经确定
			len = new int[n]; // 记录从起点到各节点的最短路径长度

			for (int i = 0; i < edges.length; i++) {
				map[edges[i][0]][edges[i][1]] = edges[i][2];
			}
			for (int i = 0; i < n; i++) {
				len[i] = Integer.MAX_VALUE;
			}
		}

		public void addEdge(int[] edge) {

			dijkstra(edge[0]);
			map[edge[0]][edge[1]] = edge[2];

		}

		public int shortestPath(int node1, int node2) {
			// 先检查 node1 到 node2 之间是否有直接的边
	        if (map[node1][node2] > 0) {
	        	return map[node1][node2]; 
	        }
 
			return len[node2];

		}
		
	    public void dijkstra(int source) {
	    	
	        Arrays.fill(visited, false);
	        Arrays.fill(len, Integer.MAX_VALUE);
	    	
			PriorityQueue<Node> q1 = new PriorityQueue<>((a, b) -> {
				return a.lenth - b.lenth;
			});

			len[source] = -1;// 从node1这个点开始
			q1.add(new Node(source, 0));

			while (!q1.isEmpty()) {

				Node t1 = q1.poll();
				int index = t1.x;// 节点编号
				int length = t1.lenth;// 节点当前点距离
				visited[index] = true;// 抛出的点确定
				for (int i = 0; i < map[index].length; i++) {
					if (map[index][i] > 0 && !visited[i]) {
						Node node = new Node(i, length + map[index][i]);
						if (len[i] > node.lenth)// 需要更新节点的时候更新节点并加入队列
						{
							len[i] = node.lenth;
							q1.add(node);
						}
					}
				}
			}
	    	
	    }

		class Node {
			int x; // 节点编号
			int lenth;// 用于记录起点到该节点的最短路径的临时变量

			public Node(int x, int lenth) {
				this.x = x;
				this.lenth = lenth;
			}
		}
	}

}
public class LeetCode2662前往目标的最小代价{

	public int minimumCost(int[] start, int[] target, int[][] specialRoads) {
		// 创建一个优先级队列，用于存储每个位置和到达该位置的代价，按代价从小到大排序
		PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> {
			return a[2] - b[2];
		});
		// 初始化结果为从起点到终点的直线距离
		int res = dist(start, target);
		// 将起点加入优先级队列
		pq.offer(new int[] { start[0], start[1], 0 });
		// 创建一个 HashMap 用于存储已访问过的位置和到达该位置的最小代价
		Map<String, Integer> vis = new HashMap<>();
		vis.put(getKey(start), 0);

		while (!pq.isEmpty()) {
			// 每次从队列中取出代价最小的位置
			int[] p = pq.poll();
			// 遍历所有特殊路径
			for (int[] sp : specialRoads) {
				int[] p1 = new int[] { sp[0], sp[1] };
				int[] p2 = new int[] { sp[2], sp[3] };
				// 计算从当前位置到特殊路径起点的代价，再加上特殊路径的代价
				int d = p[2] + dist(p, p1) + sp[4];
				String key = getKey(p2);
				// 获取之前到达特殊路径终点的最小代价，如果没有则为从起点到终点的直线距离
				int x = vis.getOrDefault(key, dist(start, p2));
				// 如果新的代价小于之前的最小代价，更新最小代价
				if (d < x) {
					vis.put(key, d);
					pq.offer(new int[] { p2[0], p2[1], d });
					// 更新结果，当前位置到特殊路径终点的代价加上从特殊路径终点到目标位置的代价
					res = Math.min(res, d + dist(p2, target));
				}
			}
		}
		return res;
	}

	// 计算两点之间的代价
	private int dist(int[] p1, int[] p2) {
		return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
	}

	// 将位置转换为字符串，用于在 HashMap 中作为键
	private String getKey(int[] p) {
		return p[0] + "_" + p[1];
	}
}

参考文章

【看完必懂】Dijkstra算法（附案例详解） - 知乎

https://www.cnblogs.com/bigsai/p/11537975.html

数据与算法架构提升之路
关注
专栏目录
[Leetcode] 每日两题 743 1631 -day96 dijkstra算法专题
weixin_43146899的博客
02-27 2050
重温 dijkstra算法 Dijkstra算法 （迪杰斯特拉算法 ，卜老师纠正过是叫戴斯特比较标准）是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 类似于广度优先搜索，它的主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 基本步骤 ： 指定起点s； 定义一个数组dis表示s到每个点的距离，集合Q记录当前求出的最短路径点（距离起点）以及距离，一开始Q中只有s一个点且距离为0，而visited数组用于标记节点是否已经求出距离起点的最短距离； 找出Q的 当前求出的路径的最小值对
leetcode-Dijkstra算法
MaYingColdPlay的博客
03-13 1886
单源最短路径-Dijkstra算法_哔哩哔哩_bilibili
*算法训练（leetcode）第五十一天 | Dijkstra（堆优化版）、Bellman_ford 算法
最新发布
weixin_43872997的博客
08-11 449
LeetCode刷题日记
浅谈图论——迪杰斯特拉算法（leetcode例题，C++演示）
qq_73075805的博客
02-04 1346
我们不要被迪杰斯特拉算法的名字吓到了，其实迪杰斯特拉的算法并不复杂。很多时候，传统的并不复杂的算法往往在解决现实问题的时候有这良好的效果。首先我们要搞清楚迪杰斯特拉算法解决的单源最短路径的问题。单源最短路径问题是找到从图中的一个固定顶点（称为源点）到其他所有顶点的最短路径。将源点到其他顶点的距离初始化为无穷大，源点到自身的距离初始化为0。同时，维护一个集合S，其中包含已确定最短路径的顶点，初始时S为空。从未确定最短路径的顶点中选择一个到源点距离最小的顶点，并将其标记为已确定最短路径。将该顶点加入集合S中。
LeetCode刷题--- Dijkstra 求最短路径
qq_43325216的博客
03-27 451
比如我们求从0 到其他点的最短距离，定义一个数组，第0行分别是每个节点，第一行是0到其他节点的距离，初始化为正无穷大，第三行是表示是否已经是最小距离。因为从1到2的距离是2+1，小于当前的5，因此可以刷新下表，此时得到了0到2最短距离3。思路就是上面的思路，不断的获取距离，然后和当前的距离比较，如果比他小，就更新进去。首先遍历0能够直接到达的顶点，修改如下，此时0到1的距离是最短的，可以标记为T。个人感觉，邻接矩阵适合无向图，邻接表适合有向图。然后看从2出发，能够直接到达的距离。
LeetCode_Dijkstra算法_中等_1631. 最小体力消耗路径
代码星辰的博客
05-05 544
目录1.题目2.思路3.代码实现（Java） 1.题目 你准备参加一场远足活动。给你一个二维 rows * columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费体力最小的一条路径。 一条路径耗费的体力值是路径上相邻格子之间高度差绝对值的最大
leetcode答案-leet-code:我在https://leetcode.com/problemset/algorithms/上对Lee
06-30
1. **数据结构**：LeetCode中的许多问题都涉及到常见数据结构的使用，如数组、链表、栈、队列、哈希表、二叉树、堆和图。理解和熟练运用这些数据结构是解决问题的关键。 - **数组**：线性数据结构，支持随机访问，...
dijkstra算法代码matlab-Dijkstra-Algorithm:Dijkstra算法
06-17
dijkstra算法代码matlab 使用 MATLAB 的 Dijkstra 算法 该项目是马里兰大学机器人课程 ENPM-661 的一部分。 在这里，我已经使用 MATLAB 为点和刚性机器人编写了 Dijkstra 算法的代码，并将其用于自定义地图。
Dijkstra_Algorithm:dijkstra算法的实现，
03-04
**Dijkstra算法**是图论中的一个著名算法，由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出，主要用于寻找有向图中两个节点间的最短路径。这个算法尤其适用于解决单源最短路径问题，即从图中的一个特定源节点出发，...
Algorithms:AlgoExpert和LeetCode的算法
03-19
2. **字符串处理**：LeetCode中有很多关于字符串操作的题目，比如模式匹配、字符串反转、编辑距离等，这有助于提升你在处理文本数据时的能力。 3. **递归与回溯**：这两种技术在解决复杂问题时经常被用到，例如八...
什么是dijkstra算法，Java和Python如何实现dijkstra算法
06-27
dijkstra算法：什么是dijkstra算法，Java和Python如何实现dijkstra算法 dijkstra算法：什么是dijkstra算法，Java和Python如何实现dijkstra算法 dijkstra算法：什么是dijkstra算法，Java和Python如何实现dijkstra算法...
LeetCode_dijkstra 算法_困难_882.细分图中的可到达节点
代码星辰的博客
11-26 628
dijkstra 算法
Leetcode1514.概率最大的路径(dijkstra算法的练习)
qq_41953962的博客
07-13 534
Leetcode1514 概率最大的路径dijkstra算法回顾题目描述邻接表图 + dijkstra算法 dijkstra算法回顾 可以参考我之前基于cs61b的博客总结: CS61BSpring2019笔记1: 图的最短路径以及最小生成树. 证明的话个人认为如果能够想明白无论是最大概率还是最短路径，每次被释放的节点一定是从start结点到该节点的最优路径的结果。 题目描述 Leetcode1514：链接. 邻接表图 + dijkstra算法 //Java class Solution { p
算法学习（10）：LeetCode刷题之Dijkstra最短路径算法
欢迎来到Jimmy的博客
01-06 8827
前言： 迪杰斯特拉(Dijkstra)最短路径算法是求有向加权图中某个节点到其他节点的最短路径。“图”这种数据结构的具体实现就是“邻接矩阵”或者“邻接表”。 比如上面这个图，用邻接表或者邻接矩阵的存储方式如下，图中的节点一般抽象成一个数字（即下标或索引）： 首先，我们来确定一下Dijkstra算法的签名： // 输入一个起点和一个图（邻接矩阵表示），返回start到其他节点的最短路径，节点的值作为返回数组的下标 int[] dijkstra(int start, int[][] graph) 最短路径
Leetcode 743. 网络延迟时间 Dijkstra算法
wwxy1995的博客
12-23 345
题目等价于找到从K点出发，所有最短路径的最大值，这个时间段，所有点一定都能收到信号。所以是标准的Dijkstra算法 O(N^2)的Dijkstra思路如下： 维护一个dist数组用来存储从K点到其他所有点的最短距离，还要维护一个visited数组记录点是否已经作为中间过程用过。 最外层循环是迭代次数，对于N个点，只需要迭代N-1次，因为其实最后一个点不用再迭代了。 首先，先要找到dist数组中距离最近的一个点，这个点没有作为中间点使用过，然后去跟新其他dist数组的值 完成之后，记得到了di..
LeetCode 126. 单词接龙 II （最短路 dijkstra算法）
sgh666666的博客
08-18 660
给定两个单词（beginWord 和 endWord）和一个字典 wordList，找出所有从 beginWord 到 endWord 的最短转换序列。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回一个空列表。 所有单词具有相同的长度。 所有单词只由小写字母组成。 字典中不存在重复的单词。 你可以假设 begi...
leetcode_743. 网络延迟时间--迪杰斯特拉
Adorablenewbaby的博客
08-02 220
leetcode_743 题目描述 题目大意 思路描述 代码 写在最后 题目描述 有 n 个网络节点，标记为 1 到 n。 给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。 现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。 示例 1： 输入：times = [[2,1,1],[2,3,1],
LeetCode_dijkstra算法_中等_1514. 概率最大的路径
代码星辰的博客
05-04 373
目录1.题目2.思路3.代码实现（Java） 1.题目 给你一个由 n 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 edges[i] = [a, b] 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 succProb[i] 。 指定两个节点分别作为起点 start 和终点 end ，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。 如果不存在从 start 到 end 的路径，请返回 0 。只要答案与标准答案的误差不超过 1e-5 ，就会被视作正确
leetcode(7):图论Dijkstra||
CoomCon的博客
07-29 600
这里写自定义目录标题1.迪杰斯特拉Dijkstra 图论问题一般分为： 单源最短路径问题：从某固定源点出发，求其到所有其他顶点的最短路径 最短路径问题：从某固定源点出发，求其到所有其他顶点的最短路径 （有向）无权图 （有向）有权图 多源最短路径问题：求任意两顶点间的最短路径 1.迪杰斯特拉Dijkstra 有权图的单源最短路径算法——dijkstra； 不能处理带负边权的情况，用邻接矩阵或邻接表存图 Dijkstra进行进一步的堆优化以后时间复杂度成为O(nlogn)， Floyd的O(n^3)
Dijkstra算法详解：寻找最短路径
"本文主要介绍了Dijkstra算法，这是一种用于寻找有向图中两点间最短路径的算法。在所有边的权重非负的情况下，Dijkstra算法是最有效的解决方案之一。" Dijkstra算法是一种解决最短路径问题的经典算法，由荷兰计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

数据与算法架构提升之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值