第二周算法总结（分治问题 最大子数组）

最新推荐文章于 2020-02-22 16:11:38 发布
最新推荐文章于 2020-02-22 16:11:38 发布
阅读量200 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43702629/article/details/102634991
版权

1.最大子数组

问题不在描述，按照算法导论所提供的分治思想 对于

一个数组，要想存在最大子数组，必须存在负数，这样问题才存在意义。

利用分治思想，将一个数组分成两部分，最大子数组肯定存在于这两个子数组

之一或者是一个跨过中点的数组。

代码如下

#include<iostream>
#include<vector>

using namespace std;
int left_low = 0, left_high = 0, left_sum = 0;
int right_low = 0, right_high = 0, right_sum = 0;
int mid_low = 0, mid_high = 0, mid_sum = 0;
vector<int> findmid(vector<int> a, int l,int mid, int r)//算出跨越中点的最大子数组
{
	int left_sum = -200;
	int left_low = 0;
	int sum =0;
	int right_sum = -200;
	int right_high = 0;
	for (int i = mid; i >= l; i--)
	{
		sum = a[i]+sum;
		if (sum > left_sum)
		{
			left_low = i;
			left_sum = sum;
		}
	}
	sum = 0;
	for (int i = mid+1; i <= r; i++)
	{
		sum = a[i]+sum;
		if (sum >right_sum)
		{
			right_high = i;
			right_sum = sum;
		}
	}
	return{ left_low, right_high, left_sum + right_sum };
}
vector<int> find(vector<int> a, int r, int l)
{
	if (l == r)
	{
		return{ r, l, a[r] };
	}
	else
	{
		int mid = (l + r) / 2;
		vector<int>a0 = find(a, r, mid);
		left_low = a0[0];
		left_high = a0[1];
		left_sum = a0[2];
		vector<int>b = find(a, mid + 1, l);
		right_low = b[0];
		right_high = b[1];
		right_sum = b[2];
		vector<int> c = findmid(a, r, mid, l);
		mid_low = c[0];
		mid_high = c[1];
		mid_sum = c[2];
		if (left_sum >= right_sum&&left_sum>=mid_sum)
		{
			return{ left_low, left_high, left_sum };
		}
		else
		{
			if (right_sum>=left_sum&&right_sum >= mid_sum)
				return{ right_low, right_high, right_sum };
			else
			return{ mid_low, mid_high, mid_sum };
		}
	}
}
void main()
{
	vector<int> a{13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};
	vector<int> b = find(a, 0, a.size()-1);
	for (auto c : b)
		cout << c << endl;
	system("pause");

}

第二种解决方法是动态规划

我们定义两个变量，其中一个是sum_,max，另一个是sum，sum_max保留的当前上一组

的最大值，而sum保存的是试探值，及当sum>sum_max的时候，把sum的值给sum_max

而当sum<0的时候意味着sum所加的元素不能代表最大子数组，应该从当前的一个元素

继续进行判断。

代码如下：

#include<iostream>
#include<vector>
using namespace std;
void pr(vector<int> a)
{
	if (a.size() == 0)
	{
		cout << 0 << endl;
		return;
	}
	int sum_max = 0;
	int sum_max1 = 0;
	int sum = 0;
	int key = 0;
	int key_1 = 0;
	for (int i = 0; i <= a.size() - 1; i++)
	{
		    sum += a[i];
			if (sum < 0)
			{
				sum = 0;
				key_1 = i + 1;
				continue;
			}
			if (sum > sum_max)
			{
				sum_max = sum;
				key = i;
			}
	}
	cout << key_1 << " " << key << " " << sum_max;
}
void main()
{

	vector<int> a{13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7 };
	pr(a);




	system("pause");

}

2.矩阵乘法

最简单的一种是n为2的幂的时候，以分治思想可以把a和b矩阵各自分成

4个，那么利用递归求解，而关于矩阵的分解，可以利用下标来进行表示

那么我们递归到最后其实处理的是最简单的乘法。

