幻方（魔方阵）

已于 2024-03-13 12:52:58 修改
阅读量4.3k 收藏 25
点赞数 3
文章标签： c语言
于 2022-01-19 17:47:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stm32f103ZETb/article/details/122578153
版权

幻方（魔方阵）

文章目录

一、幻方

幻方（Magic Square）是一种将数字安排在正方形格子中，使每行、列和对角线上的数字和都相等的方法。

二、幻方种类及构造原理

1.奇数阶幻方

即 N 为奇数的 N x N 的矩阵。

本例使用罗（萝）伯（卜）法生成奇数幻方：

  1. 将 1 放在第一行中间一列。
  2. 从 2 开始直到n×n止各数依次按下列规则存放：
    按 45° 方向（右上方）行走，即每一个数存放的行比前一个数的行数减1，列数加1。
  3. 如果行列范围超出矩阵范围，则回绕。
    例如当前位置在第 1 行，则下一个位置应在第N行，列数同样加1；例如当前位置在第N列，则下一个位置应在第一列，行数同样减1。
  4. 如果按上面规则确定的位置上已有数，或上一个数是第 1 行第 n 列时，则把下一个数放在上一个数的下面。

代码如下：

void Odd_magic(int array[n][n])
{
    int k = 1;	//k为已填元素的个数
    int row = 0, column = (int)n / 2;	//起始点
    array[0][(int)n / 2] = 1;   //起始点的值
    while(k <= n * n)	//填完即跳出
    {
        if(column != n - 1 && row != 0)    //判断是否不在第一行，不在第N列
        {
            if(array[row - 1][column + 1] == 0)    //判断下一个点的值是否为零
            {
                array[row - 1][column + 1] = array[row][column] + 1;  //标记右上方
                row = row - 1;  column = column + 1;  //每标记一个点，一定要更换标注点的位置，以下都是
                k++;    //每标记一个点就加一，以下都是
            }
        }
        if(row == 0 && column != n - 1)    //判断是否在第一行
        {
            array[n - 1][column + 1] = array[row][column] + 1;
            row = n - 1;
            column = column + 1;
            k++;
        }
        if(column == n - 1 && row != 0)    //判断是否在第N列
        {
            array[row - 1][0] = array[row][column] + 1;
            row = row - 1;
            column = 0;
            k++;
        }
        if(((column != n - 1 && row != 0) && (array[row - 1][column + 1] != 0)) || (row == 0 && column == n - 1))  //判断是否在第一行或者第一列，右上方是否为零，是否在第一行第N列
        {
            array[row + 1][column] = array[row][column] + 1;
            row = row + 1;
            k++;
        }
    }
}

2.双偶数阶幻方

即 N 为4m（4的倍数）的 N x N 的矩阵。将矩阵分成四个区域，即：

AC
DB

本例使用Spring法生成双偶幻方：

  1. 将1放在幻方的任意一个角格，然后按从左到右、从上到下的顺序依次填写其余数，当然也可以是从上到下、从左到右的顺序。因此，每个角可以按两个方向的顺序来填写。
  2. 进行对称交换。以幻方中心点为对称点，将 A 区域的 row + column 为偶数的数字与 B 区域对应的数字进行交换；将 C 区域的 row + column 为奇数的数字与 D 区域对应的数字进行交换。（保证 不同时 为奇或偶即可。）

代码如下：

void Double_even_magic(int (*array)[N])
{
    int count = 1, row, column, temp;
    //第一步填写矩阵
    for(row = 0; row < N; row++)
        for(column = 0; column < N; column++)
            array[row][column] = count++;
    //第二步对称交换
    for(row = 0; row < N / 2; row++)
    {
		//交换A，B关于中心对称的值
        for(column = 0; column < N / 2; column++)
        {
        	//exchange(&a[row][column], &a[N - 1 - row][N - 1 - column]);
            if((row + column) % 2 == 0)
            {
                temp = array[row][column];
                array[row][column] = array[N - 1 - row][N - 1 - column];
                array[N - 1 - row][N - 1 - column] = temp;
            }
        }
        //交换C，D关于中心对称的值
        for(column = N / 2; column < N; column++)
        {
            if((row + column) % 2)
            {
                temp = array[row][column];
                array[row][column] = array[N - 1 - row][N - 1 - column];
                array[N - 1 - row][N - 1 - column] = temp;
            }
        }
    }
}

