分治算法：残缺棋盘可视化（Qt C++）

最新推荐文章于 2024-03-12 22:47:54 发布
最新推荐文章于 2024-03-12 22:47:54 发布
阅读量2.1k 收藏 30
点赞数 5
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 分治算法
by Russellwzr
本文链接：https://blog.csdn.net/weixin_44771757/article/details/107581897
版权

演示程序截图
在这里插入图片描述

问题描述

  • 残缺棋盘(defective chessboard)：是一个有 2 k × 2 k 2^k×2^k 2k×2k 个方格的棋盘，其中恰有一个方格残缺。对于任意 k k k，恰好存在 2 2 k 2^{2k} 22k 种不同的残缺棋盘。
  • 在残缺棋盘中，要求用三格板(triominoes)覆盖残缺棋盘。在覆盖中，任意两个三格板不能重叠，任意一个三格板不能覆盖残缺方格，但三格板必须覆盖其他所有方格。

基本要求

  • 输入棋盘大小和残缺方格的位置,输出覆盖后的棋盘。
  • 输出棋盘时要着色，共享同一边界的覆盖应着不同的颜色。棋盘是平面图，要求使用最少的颜色覆盖着色

问题分析

（1）创建残缺棋盘——初始化模块
按照用户输入，创建残缺棋盘对象
ChessBoard(int k,int dx,int dy);
（2）确定三格板的最小颜色编号——着色模块
//判断坐标是否越界
bool Range(int x,int y);
//确定当前三格板的最小颜色编号
void GetNo(int x,int y,bool vis[]);
//三格板着色
void Color(int sx,int sy,int dx,int dy,int size);
遍历当前要覆盖的三格板的相邻方格，确定三格板的最小颜色编号
（3）三格板覆盖残缺棋盘——算法模块
void Dye(int sx,int sy,int dx,int dy,int size);
void Cover();
调用类内算法，实现三格板覆盖残缺棋盘
（4）输出覆盖结果——输出模块
void Output();
（5）棋盘可视化——可视化模块
void paintEvent(QPaintEvent *);

设计思路

（1）创建棋盘：ChessBoard(int k,int dx,int dy);
首先进行赋值操作，完成对棋盘级数以及残缺点所在坐标的初始化；然后动态申请内存空间创建二维数组，最后完成初始化棋盘（二维数组）的操作。
（2）析构棋盘：~ChessBoard();
首先释放二维数组的第二维所申请的内存空间，最后释放第一维所申请的内存空间。
（3）确定三格板的最小颜色编号——着色模块：
void Color(int sx,int sy,int dx,int dy,int size);
该模块的核心思想是搜索相邻方格，新建一个bool类型的vis数组，来对搜索过程中遇到的颜色编号进行标记，最后遍历vis数组，从中取得未被标记的最小编号作为当前三格板的颜色编号，此时的颜色编号是最小的。
（4）三格板覆盖棋盘：void Dye(int sx,int sy,int dx,int dy,int size);
该模块的核心思想是分治，将覆盖整个棋盘这个原问题分解为独立且与原问题相似的子问题进行求解，具体实现思路如下：
先将棋盘均分成四部分，判定出没有残缺块的三个区域，然后在当前棋盘的中心位置放置三格板覆盖没有残缺块的三个区域的靠近中心的位置，将被覆盖的区域看作残缺块，这样四个区域均可转换为与原问题相同的残缺棋盘问题，分而治之，直至处理完全部棋盘，算法结束
（5）输出棋盘：void Output();
遍历棋盘（二维数组），格式化输出所对应下标的值
（6）棋盘可视化：void paintEvent(QPaintEvent * );
本模块使用Qt C++中的QPixmap类来绘制棋盘，首先指定绘图设备并填充背景，然后新建一个QPen类对象执行绘制棋盘的操作，棋盘着色的实现，则是首先新建一个QBrush类对象，然后调用QRandomGenerator类的generator函数接口来生成特定范围内的随机数以获取相应的RGB值，并根据随机生成的RGB值构造QColor类对象数组，最后根据存储棋盘的二维数组的相关位置与值的大小来设置画笔的绘图位置与颜色属性来完成颜色的填充。

