算法设计-方格取数

已于 2023-08-25 11:52:42 修改
阅读量222 收藏 2
点赞数 1
分类专栏： 【3】算法设计 文章标签： 算法
于 2023-08-25 04:50:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ebatudou/article/details/132487185
版权

一、目的

  1. 正确应用动态规划求解方格取数问题。
  2. 对边界值测试结果。
  3. 正确分析算法时间复杂度。

二、实验内容与设计思想

1．设计思路

(1) 输入方格规模n，手动输入/自动生成n×n方格图
(2) 输出方格图
(3) 动态规划方格取数，输出最大取数结果

主要数据结构

结构名数据结构结构释义
maze二维数组储存方格图
dp思维数组dp[i][j][a][b]表示第一次取数到(i,j)，第二次取数到(a,b)时，已经取得的数字和。

主要代码结构

三、实验使用环境

软件：Visual Studio 2022/1/4

平台：win10

实验步骤和调试过程

4.1 生成方格图

参数
输入：无
输出：方格图的规模

流程图
代码
int input()
{
	cout << "请输入n作为迷宫的面积：";
	int n;
	cin >> n;

	int mode = 0;
	while (mode != 1 && mode != 2)
	{
		cout << "请选择迷宫模式：\n1、手动输入\n2、自动生成。\n";
		cin >> mode;
	}
	if (mode == 1)
	{
		int x, y, v;
		printf("请按照(x,y,数字)的方式输入。\n");
		while (cin >> x >> y >> v)
		{
			if (x == 0 && y == 0 && v == 0)
				break;
			maze[x][y] = v;
		}
	}
	else
	{
		srand((unsigned)time(NULL));
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				maze[i][j] = int(rand() % 100);
			}
		}
	}
	return n;
}
数据测试与结果：
迷宫大小迷宫模式数据结果
411 2 0 2 3 4 1 3 10 1 1 900 00 00 00 00 09 00 10 00 00 00 04 00 00 00 00
42/
02 72 07 81
31 15 28 21
27 56 30 31
69 24 87 33
81
2 3 13
2 6 6
3 5 7
4 4 14
5 2 21
5 6 4
6 3 15
7 2 14
0 0 0
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 13 00 00 06 00
00 00 00 00 00 07 00 00
00 00 00 00 14 00 00 00
00 00 21 00 00 00 04 00
00 00 00 15 00 00 00 00
00 00 14 00 00 00 00 00
82/
60 28 53 39 82 47 68 43
23 79 46 11 69 64 64 86
41 51 60 79 21 35 40 39
56 24 37 63 34 49 48 96
40 04 64 90 27 46 92 06
40 18 90 71 39 06 72 67
36 04 01 99 89 07 76 04
82 27 57 48 21 32 48 81
1212 913 2 106 3 47 4 4 14 5 2 21 5 6 4 6 3 15 112 14
00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 13 06 00
00 00 00 00 07 00 00 00 00 00 00 00
00 00 00 00 14 00 00 00 00 00 00 00
00 00 21 00 00 00 04 00 00 00 00 00
00 00 00 15 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00
00 00 14 00 00 00 00 00 00 00 00 00
122/
97 96 80 89 42 18 85 66 43 02 41 08
37 47 00 18 29 62 28 94 69 21 63 57
03 41 54 79 06 03 41 35 17 69 96 74
43 13 17 06 71 52 39 19 93 80 67 89
25 14 25 91 32 70 17 39 40 15 46 94
47 08 75 62 07 71 96 82 80 27 55 76
19 96 48 72 26 54 30 21 59 28 31 02
06 41 45 11 97 84 01 28 22 80 33 33
95 78 13 74 93 62 47 57 39 08 80 58
96 79 12 02 32 58 61 99 26 79 71 26
14 16 00 30 70 24 62 89 22 98 83 69
16 04 97 04 60 23 82 23 92 16 59 23

4.2 输出方格图

参数
输入：方格图的规模
输出：无

代码
void printMaze(int n)
{
	cout << "迷宫已经生成完毕\n";
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			printf("%2d ", maze[i][j]);
		}
		printf("\n");
	}
}

4.3 动态规划

参数
输入：/
输出：方格取数的解

流程图
代码
void DynamicProgramming(int n)
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			for (int k = 1; k <= n; k++)
			{
				for (int l = 1; l <= n; l++)
				{
					int maze1 = max(dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1]);
					int maze2 = max(dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]);
					dp[i][j][k][l] = max(maze1, maze2) + maze[i][j];
					//如果两个走的不相同，加上maze[k][l]的值
					if (i != k && j != l)
						dp[i][j][k][l] += maze[k][l];
				}
			}
		}
	}
	cout << "最终答案是：" << dp[n][n][n][n] << endl;//最终答案
}