代码如下：

#include<iostream>
#include<vector>

using namespace std;
typedef vector<vector<int>> vector2;
void input(vector2&a, int n)
{
	int m;
	vector<int> c;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> m;
			c.push_back(m);
		}
		a.push_back(c);
		c.clear();
	}
}

void mul(const vector2 a, const vector2 b,vector2 &c,int x,int y,int x1,int y1,int n)
{
	if (n == 1)
	{
		c[x][y1] += a[x][y] * b[x1][y1];
	}
	else
	{
		n = n / 2;
		mul(a, b, c, x, y, x1, y1, n);
		mul(a, b, c, x, y+n, x1+n, y1, n);
		mul(a, b, c, x, y, x1, y1+n,n);
		mul(a, b, c, x, y+n, x1 + n, y1 + n, n);

		mul(a, b, c, x+n, y, x1, y1,n);
		mul(a, b, c, x+n, y + n, x1+n, y1, n);
		mul(a, b, c, x+n, y, x1, y1+n,n);
		mul(a, b, c, x+n, y +n, x1 + n, y1 + n, n);

	}
}

void main()
{
	vector2 a, b, c;
	int n;
	cin >> n;
	if ( n % 2 != 0)
	{
		cout << "error" << endl;
	}
	else
	{
		input(a,n);
		input(b,n);
		for (int i = 0; i < n; i++)
		{
			vector<int> q;
			for (int j = 0; j < n; j++)
			{
				int t = 0;
				q.push_back(t);
			}
			c.push_back(q);
		}
		mul(a, b,c, 0, 0, 0, 0, n);
		for (int i = 0; i < n; i++)
		{
			
			for (int j = 0; j < n; j++)
			{
				cout << c[i][j] << " ";
			}
			cout << endl;
		}
	}




	system("pause");

}

2.strassen算法

这个算法的核心思想是另递归树的枝叶不那么茂盛一点，显然，他做到了

代码如下：

#include<iostream>
#include<vector>

using namespace std;
typedef vector<vector<int>> vector2;
void input(vector2&a, int n)
{
	int m;
	vector<int> c;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> m;
			c.push_back(m);
		}
		a.push_back(c);
		c.clear();
	}
}

void mul(const vector2 a, const vector2 b, vector2 &c, int x, int y, int x1, int y1, int n)
{
	if (n == 2)
	{
		n = n - 1;
		int s[10];
		s[0] = b[x1][y1 + n] - b[x1 + n][y1 + n];
		s[1] = a[x][y] + a[x][y + n];
		s[2] = a[x + n][y] + a[x + n][x + n];
		s[3] = b[x1 + n][y1] - b[x1][y1];
		s[4] = a[x][y] + a[x + n][y + n];
		s[5] = b[x1][y1] + b[x1 + n][y1 + n];
		s[6] = a[x][y + n] - a[x + n][y + n];
		s[7] = b[x1 + n][y1] + b[x1 + n][y1 + n];
		s[8] = a[x][y] - a[x + n][y];
		s[9] = b[x1][y1] + b[x1][y1 + n];
		int p[7];
		p[0] = a[x][y] * s[0];
		p[1] = s[1] * b[x1 + n][y1 + n];
		p[2] = s[2] * b[x1][y1];
		p[3] = s[3] * a[x + n][y + n];
		p[4] = s[4] * s[5];
		p[5] = s[6] * s[7];
		p[6] = s[8] * s[9];
		c[x][y1] += p[4] + p[3] - p[1] + p[5];
		c[x][y1 + n] += p[0] + p[1];
		c[x + n][y1] += p[2] + p[3];
		c[x + n][y1 + n] += p[4] + p[0] - p[2] - p[6];
	}
	else
	{
		n = n / 2;
		mul(a, b, c, x, y, x1, y1, n);
		mul(a, b, c, x, y + n, x1 + n, y1, n);
		mul(a, b, c, x, y, x1, y1 + n, n);
		mul(a, b, c, x, y + n, x1 + n, y1 + n, n);
		mul(a, b, c, x + n, y, x1, y1, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1, n);
		mul(a, b, c, x + n, y, x1, y1 + n, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1 + n, n);

	}
}
void main()
{
	vector2 a, b, c;
	int n;
	cin >> n;
	if (n % 2 != 0)
	{
		cout << "error" << endl;
	}
	else
	{
		input(a, n);
		input(b, n);
		for (int i = 0; i < n; i++)
		{
			vector<int> q;
			for (int j = 0; j < n; j++)
			{
				int t = 0;
				q.push_back(t);
			}
			c.push_back(q);
		}
		mul(a, b, c, 0, 0, 0, 0, n);
		for (int i = 0; i < n; i++)
		{

			for (int j = 0; j < n; j++)
			{
				cout << c[i][j] << " ";
			}
			cout << endl;
		}
	}




	system("pause");

}