代码实现

ChessBoard.h

#ifndef CHESSBOARD_H
#define CHESSBOARD_H

//坐标
struct Coordinate{
    int x,y;
    Coordinate(){}
    Coordinate(int xx,int yy):x(xx),y(yy){}
};


class ChessBoard{
    public:
        //构造函数
        ChessBoard(int k,int dx,int dy);
        //析构函数
        ~ChessBoard();
        //覆盖以(sx,sy)为左上角，大小为size的棋盘
        void Dye(int sx,int sy,int dx,int dy,int size);
        //覆盖
        void Cover();
        //输出棋盘
        void Output();
        //判断坐标是否越界
        bool Range(int x,int y);
        //确定当前三格板的最小颜色编号
        void GetNo(int x,int y,bool vis[]);
        //三格板着色
        void Color(int sx,int sy,int dx,int dy,int size);
    //private:
        int **a;        //存储棋盘信息
        int Size;       //棋盘边长
        int default_x;  //残缺点行号
        int default_y;  //残缺点列号
        int num;        //使用三格板的个数
        int tot;		//颜色个数
};
#endif // CHESSBOARD_H

ChessBoard.cpp

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iomanip>
#include "ChessBoard.h"
using namespace std;

//位移
int d[][2]={{0,1},{0,-1},{1,0},{-1,0}};

//构造函数
ChessBoard::ChessBoard(int k,int dx,int dy){
    Size=pow(2,k);
    default_x=dx;
    default_y=dy;
    tot=num=0;
    //动态申请二维数组
    a=new int*[Size];
    for(int i=0;i<Size;i++)
        a[i]=new int[Size];
    //初始化数组
    for(int i=0;i<Size;i++)
       for(int j=0;j<Size;j++)
           a[i][j]=0;
    //设置残缺点
    a[dx][dy]=-1;
}

//析构函数
ChessBoard::~ChessBoard(){
    //释放内存空间
    for(int i=0;i<Size;i++)
        delete[] a[i];
    delete []a;
}

//判断坐标是否越界
bool ChessBoard::Range(int x,int y){
    if(x<0||x>=Size||y<0||y>=Size||(x==default_x&&y==default_y))
        return false;
    return true;
}

//确定当前三格板的最小颜色编号
void ChessBoard::GetNo(int x,int y,bool vis[]){
    for(int i=0;i<4;i++){
        int dx=x+d[i][0],dy=y+d[i][1];
        if(Range(dx,dy)){
            vis[a[dx][dy]]=true;
        }
    }
}

//三格板染色
void ChessBoard::Color(int sx,int sy,int dx,int dy,int size){
    Coordinate tmp[10];
    tmp[0]=Coordinate(sx+size-1,sy+size-1);
    tmp[1]=Coordinate(sx+size-1,sy+size);
    tmp[2]=Coordinate(sx+size,sy+size-1);
    tmp[3]=Coordinate(sx+size,sy+size);
    bool vis[tot+10];
    memset(vis,0,sizeof(vis));
    //搜索周围区域
    for(int i=0;i<4;i++){
        if(!(tmp[i].x==dx&&tmp[i].y==dy)){
            GetNo(tmp[i].x,tmp[i].y,vis);
        }
    }
    int No=0;
    //确定三格板的最小颜色编号
    for(int i=0;i<tot+10;i++){
        if(!vis[i]){
            No=i;
            break;
        }
    }
    tot=max(tot,No);
    //染色
    for(int i=0;i<4;i++){
        if(!(tmp[i].x==dx&&tmp[i].y==dy)){
            a[tmp[i].x][tmp[i].y]=No;
        }
    }
}