一个四重循环枚举两条路分别走到的位置。
maze[i][j]表示(i,j)格上的值，dp[i][j][h][k]表示第一条路走到(i,j)，第二条路走到(h,k)时的最优解。
使用四重循环令i,j,h,k都从[1,n]对dp进行更新，最后的dp[n][n]即是答案。

测试数据与结果：
方格图取数结果
21 25 65 62 45 27 39 13
29 69 91 21 90 68 31 25
90 35 47 90 75 92 11 57
91 16 54 06 17 59 97 89
36 18 37 56 75 84 73 65
09 64 80 10 86 59 53 30
73 85 71 25 51 98 79 78
51 37 16 44 28 17 11 80
1601
06 72 81 16 80 50 27 08 46 60 13 66 77 88 03 63 30 39 78 39 66 80 80 97 52 33 21 90 90 83 86 88 95 86 67 89 89 16 56 92 14 30 39 49 19 52 85 20 19 82 94 03 29 50 58 71 17 09 01 19 00 96 93 45 18 24 67 36 52 57 00 23 06 62 08 74 42 21 80 14 26 76 67 56 90 77 78 52 58 74 10 48 42 72 74 38 58 65 65 37 85 19 22 65 97 23 46 64 33 54 08 13 78 34 23 59 70 24 74 37 09 09 94 28 93 39 31 52 89 85 88 28 13 89 24 77 52 09 56 30 57 84 21 172576
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
0
78 88 85 23 63 25 32 13 62 10 13 72 33 59 37 98
44 47 90 57 64 57 43 44 77 82 69 77 57 02 89 82
04 74 47 05 89 97 29 85 12 89 41 03 34 04 78 08
02 56 38 05 85 40 59 93 85 48 55 18 37 95 26 59
24 30 30 68 03 52 47 02 88 40 54 21 80 43 50 83
75 15 29 62 71 18 60 13 38 71 34 03 96 62 11 33
92 26 24 17 45 52 65 94 61 33 65 78 17 68 25 57
20 57 91 81 88 45 41 39 60 71 63 11 85 74 50 62
27 60 17 19 44 43 31 32 38 06 78 83 36 26 18 45
19 85 06 08 22 95 44 47 40 39 30 82 71 57 63 49
13 37 54 34 06 26 39 69 93 72 24 75 44 54 86 36
89 41 76 53 71 93 42 30 64 73 70 89 04 21 11 07
33 33 35 87 57 53 87 68 61 75 20 22 35 04 24 36
82 99 33 52 85 87 25 55 53 35 51 95 47 95 25 62
37 60 51 25 35 32 79 33 46 99 77 52 12 84 37 24
79 40 30 03 94 08 17 02 60 94 94 92 16 31 15 49
3641
21 25 65 62 45 27 39 13
29 69 91 21 90 68 31 25
90 35 47 90 75 92 11 57
91 16 54 06 17 59 97 89
36 18 37 56 75 84 73 65
09 64 80 10 86 59 53 30
73 85 71 25 51 98 79 78
51 37 16 44 28 17 11 80
06 72 81 16 80 50 27 08 46 60 13 66
77 88 03 63 30 39 78 39 66 80 80 97
52 33 21 90 90 83 86 88 95 86 67 89
89 16 56 92 14 30 39 49 19 52 85 20
19 82 94 03 29 50 58 71 17 09 01 19
00 96 93 45 18 24 67 36 52 57 00 23
06 62 08 74 42 21 80 14 26 76 67 56
90 77 78 52 58 74 10 48 42 72 74 38
58 65 65 37 85 19 22 65 97 23 46 64
33 54 08 13 78 34 23 59 70 24 74 37
09 09 94 28 93 39 31 52 89 85 88 28
13 89 24 77 52 09 56 30 57 84 21 17
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
78 88 85 23 63 25 32 13 62 10 13 72 33 59 37 98
44 47 90 57 64 57 43 44 77 82 69 77 57 02 89 82
04 74 47 05 89 97 29 85 12 89 41 03 34 04 78 08
02 56 38 05 85 40 59 93 85 48 55 18 37 95 26 59
24 30 30 68 03 52 47 02 88 40 54 21 80 43 50 83
75 15 29 62 71 18 60 13 38 71 34 03 96 62 11 33
92 26 24 17 45 52 65 94 61 33 65 78 17 68 25 57
20 57 91 81 88 45 41 39 60 71 63 11 85 74 50 62
27 60 17 19 44 43 31 32 38 06 78 83 36 26 18 45
19 85 06 08 22 95 44 47 40 39 30 82 71 57 63 49
13 37 54 34 06 26 39 69 93 72 24 75 44 54 86 36
89 41 76 53 71 93 42 30 64 73 70 89 04 21 11 07
33 33 35 87 57 53 87 68 61 75 20 22 35 04 24 36
82 99 33 52 85 87 25 55 53 35 51 95 47 95 25 62
37 60 51 25 35 32 79 33 46 99 77 52 12 84 37 24
79 40 30 03 94 08 17 02 60 94 94 92 16 31 15 49