3.单偶数阶幻方

即 N 为4m + 2（2的倍数，不是4的倍数）的 N x N 的矩阵。将矩阵分成四个区域，即：

AC
DB

本例使用Strachey法生成单偶幻方（基于奇数阶幻方之上）：

  1. A区域用 1 至 (2m+1)2 填写成 2m+1 阶幻方；B区域用 (2m+1)2+1 至 2*(2m+1)2 填写成 2m+1 阶幻方；C区域用 2*(2m+1)2+1 至 3*(2m+1)2 填写成 2m+1 阶幻方；D区域用 3*(2m+1)2+1 至 4*(2m+1)2 =填写成 2m+1 阶幻方；
  2. 在A区域取左侧 m 列与D区域对应小格对调，在A区域中间行取中心格与其他行左侧一格与D区域对应小格对调（也就是，最中间的数字、中间一行从左向右前 m-1 个数字，其他行前 m 个数字）。在C区域中任取 m-1 列与B区域对应小格对调。

代码如下：

void Single_even_magic(int array[N][N])
{
    int count = 1, row, column, m = (int)N / 4, temp;
    int A[n][n] = {0}, B[n][n] = {0}, C[n][n] = {0}, D[n][n] = {0}; //初始化A，B，C，D
    //第一步，完成A, B, C, D幻方
    Odd_magic(A);
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
        {
            B[row][column] = A[row][column] + (2 * m + 1) * (2 * m + 1);
            C[row][column] = B[row][column] + (2 * m + 1) * (2 * m + 1);
            D[row][column] = C[row][column] + (2 * m + 1) * (2 * m + 1);
        }
    }
    // print(A, B, C, D);
    //第二步，完成A, D的对调，C, B的对调
    //完成A, D的对调
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < m; column++)
        {
            temp = A[row][column];
            A[row][column] = D[row][column];
            D[row][column] = temp;
        }
    }
    temp = A[m][m]; A[m][m] = D[m][m];  D[m][m] = temp;
    temp = A[m][m - 1]; A[m][m - 1] = D[m][m - 1];  D[m][m - 1] = temp;
    //完成C, B的对调
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < m - 1; column++)
        {
            temp = B[row][column];
            B[row][column] = C[row][column];
            C[row][column] = temp;
        }
    }
    // print(A, B, C, D);
    //将A, B, C, D对应区域赋值到array中
    for(row = 0; row < N; row++)
    {
        for(column = 0; column < N; column++)
        {
            if(row < n && column < n)
                array[row][column] = A[row][column];
            else if(row < n && column >= n)
                array[row][column] = C[row][column - n];
            else if(row >= n && column < n)
                array[row][column] = D[row - n][column];
            else if(row >= n && column >= n)
                array[row][column] = B[row - n][column - n];
        }
    }
}

三、整体代码

最后附上总代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define N 3     //幻方阶数

#if (N % 2 == 0 && N % 4 != 0)
#define n N / 2		//单偶
#else
#define n N		//双偶、奇数
#endif

void Odd_magic(int array[n][n]);    //生成奇数阶幻方
void Double_even_magic(int (*array)[N]);    //生成双偶数阶幻方
void Single_even_magic(int array[N][N]);    //生成单偶数阶幻方

int check(int array[N][N]); //检查生成的幻方是否正确，即行、列、对角线和是否相等
void print(int (*A)[n], int (*B)[n], int (*C)[n], int (*D)[n]); //打印A, B, C, D幻方
void exchange(int *x, int *y);   //交换两个整形变量的值