void ChessBoard::Dye(int sx,int sy,int dx,int dy,int size){
    //覆盖完毕
    if(size<2)
        return;
    num++;
    //从中间分割棋盘
    size/=2;
    // 覆盖左上角子棋盘
    if (dx<sx+size&&dy<sy+size){
        Color(sx,sy,sx+size-1,sy+size-1,size);
        Dye(sx,sy,dx,dy,size);
    }
    else
        Dye(sx,sy,sx+size-1,sy+size-1,size);
    //覆盖右上角子棋盘
    if (dx<sx+size&&dy>=sy+size){
        Color(sx,sy,sx+size-1,sy+size,size);
        Dye(sx,sy+size,dx,dy,size);
    }
    else
        Dye(sx,sy+size,sx+size-1,sy+size,size);
    //覆盖左下角子棋盘
    if (dx>=sx+size&&dy<sy+size){
        Color(sx,sy,sx+size,sy+size-1,size);
        Dye(sx+size,sy,dx,dy,size);
    }
    else
        Dye(sx+size,sy,sx+size,sy+size-1,size);
    // 覆盖右下角子棋盘
    if (dx>=sx+size&&dy>=sy+size){
        Color(sx,sy,sx+size,sy+size,size);
        Dye(sx+size,sy+size,dx,dy,size);
    }
    else
        Dye(sx+size,sy+size,sx+size,sy+size,size);
}

//覆盖
void ChessBoard::Cover(){
    Dye(0,0,default_x,default_y,Size);
}

//输出
void ChessBoard::Output(){
    for(int i=0;i<Size;i++){
        for(int j=0;j<Size;j++){
            cout<<a[i][j]<<" ";
        }
        cout<<endl;
    }
}

Mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QLabel>
#include "ChessBoard.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    ChessBoard *test;
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
    QPixmap *map; // 绘制棋盘
    qreal sizeW;  // 单个方格的宽
    qreal sizeH;  // 单个方格的高
    bool flag_1;   //create
    bool flag_2;  //color
    void paintEvent(QPaintEvent *);
private slots:
    void on_pushButton_2_clicked();

    void on_pushButton_clicked();

    void on_pushButton_3_clicked();

    void on_pushButton_4_clicked();

private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

Mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "ChessBoard.h"
#include <QPainter>
#include <QRandomGenerator>
#include <QMouseEvent>
#include <QString>
#include <cmath>