4.4 时间复杂度

  • 生成方格图：O(n2)
    无好坏情况之分，方格图是n×n个数字组成的，需要生成n×n个随机数。

  • 动态规划：O(n4)
    最坏情况=最好情况：O(n4)
    因为有四重循环，每一重循环都是1~n。所以是n4。

200次方格取数时间图

4.5 空间复杂度

  • 生成方格图：O(n2)
    方格图是n×n个数字组成的，所以需要n×n的二维数组储存。

  • 动态规划：O(n4)
    最坏情况=最好情况：O(n4)
    因为有两次取数，相当于两个人同时走，所以需要n×n×n×n的四维数组来储存，所以是n4。

五、附录

方格取数

#include<bits/stdc++.h>
using namespace std;
int maze[15][15];
int dp[15][15][15][15];

int input()
{
	cout << "请输入n作为迷宫的面积：";
	int n;
	cin >> n;

	int mode = 0;
	while (mode != 1 && mode != 2)
	{
		cout << "请选择迷宫模式：\n1、手动输入\n2、自动生成。\n";
		cin >> mode;
	}
	if (mode == 1)
	{
		int x, y, v;
		printf("请按照(x,y,数字)的方式输入。\n");
		while (cin >> x >> y >> v)
		{
			if (x == 0 && y == 0 && v == 0)
				break;
			maze[x][y] = v;
		}
	}
	else
	{
		srand((unsigned)time(NULL));
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				maze[i][j] = int(rand() % 100);
			}
		}
	}
	return n;
}

void printMaze(int n)
{
	cout << "迷宫已经生成完毕\n";
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			printf("%2d ", maze[i][j]);
		}
		printf("\n");
	}
}

void DynamicProgramming(int n)
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			for (int k = 1; k <= n; k++)
			{
				for (int l = 1; l <= n; l++)
				{
					int maze1 = max(dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1]);
					int maze2 = max(dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]);
					dp[i][j][k][l] = max(maze1, maze2) + maze[i][j];
					//如果两个走的不相同，加上maze[k][l]的值
					if (i != k && j != l)
						dp[i][j][k][l] += maze[k][l];
				}
			}
		}
	}
	cout << "最终答案是：" << dp[n][n][n][n] << endl;//最终答案
}
int main()
{
	int n = input();
	printMaze(n);
	DynamicProgramming(n);
}

打印200方格取数时间

#include<bits/stdc++.h>
using namespace std;
int maze[100][100];
int dp[100][100][100][100];
int num[200];
void readfile_byword()
{
	string filename = "D:\\Desktop\\3.txt";
	ifstream OpenFile(filename);
	if (OpenFile.fail())
	{
		cout << "打开文件错误!" << endl;
		exit(0);
	}
	string str;
	stringstream ss;
	for (int i = 0; i < 200; i++)
	{
		OpenFile >> str;
		ss << str;
		ss >> num[i];
		ss.clear();
	}
	OpenFile.close();
	system("pause");
}

int input(int n)
{
	printf("%d ", n);
	int mode = 2;
	if (mode == 1)
	{
		int x, y, v;
		printf("请按照(x,y,数字)的方式输入。\n");
		while (cin >> x >> y >> v)
		{
			if (x == 0 && y == 0 && v == 0)
				break;
			maze[x][y] = v;
		}
	}
	else
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				maze[i][j] = int(rand() % 100);
			}
		}
	}
	return n;
}

void printMaze(int n)
{
	cout << "迷宫已经生成完毕\n";
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			printf("%02d ", maze[i][j]);
		}
		printf("\n");
	}
}