int main()
{
    int row, column,a[N][N] = {0};
    Odd_magic(a);   //测试奇数阶幻方
    // Double_even_magic(a);   //测试双偶数阶幻方
    // Single_even_magic(a);   //测试单偶数阶幻方
    if(!check(a))
    {
        for(row = 0; row < N; row++)
        {
            for(column = 0; column < N; column++)
                printf("%4d  ", a[row][column]);
            printf("\n");
        }
    }
    system("pause");
    return 0;
}

void Odd_magic(int array[n][n])
{
    int k = 1;	//k为已填元素的个数
    int row = 0, column = (int)n / 2;	//起始点
    array[0][(int)n / 2] = 1;   //起始点的值
    while(k <= n * n)	//填完即跳出
    {
        if(column != n - 1 && row != 0)    //判断是否不在第一行，不在第N列
        {
            if(array[row - 1][column + 1] == 0)    //判断下一个点的值是否为零
            {
                array[row - 1][column + 1] = array[row][column] + 1;  //标记右上方
                row = row - 1;  column = column + 1;  //每标记一个点，一定要更换标注点的位置，以下都是
                k++;    //每标记一个点就加一，以下都是
            }
        }
        if(row == 0 && column != n - 1)    //判断是否在第一行
        {
            array[n - 1][column + 1] = array[row][column] + 1;
            row = n - 1;
            column = column + 1;
            k++;
        }
        if(column == n - 1 && row != 0)    //判断是否在第N列
        {
            array[row - 1][0] = array[row][column] + 1;
            row = row - 1;
            column = 0;
            k++;
        }
        if(((column != n - 1 && row != 0) && (array[row - 1][column + 1] != 0)) || (row == 0 && column == n - 1))  //判断是否在第一行或者第一列，右上方是否为零，是否在第一行第N列
        {
            array[row + 1][column] = array[row][column] + 1;
            row = row + 1;
            k++;
        }
    }
}

void Double_even_magic(int (*array)[N])
{
    int count = 1, row, column, temp;
    //第一步填写矩阵
    for(row = 0; row < N; row++)
        for(column = 0; column < N; column++)
            array[row][column] = count++;
    //第二步对称交换
    for(row = 0; row < N / 2; row++)
    {
		//交换A，B关于中心对称的值
        for(column = 0; column < N / 2; column++)
        {
        	//exchange(&a[row][column], &a[N - 1 - row][N - 1 - column]);
            if((row + column) % 2 == 0)
            {
                temp = array[row][column];
                array[row][column] = array[N - 1 - row][N - 1 - column];
                array[N - 1 - row][N - 1 - column] = temp;
            }
        }
        //交换C，D关于中心对称的值
        for(column = N / 2; column < N; column++)
        {
            if((row + column) % 2)
            {
                temp = array[row][column];
                array[row][column] = array[N - 1 - row][N - 1 - column];
                array[N - 1 - row][N - 1 - column] = temp;
            }
        }
    }
}

void Single_even_magic(int array[N][N])
{
    int count = 1, row, column, m = (int)N / 4, temp;
    int A[n][n] = {0}, B[n][n] = {0}, C[n][n] = {0}, D[n][n] = {0}; //初始化A，B，C，D
    //第一步，完成A, B, C, D幻方
    Odd_magic(A);
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
        {
            B[row][column] = A[row][column] + (2 * m + 1) * (2 * m + 1);
            C[row][column] = B[row][column] + (2 * m + 1) * (2 * m + 1);
            D[row][column] = C[row][column] + (2 * m + 1) * (2 * m + 1);
        }
    }
    // print(A, B, C, D);
    //第二步，完成A, D的对调，C, B的对调
    //完成A, D的对调
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < m; column++)
        {
            temp = A[row][column];
            A[row][column] = D[row][column];
            D[row][column] = temp;
        }
    }
    temp = A[m][m]; A[m][m] = D[m][m];  D[m][m] = temp;
    temp = A[m][m - 1]; A[m][m - 1] = D[m][m - 1];  D[m][m - 1] = temp;
    //完成C, B的对调
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < m - 1; column++)
        {
            temp = B[row][column];
            B[row][column] = C[row][column];
            C[row][column] = temp;
        }
    }
    // print(A, B, C, D);
    //将A, B, C, D对应区域赋值到array中
    for(row = 0; row < N; row++)
    {
        for(column = 0; column < N; column++)
        {
            if(row < n && column < n)
                array[row][column] = A[row][column];
            else if(row < n && column >= n)
                array[row][column] = C[row][column - n];
            else if(row >= n && column < n)
                array[row][column] = D[row - n][column];
            else if(row >= n && column >= n)
                array[row][column] = B[row - n][column - n];
        }
    }
}