这是求解n是2的幂的矩阵乘法，当n不是2的幂的时候，其实我们可以把矩阵

转换为2的幂，例如我们可以补0进行转换，我们可以知道矩阵乘法最后的

行数和列数，那么我们删除其他的数字就可以得到矩阵乘法的结果。

代码的改变只是增加了补充函数与删除函数

代码如下：

#include<iostream>
#include<vector>
#include<math.h>
using namespace std;
typedef vector<vector<int>> vector2;
/*
算法导论的strassen算法扩展，及满足n不是2的幂的情况
思路是变为2的幂，补0
最后去除0
*/#include<iostream>
#include<vector>
#include<math.h>
using namespace std;
typedef vector<vector<int>> vector2;
/*
算法导论的strassen算法扩展，及满足n不是2的幂的情况
思路是变为2的幂，补0
最后去除0
*/
void output(vector2 const &a,int x1,int y1)
{
	for (int i = 0; i < x1; i++)
	{
		for (int j = 0; j < y1; j++)
		{
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
}
void input(vector2 &a, int x1, int y1,int n)//补充的具体实现
{
	vector<int> s;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (i < x1&&j < y1)
			{
				int t;
				cin >> t;
				s.push_back(t);
			}
			else
			{
				s.push_back(0);
			}
		}
		a.push_back(s);
		s.clear();
	}
}
int padding (vector2&a, vector2 &b, int x1, int y1, int x2,int y2)//判断应该补充多少
{
	int n = 6;//2的6次方已经极大
	for (int i = 2; i <= n; i++)
	{
		int t = pow(2, i);
		if (t >= x1)//判断n应该为多少
		{
			n = t;
			break;
		}
	}
	input(a, x1, y1, n);
	input(b, x2, y2, n);
	return n;
}
void mul(const vector2 a, const vector2 b, vector2 &c, int x, int y, int x1, int y1, int n)
{
	if (n == 2)
	{
		n = n - 1;
		int s[10];
		s[0] = b[x1][y1 + n] - b[x1 + n][y1 + n];
		s[1] = a[x][y] + a[x][y + n];
		s[2] = a[x + n][y] + a[x + n][x + n];
		s[3] = b[x1 + n][y1] - b[x1][y1];
		s[4] = a[x][y] + a[x + n][y + n];
		s[5] = b[x1][y1] + b[x1 + n][y1 + n];
		s[6] = a[x][y + n] - a[x + n][y + n];
		s[7] = b[x1 + n][y1] + b[x1 + n][y1 + n];
		s[8] = a[x][y] - a[x + n][y];
		s[9] = b[x1][y1] + b[x1][y1 + n];
		int p[7];
		p[0] = a[x][y] * s[0];
		p[1] = s[1] * b[x1 + n][y1 + n];
		p[2] = s[2] * b[x1][y1];
		p[3] = s[3] * a[x + n][y + n];
		p[4] = s[4] * s[5];
		p[5] = s[6] * s[7];
		p[6] = s[8] * s[9];
		c[x][y1] += p[4] + p[3] - p[1] + p[5];
		c[x][y1 + n] += p[0] + p[1];
		c[x + n][y1] += p[2] + p[3];
		c[x + n][y1 + n] += p[4] + p[0] - p[2] - p[6];
	}
	else
	{
		n = n / 2;
		mul(a, b, c, x, y, x1, y1, n);
		mul(a, b, c, x, y + n, x1 + n, y1, n);
		mul(a, b, c, x, y, x1, y1 + n, n);
		mul(a, b, c, x, y + n, x1 + n, y1 + n, n);
		mul(a, b, c, x + n, y, x1, y1, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1, n);
		mul(a, b, c, x + n, y, x1, y1 + n, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1 + n, n);
	}
}
void main()
{
	vector2 a, b, c;
	int x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	if (y1 != x2)
	{
		cout << "error not *" << endl;
	}
	else
	{
		int n=padding(a, b, x1, y1, x2, y2);
		for (int i = 0; i < n; i++)
		{
			vector<int> s;
			for (int j = 0; j < n; j++)
			{
				int t = 0;
				s.push_back(t);
			}
			c.push_back(s);
		}
		mul(a, b, c, 0, 0, 0, 0, n);
		output(c, x1, y2);
		
	}
	
	system("pause");

}
void output(vector2 const &a,int x1,int y1)
{
	for (int i = 0; i < x1; i++)
	{
		for (int j = 0; j < y1; j++)
		{
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
}
void input(vector2 &a, int x1, int y1,int n)//补充的具体实现
{
	vector<int> s;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (i < x1&&j < y1)
			{
				int t;
				cin >> t;
				s.push_back(t);
			}
			else
			{
				s.push_back(0);
			}
		}
		a.push_back(s);
		s.clear();
	}
}
int padding (vector2&a, vector2 &b, int x1, int y1, int x2,int y2)//判断应该补充多少
{
	int n = 6;//2的6次方已经极大
	for (int i = 2; i <= n; i++)
	{
		int t = pow(2, i);
		if (t >= x1)//判断n应该为多少
		{
			n = t;
			break;
		}
	}
	input(a, x1, y1, n);
	input(b, x2, y2, n);
	return n;
}
void mul(const vector2 a, const vector2 b, vector2 &c, int x, int y, int x1, int y1, int n)
{
	if (n == 2)
	{
		n = n - 1;
		int s[10];
		s[0] = b[x1][y1 + n] - b[x1 + n][y1 + n];
		s[1] = a[x][y] + a[x][y + n];
		s[2] = a[x + n][y] + a[x + n][x + n];
		s[3] = b[x1 + n][y1] - b[x1][y1];
		s[4] = a[x][y] + a[x + n][y + n];
		s[5] = b[x1][y1] + b[x1 + n][y1 + n];
		s[6] = a[x][y + n] - a[x + n][y + n];
		s[7] = b[x1 + n][y1] + b[x1 + n][y1 + n];
		s[8] = a[x][y] - a[x + n][y];
		s[9] = b[x1][y1] + b[x1][y1 + n];
		int p[7];
		p[0] = a[x][y] * s[0];
		p[1] = s[1] * b[x1 + n][y1 + n];
		p[2] = s[2] * b[x1][y1];
		p[3] = s[3] * a[x + n][y + n];
		p[4] = s[4] * s[5];
		p[5] = s[6] * s[7];
		p[6] = s[8] * s[9];
		c[x][y1] += p[4] + p[3] - p[1] + p[5];
		c[x][y1 + n] += p[0] + p[1];
		c[x + n][y1] += p[2] + p[3];
		c[x + n][y1 + n] += p[4] + p[0] - p[2] - p[6];
	}
	else
	{
		n = n / 2;
		mul(a, b, c, x, y, x1, y1, n);
		mul(a, b, c, x, y + n, x1 + n, y1, n);
		mul(a, b, c, x, y, x1, y1 + n, n);
		mul(a, b, c, x, y + n, x1 + n, y1 + n, n);
		mul(a, b, c, x + n, y, x1, y1, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1, n);
		mul(a, b, c, x + n, y, x1, y1 + n, n);
		mul(a, b, c, x + n, y + n, x1 + n, y1 + n, n);
	}
}
void main()
{
	vector2 a, b, c;
	int x1, y1, x2, y2;
	cin >> x1 >> y1 >> x2 >> y2;
	if (y1 != x2)
	{
		cout << "error not *" << endl;
	}
	else
	{
		int n=padding(a, b, x1, y1, x2, y2);
		for (int i = 0; i < n; i++)
		{
			vector<int> s;
			for (int j = 0; j < n; j++)
			{
				int t = 0;
				s.push_back(t);
			}
			c.push_back(s);
		}
		mul(a, b, c, 0, 0, 0, 0, n);
		output(c, x1, y2);
		
	}
	
	system("pause");

}

 