void DynamicProgramming(int n)
{
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			for (int k = 1; k <= n; k++)
			{
				for (int l = 1; l <= n; l++)
				{
					int maze1 = max(dp[i - 1][j][k - 1][l], dp[i - 1][j][k][l - 1]);
					int maze2 = max(dp[i][j - 1][k - 1][l], dp[i][j - 1][k][l - 1]);
					dp[i][j][k][l] = max(maze1, maze2) + maze[i][j];
					//如果两个走的不相同，加上maze[k][l]的值
					if (i != k && j != l)
						dp[i][j][k][l] += maze[k][l];
				}
			}
		}
	}
	//cout << "最终答案是：" << dp[n][n][n][n] << endl;//最终答案
}
int main()
{
	readfile_byword();
	for (int i = 0; i <200; i++)
	{
		clock_t start, finish;
		start = clock();

		int n = input(num[i]);
		//printMaze(n);
		DynamicProgramming(n);

		finish = clock();
		double time = (double)(finish - start) / CLOCKS_PER_SEC; //单位换算成秒

		cout << time << endl;
	}
}

画散点图

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/9/23 17:26
# @Author  : Fw_022
import numpy as np
import matplotlib.pyplot as plt
import random


def draw(x, y):
    area = 200

    colors = [random.random() for i in range(len(x))]

    plt.figure(figsize=(20, 10))
    plt.style.use('seaborn-whitegrid')

    plt.scatter(x, y, s=area, c=colors, alpha=0.4, label='Duration Time', cmap='viridis')
    # 颜色条：viridis，RdBu
    plt.legend(fontsize=30)

    plt.xlabel("n", fontsize=30)
    plt.ylabel('Time', fontsize=30)


    plt.xticks(fontsize=30, color='#000000')
    plt.yticks(fontsize=30, color='#000000')
    # plt.xticks([])  # 不显示x轴刻度值
    # plt.tick_params(labelsize=20) 刻度值字体大小

    plt.tick_params(pad=5)  # 刻度距离坐标轴的距离调整

    plt.colorbar()  # 显示颜色对比条
    plt.savefig(r"D:\Desktop\a.png", bbox_inches='tight', dpi=1000)
    plt.show()


if __name__ == "__main__":
    path = r"D:\Desktop\time.txt"
    data = open(path).readlines()
    x, y = [], []
    for i in data:
        a, b = i.split(' ')
        x.append(int(a))
        y.append(float(b))
    draw(x, y)