int check(int array[N][N])
{
    int i, j, value[5] = {0};
    for(j = 0; j < N; j++)
        value[0] += array[0][j];
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
        {
            value[1] += array[i][j];
            value[2] += array[j][i];
            if(i + j == N - 1)
                value[4] += array[i][j];
            if(i == j)
                value[3] += array[i][j];
        }
        if(value[0] == value[1] && value[0] == value[2])
        {value[1] = 0; value[2] = 0;}
        else
            return -1;
    }
    if(value[0] == value[3] && value[0] == value[4])
        return 0;
}


void print(int (*A)[n], int (*B)[n], int (*C)[n], int (*D)[n])
{
    int row, column;
    printf("A:\n");
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
            printf("%4d", A[row][column]);
        printf("\n");
    }
    printf("B:\n");
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
            printf("%4d", B[row][column]);
        printf("\n");
    }
    printf("C:\n");
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
            printf("%4d", C[row][column]);
        printf("\n");
    }
    printf("D:\n");
    for(row = 0; row < n; row++)
    {
        for(column = 0; column < n; column++)
            printf("%4d", D[row][column]);
        printf("\n");
    }
    printf("\n");
}

void exchange(int *x, int *y)
{
    int temp;
    temp = *y;
    *y = *x;
    *x = temp;
}

参考

幻方法则
单偶幻方的填法
单偶数幻方构造法