harkbox
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计实验报告-求最大子段和问题
01-20
算法设计实验报告，包括：蛮力法、分治法和减治法求最大子段和问题各自的基本思想、时间复杂度分析，C++实现代码，三种算法运行时间的比较，运行截图，实验心得。
最大子数组和问题分析总结
温顺的野狼
11-09 1466
问题：对给定义数组A，其长度为n，找出数组A中的最大子数组，例如数组A={-23,18,20,-7,12}，则最大子数组为{18,20,-7,12}。 应用：比如一段时间内股票如何低买高卖，获取最大利润。 解题思路：        （1）蛮力法（brute-force ）：通过二重循环计算每个子数字和，同时进行比较，最后的结果是最大子数组和及其开始和结束的坐标，即从数组中选择一个数A(i)，
【算法导论】最大子数组问题
Code for Yun
07-02 2424
#include #define LENGTH 16 //定义一个结构，记录了左右下表和总和，原因在于用于数据返还 typedef struct { int low; int high; int sum; }parm; parm findMaxCrossingSubarray(int number[],int low,int mid,int high)
分治-最大子数组（算法导论P39）
关注网络安全、云原生安全
01-01 1110
题目：给定一个整数数组，找出和最大得到子数组，返回其和。例如，（1,-2,3,5,-1,2）最大子数组（3,5,-1,2），和为9. 分析：利用分治思想，将数组分为两段，则，最大子数组在左子数组、右子数组、或者跨在两个子数组中间。       对于左右子数组利用递归解决，跨在中间的左右扩展即可。       MaxSubArr(int A[], int from, int to)参数：数组A，起...
课后实验5--返回一个整数数组中最大子数组的和（首尾相接改良版）
avx94467的博客
03-25 221
伙伴链接：http://www.cnblogs.com/chengqiqin07/ 一、设计思想 本次实验是在前一次的实验的基础上将初始数组的头和尾部连接起来，形成环，在环中寻找子数组中和的最大值。 关于寻找环状数组中子数组和的最大值，在课堂上按照老师的提示，将初始数组首尾相接形成环，再将其从任意一点断开，形成不同的数组，再从中找出子数组中和的最大值。于是我们进过思考，...
最大子序列和问题的求解.md
最新发布
07-15
对于序列 -2, 11, -4, 13, -5, -2，最大子序列和为20（从第2个元素到第4个元素）。 #### 三、算法详解 ##### 1. 穷举法（立方级方法） 该方法通过遍历所有可能的子序列来计算其和，并从中选择最大的一个。时间...
最大子数组和
05-26
通过对最大子数组和问题的研究，我们不仅复习了数据结构的基础知识，还深入理解了算法设计的不同策略，包括蛮力法、分治法和动态规划法。从实验结果来看，动态规划法由于其较低的时间复杂度和较高的效率，成为了解决...
java算法题 : 数组相关问题
03-14
2. 最大子数组和：寻找数组中连续子数组的最大和，Kadane's算法可以在一次遍历中解决，时间复杂度为O(n)。 3. 翻转数组：给定一个数组，反转数组中的元素。可以通过两个指针从两端向中间遍历并交换元素实现。 4. ...
2021秋-计软实验三：分治算法1
08-08
在“2021秋-计软实验三：分治算法1”中，我们关注的是如何利用分治算法解决最大子数组问题，并对比其与遍历算法在效率上的差异。 最大子数组问题要求找到一个数组中连续子数组的最大和。在给定的实验中，我们首先有...
第7章 分治算法(C++版).ppt
12-17
在实际编程中，分治算法不仅应用于排序和查找，还广泛用于图形学、计算几何、数学计算等领域，如计算斐波那契数列、解决矩阵乘法问题、解决最大子数组和问题等。掌握分治算法的思想和应用，对于提升编程能力和解决...
最大子数组问题
qq_32742637的博客
05-24 272
每周坚持搞三种算法问题，介绍一下最大子数组问题 算法思路：分治策略求解，将问题不断分为更小的问题，进而求解 问题描述：求数组中相连着的数 相加值最大，例如"{-3,2,3,-4,21,-5},输出最大为2+3-4+21=22" 代码：#define _CRT_SECURE_NO_WARNIGNS #include #include #include #define N 10 #defi
算法导论之最大子数组问题
SJCHEN1221的博客
02-02 372
例如我们在求解下面的最大子数组时 13 -3 -25 20 -3 -16 -23 18 20 -7 12 -5 -22 15 -4 7     最简单的做法就是暴力求解，但是时间复杂度为O(n^2); // // main.cpp // 算法导论 // // Created by SJCH...
【算法导论学习笔记】最大子数组问题
m0_37600149的博客
07-13 241
Maximum Subarray 要在一个数组中找出一个最大子数组，最直观的想法就是尝试所有可能的情况，从所有的子数组中找出和最大的子数组。这种方法的时间复杂度较高，下面采用分治算法来进行求解。 分治算法主要有三个步骤： 分解：将问题分解为一些子问题，子问题的形式与原问题一样，但规模更小； 解决：递归的求解子问题，如果子问题规模足够小，则停止递归； 合并：将子问题的解
算法导论学习笔记——4.1最大子数组问题
HDUCheater的博客
02-22 431
4.1最大子数组问题 这类问题之前我都是用dp做的，通过刷新下标st与ed，来找到答案。 pst指的是可能的开头(possible start)； 我的做法也是练习4.1-5的一个答案 pst=st=ed=1,maxsum=-inf,sum=0; for(i=1;i<=n;i++) { sum+=a[i]; if(sum>=maxsum) st=pst,ed=i,maxsum=su...
最大子数组问题（分治法）
疙瘩村村书记
11-16 312
最大数组问题（分治法） 时间算法度：Θ(nlgn)Θ\left(nlgn\right)Θ(nlgn) 该算法主旨：
分治策略之最大子数组（Python实现）
TrueDei
11-23 994
一、 实验目的及任务 分治法求解最大子数组问题 二、 实验环境 c++或java 三、 问题描述 Input : 一个数组 Output:最大连续子数组。 四、 编程任务 一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该连续子数组中各元素的和最大，这个连续子数组便被称作最大连续子数组。 五、 数据输入 随机产生1000以上的数据（有正有负），放入输入文件input.txt 六、 ...
第四章 分治策略 最大子数组问题
weixin_30588907的博客
10-07 75
最大子数组问题:找出数组中和最大的最大的非空连续子数组. 这里定义一个ret的类来进行存储三个值.用public只是用来方便读取和使用.. #include "stdafx.h" #include<iostream> using namespace std; class ret { public: ret(void){}; ret(int x,int y ...
c语言 回溯法 最大子数组和
09-30
回溯法是一种常用于解决组合问题的算法，通过不断尝试寻找满足特定条件的解，并记录下已经尝试过的解，从而找到最优解。...在实际应用中，可以使用动态规划或分治法等更优化的算法来解决最大子数组和的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值