//判断用户输入是否为整数
bool isDigitStr(QString src){
    QByteArray ba = src.toLatin1();
    const char *s = ba.data();
    while(*s && *s>='0' && *s<='9') s++;
    if (*s){
        return false;
    }
    else{
        return true;
    }
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->setWindowTitle("BrokenChessBoard");
    this->setFixedSize(QSize(1230, 980)); // 固定界面的大小
    test=new ChessBoard(2,0,0); // 初始化棋盘
    //flag_1:create
    //flag_2:color
    flag_1=flag_2=false;
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::paintEvent(QPaintEvent *)
{
    // 初始化棋盘
    map = new QPixmap(900, 900); // 初始化QPixmap的大小
    map->fill(Qt::white); // 填充背景色为白色
    QPainter painter(map); // 指定绘图设备为map
    // 创建一个画笔
    QPen pen;
    pen.setWidth(1);
    pen.setColor(Qt::black);
    pen.setStyle(Qt::SolidLine);
    painter.setPen(pen); // 设置画笔

    sizeH = qreal(map->height()) / test->Size;
    sizeW = qreal(map->width()) / test->Size;
    // 绘制棋盘
    for (int i = 1; i <= test->Size+1; i++)
        // 竖线
        painter.drawLine(QLineF(i*sizeW, 0, i*sizeW, map->height()));
    for (int i = 1; i <= test->Size+1; i++)
        // 横线
        painter.drawLine(QLineF(0, i*sizeH, map->width(), i*sizeH));

    // 绘制残缺方格
    // 设置一个画刷
    QBrush brush;
    brush.setColor(QColor(0, 0, 0));
    brush.setStyle(Qt::SolidPattern);
    painter.setBrush(brush);
    QRect rect(test->default_y*sizeW, test->default_x*sizeH, sizeW, sizeH);
    if (flag_1)
        painter.drawRect(rect);

    // flag为true，表示“覆盖棋盘”
    if (flag_2)
    {
        QRandomGenerator generator(10);
        int nums = (test->Size*test->Size-1)/3 + 1;
        QColor colors[nums];
        colors[0] = QColor(0, 0, 0); // 残缺棋盘的数字0，为黑色
        for (int i = 1; i < nums; i++)
            colors[i] = QColor(generator.bounded(80, 255), generator.bounded(80, 255),
                               generator.bounded(60, 255));
        for (int i = 0; i < test->Size; i++)
        {
            for (int j = 0; j<test->Size; j++)
            {
                // 填充颜色
                int temp = test->a[i][j];
                QBrush brusher;
                brusher.setColor(colors[temp]);
                brusher.setStyle(Qt::SolidPattern);
                painter.setBrush(brusher);
                rect.setRect(j*sizeW, i*sizeH, sizeW, sizeH);
                painter.drawRect(rect);
                // 填写数字
                painter.drawText(QPoint(j*sizeW+sizeW/2, i*sizeH+sizeH/2), QString::number(temp));
            }
        }
        flag_2 = false;
    }
    // 绘制
    QPainter painterAll(this); // 指定绘图设备为界面
    painterAll.drawPixmap(QPoint(300, 50), *map);
}

void MainWindow::on_pushButton_2_clicked()
{
    close();
}

//Create
void MainWindow::on_pushButton_clicked()
{
    // 初始化棋盘
    flag_1 = true;
    QString kk=ui->lineEdit->text();
    QString dr=ui->lineEdit_2->text();
    QString dc=ui->lineEdit_3->text();
    if(!isDigitStr(kk)||!isDigitStr(dr)||!isDigitStr(dc)){
        ui->label_4->setText("Error:The input must be integer!");
        return;
    }
    int k = kk.toInt();
    int defectRow = dr.toInt()-1;
    int defectColumn = dc.toInt()-1;
    delete test; // 清空原来的棋盘
    int sz=pow(2,k);
    if(k<=0||defectRow<=0||defectColumn<=0){
        ui->label_4->setText("Error:The input must be positive integer!");
        return;
    }
    if(defectRow>sz||defectColumn>sz){
        ui->label_4->setText("Error:The input is out of range!");
        return;
    }
    test = new ChessBoard(k, defectRow, defectColumn);
    //绘制棋盘
    this->repaint();
    QString res="Successfully Create ChessBoard!\n";

    res+="The Size of the ChessBoard is ";
    res+=QString::number(sz);
    res+="\n";
    res+="The imperfect coordinates is (";
    res+=dr;res+=", ";res+=dc;res+=").\n";
    ui->label_4->setText(res);
}

//Color
void MainWindow::on_pushButton_3_clicked()
{
    flag_2=true;
    test->Cover();
    this->repaint();
    ui->label_4->setText("Successfully Color ChessBoard!");
}

//Reset
void MainWindow::on_pushButton_4_clicked()
{
    delete test;
    flag_1=false;
    test=new ChessBoard(2,0,0);
    this->repaint();
    ui->label_4->setText("Successfully Reset ChessBoard!");
}

Main.cpp

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

QT 画图事件参考了这篇 blog
https://blog.csdn.net/weixin_43360801/article/details/104169366

残缺棋盘游戏问题C++实现(分治法)
12-20
用C++实现的残缺棋盘游戏问题程序。注释详实，可读性好。效率较高。
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 分治算法 — 残缺棋盘
coding-hwz
11-17 2873
《数据结构、算法与应用 —— C++语言描述》学习笔记 —分治算法一、 残缺棋盘1、问题描述2、求解策略 一、 残缺棋盘 1、问题描述 残缺棋盘是一个有2k∗2k2^k*2^k2k∗2k个方格的棋盘，其中恰有一个方格残缺，如图为两个 k=2 的残缺棋盘： 在残缺期盼中，要求用三格板覆盖残缺棋盘。在覆盖中，任意两个三格板不能重叠，任意一个三个班不能覆盖残缺方格，但三格板必须覆盖其他所有方格。在这种限制条件下，所需的三格板总数为(22k−1)/3(2^{2k}-1)/3(22k−1)/3。四种三格板的形状如图
分治算法-残缺棋盘
weixin_44602007的博客
03-19 3951
分治算法-残缺棋盘  残缺棋盘是一个2^k*2^个方格的棋盘，其中恰有1个方格残缺。图中给出，其中残缺部分用阴影表示。 这样的棋盘称...
利用OpenCV实现C++语言中二维数组的可视化、图像显示
热门推荐
小山山的博客
11-25 1万+
利用OpenCV实现C语言中二维数组的图像显示 在利用C语言处理数组时，我们经常需要将图片的二维数组进行可视化；所以本文分享了一种利用OpenCV读取和生成图片的方法。 1. 利用OpenCV读取图片 前提条件： 本文的程序是在visual Studio2012中执行的； vs已经配置好调用OpenCV需要的设置，如包含库目录，库文件等； 在当前文件夹下有一幅名为“1”的.jpg格式的...
C++高效的数据可视化程序有哪些
weixin_35757191的博客
02-15 401
C语言有很多高效的数据可视化程序，以下是其中的一些： GNU绘图工具(GNU Plot)：这是一个强大的绘图工具，可以在终端或其他程序中使用，以生成高质量的二维和三维图形。它支持多种图形格式，并可以使用C语言进行自定义脚本。 OpenGL：这是一个开放的图形库，用于渲染2D和3D图形。它提供了一个跨平台的API，可在不同的操作系统和硬件上运行。 SDL：这是一个简单的跨平台图形库，适用于创建...
c ++创建二维数组_C ++中的二维数组
从零开始的教程世界
07-07 5274
c ++创建二维数组 介绍 (Introduction) A two-dimensional array in C++ is the simplest form of a multi-dimensional array. It can be visualized as an array of arrays. The image below depicts a two-dimensional arr...
分治法案例-残缺棋盘覆盖问题-JAVA实现
12-03
使用JAVA解决残缺棋盘覆盖问题：一个n*n的棋盘上有一个缺陷点，该点不能被覆盖，剩下的格子全部用三盒板覆盖。应用的是分治法。
分治算法 残缺棋盘解法
12-09
用分而治之方法可以很好地解决残缺棋盘问题。
Java基于分治算法实现的棋盘覆盖问题示例
08-28
Java基于分治算法实现的棋盘覆盖问题示例 本文主要介绍了Java基于分治算法实现的棋盘覆盖问题，简单描述了棋盘覆盖问题，并结合具体实例形式分析了Java基于分治算法实现棋盘覆盖问题的相关操作技巧。 知识点一：...
基于分治思想的残缺棋盘覆盖仿真
12-18
残缺棋盘覆盖仿真，功能包括 （1）自定义棋盘大小 （2）随机产生残缺块位置 （3）用4种不同颜色标识不同的三角板 （4）自动给出覆盖过程（速度可调） （5）对各种三角板进行自动计数
残缺棋盘覆盖_C++_残缺三格板_残缺棋盘_数据结构_
10-02
残缺棋盘中，要求用三格板(triominoes)覆盖残缺棋盘。在覆盖中，任意两个三格板不能重叠，任意一个三格板不能覆盖残缺方格，但三格板必须覆盖其他所有方格。输出覆盖后的棋盘，输出棋盘时要着色，共享同一边界的覆盖...
棋盘覆盖问题图形界面分治法详解（C++）
qq_47932093的博客
11-12 2045
用分治策略，当k>0时，将2^k*2^k棋盘分割成4个2^(k-1)*2^(k-1)子棋盘，如下图。 只要递归的使用这种分割，就可以将问题缩小到2*2的四缺三小问题啦。 我的编译环境是VS2019，用到了EasyX图形库，几百KB大小，可以去官网下一个，个人感觉挺好用。 输入： 4（k的值），50（每个方格的边长（像素单位）） 输出： 自己运行时由于加了Sleep()函数，所以会是一个动态的过程。数字代表递归的次数。颜色为RGB随机数，不想太多颜色可以把注释随机颜色的那行删掉.
《分治法———残缺棋盘问题》
最新发布
2301_80261854的博客
03-12 2077
将三格板编号1-（size2-1）/3，将每个方格板的编号填充在代表棋盘的数组中，以这种方式表示棋盘被方格板覆盖。我们用一个二维数组Board[][]来模拟棋盘，覆盖残缺棋盘所需要的三格板数目为（size2-1）/3。这样的棋盘我们成为“三格板”，残缺棋盘问题就是要用这四种三格板覆盖更大的残缺棋盘。我们用左上角方格所在行和列来唯一确定一个棋盘，残缺方格或“伪”残缺方格用行号和列号记录。（2）三格板不能覆盖残缺方格，但必须要覆盖其他所有的方格。//tr:棋盘中左上角方格所在行。//dr:残缺方格所在行。
残缺棋盘+染色（分治）
龙征天的博客
04-25 1737
问题描述 残缺棋盘(defective chessboard):是一个有2k×2k个 方格的棋盘，其中恰有一个方格残缺。对于任意k，恰好存在22k2^{2k}22k种不同的残缺棋盘。 在残缺棋盘中，要求用三格板(triominoes)覆盖残缺棋 盘。在覆盖中，任意两个三格板不能重叠，任意一个三 格板不能覆盖残缺方格，但三格板必须覆盖其他所有方格。 基本要求 (1)输入棋盘大小和残缺方格的位置,输出...
数据结构——残缺棋盘覆盖（问题+算法+UI界面）
ALTLI的博客
02-04 7952
总述：这是山东大学软件学院AI班大二下学期的数据结构课程设计（假期完成课设，开学第一周演示），假期花了1天时间完成了这个课程设计，代码在下面的连接中 百度网盘链接： 链接：https://pan.baidu.com/s/1RdlO2fgefQIRixebHlr_Ow 提取码：95mh 花5天时间帮同学写的课程设计基于QT实现九大排序的动态演示 文章目录一.残缺棋盘问题二.算法三.UI界面 一.残缺棋盘问题 残缺棋盘是一个有2k×2k2^{k}×2^{k}2k×2k 个方格的棋盘，其中恰有一个方格残缺，如下图
[算法设计与分析]4.3.3二分法不相似情况(残缺棋盘)
A beginner's learning path
09-10 1295
#include&lt;stdio.h&gt; #include&lt;iostream&gt; #include&lt;cmath&gt; using namespace std; const int N = 100; int amount = 0; int board[N][N]; void IncompleteChessBoard(); void Cover(int tr, int...
残缺棋盘 分治
weixin_44916213的博客
01-06 348
分析： 在这种限制条件下，所需要的三格板总数为？ 1)被覆盖板面积(除去残缺方格)为2k×2k-1 (k≥1) ； 2)三格板之间不能重叠； 3)三格板不能覆盖残缺方格，但必须覆盖其他所有方格。 (2k×2k-1)/3 2^k^×2^k^-1--->4^k^-1---->(3+1)^k^-1所得结果一定会被三整除 #include<iostream> using namespace std; int amount = 0;//用的块数 int Board[10.
残缺棋盘问题
摸爬滚打的进阶之路
02-21 3309
棋盘残缺问题分析
残缺棋盘问题 C语言 算法
qq_41864867的博客
03-26 4243
问题描述： Incomplete Chessboard Description TheBeet有一个块大小为(2^{N}2N*2^{N}2N)的棋盘。这个棋盘是由一个个格子组成的。很不幸的，在一个月黑风高的晚上，它被摔坏了。不幸中的万幸，它只被摔坏了一个格子（此格子可以在棋盘的任意位置）。 但是这个棋盘再也不能用来下棋了，于是TheBeet想把这个棋盘切成如以下的几种小块。...
c语言分治算法求解残缺棋盘问题，自己定义棋盘大小
04-07
好的，关于 c 语言分治算法求解残缺棋盘问题，可以这样实现： 首先，定义一个二维数组作为棋盘，大小可以根据需求自行定义。然后，将棋盘按照分治思想，分成四个子棋盘。接着，递归地对每个子棋盘进行同样的操作，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值