nencbskk
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CSP-J 2020 方格取数 [2种超详细解法]
ThOugHT_XD的博客
10-22 1035
CSP-J 2020 方格取数 记忆化搜索和动态规划2种超详细解法~
方格取数算法详解
qq_47664976的博客
05-28 5014
今天做到了一个比较难的算法，看了好久都没有思路。。记录一下。 题目如下： 设有 N×N 的方格图 (N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 0。如下图所示（见样例）: A 0 0 0 0 0 0 0 0 0 0 13 0 0 6 0 0 0 0 0 0 7 0 0 0 0 0 0 14 0 0 0 0 0 21 0 0 0 4 0 0 0 0 15 0 0 0 0 0 0 14 0 0
【算法每日一练]-动态规划 篇10 方格取数 （两种解法）
最新发布
m0_69478376的博客
10-22 584
高能预警：讲了这么久动态规划了，该上点有难度的题吧
方格取数
CSDNYOYOYO的博客
07-22 446
方格取数 题目描述 设有N×N的方格(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字0。如下图所示（见样例）: A-------------------- 0 0 0 0 0 0 0 0 0 0 13 0 0 6 0 0 0 0 0 0 7 0 0 0...
【算法专题】方格取数问题
weixin_42638946的博客
11-16 2817
方格取数问题 1. 概述 给定一个 n×mn \times mn×m 的矩阵，每个位置有个非负数，我们可以从左上角走到右下角，每经过一个位置我们可以把格子上对应的数字取走，取走之后数字变为0，问我们可以获得的数字之和最大是多少？ 此问题存在递进的三种类型： （1）可以从左上角走到右下角1次，对应题目：AcWing 1015. 摘花生； （2）可以从左上角走到右下角2次，对应题目：AcWing 1027. 方格取数、Leetcode 0741 摘樱桃； （3）可以从左上角走到右下角k次，对
追梦算法----方格取数
今天会营业的博客
03-24 868
说明 在 n 行、m 列的方格矩阵中，每个方格都包含一个数字。小明可以从任意方格出发开始移动。每次移动可以移到与当前方格有一条边相邻的方格(即向上、下、左或右方向移动 1 格，且不能移出边界)。除此之外，你移动到的方格中的数字必须比当前方格中的数字更大。 请你帮助小明编程规划移动路径，使路径上经过的所有数字之和最大。 本题方格中的数据根据输入的初始数字 s 按照如下算法生成: for i = 1, 2, ... n for j = 1, 2, ... m s ← (s × 345) mod 1...
算法训练 方格取数
GU
01-30 403
算法训练 方格取数 问题描述 　　设有NN的方格图(N<=10),我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。 　　某人从图的左上角的A 点(1,1)出发，可以向下行走，也可以向右走，直到到达右下角的B点(N,N)。 在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。 　　此人从A点到B 点共走两次，试找出2条这样的路径，使得取得的数之和为最大。 输入格式 ...
方格取数.zip
12-04
【标题】"方格取数.zip"对应的是一组与编程竞赛相关的资源，特别是与"蓝桥杯"这一知名编程赛事紧密相连。蓝桥杯比赛主要考察参赛者的程序设计能力和算法运用技巧，是针对计算机科学和技术专业学生的重要竞赛之一。在...
分治算法实验 - 棋盘覆盖问题.docx
03-09
分治算法是一种重要的计算机科学中的算法设计思想，它将复杂的问题分解为多个相似的子问题，然后递归地解决这些子问题，最后将子问题的解组合起来得到原问题的解。在“棋盘覆盖问题”中，我们利用分治策略来解决如何...
方格取数系列算法分析
01-21
里面有几个例题和解答，是一些比较老但是经典的题目，仅供参考
棋盘覆盖---算法分析与设计 实验作业
03-14
棋盘覆盖问题是一个经典的计算机科学问题，涉及到算法分析与设计，尤其在递归算法的应用上具有重要的学习价值。这个问题的基本设定是在一个8x8的国际象棋棋盘上，通过放置一些棋子使得每个格子恰好被一个棋子覆盖，...
ACM 程序设计：图模型与搜索算法-p6.pdf
06-18
在ACM程序设计中，图模型与搜索算法是重要的问题解决工具，特别是在解决复杂的路径寻找问题上，如旅行骑士问题(Traveling Knight Problem, TKP)。TKP要求在国际象棋棋盘上找到一条最短的封闭巡回路线，使得骑士能...
ACM中的位运算 方格取数 公共子序列
03-13
11. **方格取数**： - 这类问题通常涉及寻找最大和的同时避免相邻单元格的选取，可能需要利用位运算进行状态编码和转换。 12. **找数问题**： - **找出现奇数次的数**：可以使用异或运算在O(n)时间复杂度内找到...
洛谷P1004 方格取数
lzx_xzl_______的博客
12-09 587
题目描述 设有N \times NN×N的方格图(N \le 9)(N≤9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字00。如下图所示（见样例）: A 0 0 0 0 0 0 0 0 0 0 13 0 0 6 0 0 0 0 0 0 7 0 0 0 0 0 0 14 0 0 0 0 0 21 0 0 0 4 0 0 0 0 15 0 0 0 0 0 0 14 0 0 0 0 0...
[CSP-J2020] 方格取数 题目分析
qq_66909106的博客
04-10 1924
欢迎来到CSP-J题目分析专题，这是本蒻蒻的第一篇博客，若写的有不好的地方还望指出
方格取数（动态规划经典题）
yanyanwenmeng的博客
08-10 6298
1. 设状态：f[i][j][h][k];//表示两条路同时走，第一条路径走到(i,j)时，第二条走到（h,k）时的最大数字和； 2. 初始状态：f[0][0][0][0]=0;     最终状态：f[n][n][n][n]; 3. 状态转移方程：当i==h&&j==k时，f[i][j][h][k]=max{f[i-1][j][h-1][k],f[i][j-1][h][k-1],f[i-1]
【CSP2020PJ T4】方格取数 题解（记忆化搜索）
Dream_aside的博客
11-08 2083
我对这次考试的简单总结~
九章算法面试题26 方格取数
九章算法的博客
05-12 1164
初阶：有一个n*m的矩阵，需要从坐上角(1,1)走到右下角(n,m)，只能向右和向下走。矩阵中的每个方格有一个非负整数，问从左上角到右下角的所有路径中，数字之和最大的路径是哪一条。 进阶：如果可以从左上角往下走k次，每个方格中的数被取走之后第二次经过则不再累加数值。请问走k次最多能取到的数值之和是多少。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值