paopol
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C语言实现魔方阵算法(幻方阵 奇魔方 单偶魔方实现)
12-31
例如三阶魔方阵为： 魔方阵有什么的规律呢？ 魔方阵分为奇幻方和偶幻方。而偶幻方又分为是4的倍数（如4，8，12……）和不是4的倍数（如6，10，14……）两种。下面分别进行介绍。 2 奇魔方的算法2.1 奇魔方的规律与算法 奇魔方（阶数n = 2 * m + 1，m =1，2，3……）规律如下： 数字1位于方阵中的第一行中间一列；数字a（1 < a  ≤ n2）所在行数比a-1行数少1，若a-1的行数为1，则a的行数为n；数字a（1 < a  ≤ n2）所在列数比a-1列数大1，若a-1的列数为n，则a的列数为1；如果a-1是n的倍数，则a（1 < a  ≤ n2）的行数比a-1行数大1，列数
Leetcode840.Magic Squares In Grid矩阵中的幻方
Ha12312的博客
11-09 231
3 x 3 的幻方是一个填充有从 1 到 9的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。 给定一个由整数组成的 N × N 矩阵，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）。 示例 1: 输入: [[4,3,8,4], [9,5,1,9], [2,7,6,2]] 输出: 1 ...
魔方阵幻方
10-30
一个c语言编写的魔方阵,幻方程序源文件！代码简单易懂，容易看懂！
任意阶魔方阵
02-17
此文档可以解决100以内的任一魔方阵，当然也可以对此进行扩充完善，扩充时只需要改动一行代码，简单易操作。
【算法导论】幻方算法概述及Python实现
在岗Golang后端开发，分享一些日常笔记和代码
05-09 1142
幻方算法是一种数学算法，旨在创建一个特定大小的方阵，其中每个单元格都包含唯一的数字，以及满足特定条件的数字总和。在幻方算法中，每个数字只出现一次，而且每一行，每一列和对角线的数字之和都相等。
幻方矩阵（魔方矩阵）
tjpu小学生
10-17 3792
定义：如果一个数组具有相同行列且每行，每列和对角线上的和都一样，则成这些数组则成为魔方矩阵，又叫幻方矩阵。魔方矩阵中的每个元素不能相同。你能构造任何大小（除了2x2）的魔方矩阵。 在《射雕英雄传里》黄蓉和郭靖被追杀进黑龙潭中，无意进了瑛姑家中，瑛姑出了一道题：数字1-9填到三行三列中，要求每行、每列以及对角线上的和都相等。这道题难了瑛姑十几年，被黄蓉一下子解了出来。其实这就是魔方矩阵原理。 下面我们来看怎么用代码来呈现一个4x4的魔方矩阵 我们可以看到，我们虽然把这个4x4的幻方矩阵写了出来.
MATLAB入门——矩阵与幻方矩阵
A_kpt1234的博客
09-24 531
可以采用多种方法输入矩阵：输入元素的明确列表；从外部数据文件加载矩阵；使用内置函数生成矩阵；使用自己的函数创建矩阵，并将其保存在文件中。需要遵循的约定：使用空格或逗号分隔每一行的元素；使用分号分隔每一列的元素；使用方括号[ ]将整个元素列表括起来。
幻方常规解法汇总
weixin_34148456的博客
12-24 900
      没法，组合数学还考幻方构造。这东西不看解法真不会写，虽然没见有啥用，但还是记录下，免得日后再找。按目前填写幻方的方法，是把幻方分成了三类，即奇数阶幻方、双偶阶幻方、单偶阶幻方。下面按这三类幻方，列出最常用解法（考试用，不求强大，只求有效！）。 奇数阶幻方（罗伯法） 奇数阶幻方最经典的填法是罗伯法。填写的方法是： 把1（或最小的数）放在第一行正中； 按以下规律排列剩下的(n×n...
幻方的填法
wzlzf3385的博客
06-12 6339
幻方简易填法
魔方阵（各幻方）
wxk0123456789的博客
05-06 1596
1.什么叫幻方 所谓幻方，就是一个n行n列的正方形，共有n2个格子，将1、2、3、……、n2这些数字放到这些格子里，使其每行的和、每列的和及两条对角线的和都是一个相同的数S，S称为幻和。当n为奇数时，称为奇数阶幻方，当n为偶数时，称为偶阶幻方。当n可被4整除时，称方为双偶幻方。当n不可被4整除时，称为单偶幻方。 2.奇幻方解法 奇魔方（阶数n = 2 * m + 1，m =1，2，3……）规律如下： 数字1位于方阵中的第一行中间一列； 数字a（1 < a ≤ n2）所在行数比a-1行数少1，若a-1
任意阶魔方阵（幻方）
06-17
此资源可以解决任意魔方阵（幻方）的问题，代码容易理解。
java算法——奇数阶魔方阵
07-15
奇数阶魔方阵 * 1.自然数1出现在第一行的正中间 * 2.若填入的数字在第一行（不在第n列），则下一个数字在第n行且列数加1 * 3.若填入的数字在该行的最右侧，则下一个数字就填在上一行的最左侧 * 4.一般地，下一个...
奇数阶幻方的经典方法－罗伯法
wainixy的专栏
01-14 3955
原文出处：http://hi.baidu.com/chisir001/item/4677dd0d39993297a2df4321        所谓幻方，也教纵横图，就是在n×n的方阵中放入1到n2个自然数：在一定的布局下，其各行、各列和两条对角线上的数字之和正好都相等。这个和数就叫做“幻方常数”或幻和。        构造幻方的方法：        奇数阶幻方，也就是3阶、5阶、7阶…
matlab基础训练—矩阵和幻方矩阵
weixin_62838986的博客
02-18 2730
本篇文章中，我介绍了matlab矩阵和幻方矩阵的基础知识，大家想要了解的或是复习的都可以来看看，说不定就有所收获。
魔方阵的算法
weixin_43823667的博客
03-05 1743
魔方阵的算法原理: 魔方阵(1) 将1放在第一行中间一列; (2) 从2开始直到n×n止各数依次按下列规则存放： 按 45°方向向右上走，每一个数存放的行比前一个数的行数减1，列数加1； (3) 如果行列范围超出矩阵范围，则回绕。 例如1在第1行，则2应放在最下一行，列数同样加1; 又如某个数在第n列，则下一个数应放在第一列，行数同样减1； (4) 如果按上面规则确定的位置上已有数，或上一个数是第...
魔方阵（奇数，单偶，双偶）
weixin_42422557的博客
07-28 1838
目录 一、奇数 二、双偶 三、双偶 魔方阵，是指组成元素为自然数1、2、…、n2的平方的n×n的方阵，其中每个元素值都不相等，且每行、每列以及主、副对角线上各n个元素之和都相等。 魔方阵的规律 一、奇数 阶数为奇数n（n = 1,3,5...） （1）将1放在第一行中间一列。 （2）从2开始到n*n，每一个数存放的行在之前一个数的行数减1，列数加1。如果当前数字在第一行，那么下一个...
n 阶幻方问题
DoneSpeak的博客
11-01 6941
前言 这是很久以前做的一个实验的内容，觉得特别有意思，所以一直想发布出来，没想到拖着拖着就到现在了。 问题描述 一个n阶幻方是把从1到n^2的整数赶往一个n阶方阵，每一个数只出现一次，每一行、主副对角线的和都相等。 分析和本文基本概念 分析 据了解，4阶幻方个数的基本型就有880个，通过旋转和反射总共可有7040个不同的形式的，5阶幻方基本型有275 305 224个，6阶幻方的个数非常之多，皮恩...
C++ 版本 22:神奇的幻方
木落
11-21 4664
22:神奇的幻方 描述 幻方是一个很神奇的N*N矩阵，它的每行、每列与对角线，加起来的数字和都是相同的。 我们可以通过以下方法构建一个幻方。（阶数为奇数） 1.第一个数字写在第一行的中间 2.下一个数字，都写在上一个数字的右上方： a.如果该数字在第一行，则下一个数字写在最后一行，列数为该数字的右一列 b.如果该数字在最后一列，则下一个数字写在第一列，行数为该数字的上一行 c.如果该数字在右上角，或者该数字的右上方已有数字，则下一个数字写在该数字的下方 输入 一个数字N（N<=20） 输出 按上方法
判断字符串由几个单词组成（C语言）
最新发布
m0_67184754的博客
04-27 256
【代码】判断字符串由几个单词组成（C语言）
python神奇魔方阵
09-15
这段代码是用Python编写的生成神奇魔方阵的程序，它可以根据输入的方阵大小生成对应的魔方阵。魔方阵是一个方阵，其中每行、每列和对角线上的元素加起来都等于同一个值。具体的生成过程如下： 1. 首先，获取用户输入的方阵大小，该大小必须是奇数。 2. 创建一个大小为方阵大小的二维数组`magic_square`，并将所有元素初始化为0。 3. 定义两个指针`i`和`j`，初始位置分别为方阵的中间行和最后一列。 4. 从1开始，循环直到填满整个方阵。 5. 判断当前位置是否越界，如果越界则将指针调整到合适的位置。 6. 如果当前位置已经被填充过，则将指针调整到合适的位置。 7. 如果当前位置是空的，则将当前数字填入该位置，并将数字加1。 8. 更新指针的位置，向左上方移动。 9. 打印生成的魔方阵。 这段代码使用的是著名的奇数阶魔方阵生成算法。通过循环和条件判断，依次将数字填入方阵中的正确位置，最终生成一个满足要求的神奇魔方阵。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

paopol

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

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

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

打赏作者

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

抵扣说明：

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

余额充值