邻接表：删除一个顶点

最新推荐文章于 2024-07-25 17:57:45 发布
最新推荐文章于 2024-07-25 17:57:45 发布
阅读量760 收藏
点赞数 1
分类专栏： 我的dhu记录 文章标签： c++ 数据结构 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nameofworld/article/details/125616154
版权

邻接表：删除一个顶点

作者: 冯向阳时间限制: 1S章节: DS:图

截止日期: 2022-06-30 23:55:00

问题描述 :

目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。

内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的边）；否则，返回。图的存储结构采用邻接表。将其加入到ADT中。

注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）

参考函数原型：

//往G中删除一个顶点

template<class TypeOfVer, class TypeOfEdge>

bool adjlist_graph<TypeOfVer, TypeOfEdge>::DeleteVer(const int u);

图的邻接表模板类原型参考如下：

/* 边表的结点定义 */

template<class TypeOfEdge>

struct edgeNode

{

    int data;

    TypeOfEdge weight;

    edgeNode<TypeOfEdge> *next;

    edgeNode(const int &d, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（无权图） 

    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

    {

        next = ptr;

        data = d;

    }

    edgeNode(const int &d, const TypeOfEdge &w, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（带权图） 

    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

    {

        next = ptr;

        data = d;

        weight = w;

    }

    int getData(){ return data;}  //取得结点的序号（顶点集） 

    TypeOfEdge getWeight(){ return weight;}  //取得边集中对应边的权值 

    void SetLink( edgeNode<TypeOfEdge> *link ){ next = link; }  //修改结点的next域 

    void SetData( int value ){ data = value; }   //修改结点的序号（顶点集） 

    void SetWeight(TypeOfEdge value ){ weight = value; }   //修改边集中对应边的权值   

};

//图的邻接表类

template<class TypeOfVer, class TypeOfEdge>

struct verNode

{

    TypeOfVer ver;

    edgeNode<TypeOfEdge> *head;

    

    verNode(edgeNode<TypeOfEdge> *h = NULL){head = h;} 

    TypeOfVer getVer(){ return ver;}  //取得结点值（顶点集） 

    edgeNode<TypeOfEdge> *getHead(){ return head;}  //取得对应的边表的头指针 

    void setVer(TypeOfVer value){ ver = value;}  //设置结点值（顶点集） 

    void setHead(edgeNode<TypeOfEdge> *value){ head = value;}  //设置对应的边表的头指针

};

template <class TypeOfVer, class TypeOfEdge>

class adjlist_graph{

    private:

       int Vers;           //顶点数 

       int Edges;          //边数 

       verNode<TypeOfVer,TypeOfEdge> *verList;

       

       string GraphKind;     //图的种类标志 

       

       bool Delete_Edge( int u, int v ); 

       bool DFS(int u, int &num, int visited[]); //DFS遍历（递归部分）

    public:

       adjlist_graph( const string &kd, int vSize, const TypeOfVer d[]); //构造函数构造一个只有结点没有边的图。 

       adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e); 构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集 

       adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e, const TypeOfEdge w[]); //构造函数构造一个有权图。

       bool GraphisEmpty() { return Vers == 0; }  //判断图空否

       string GetGraphKind(){ return GraphKind; }

       bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值 

       int GetFirstAdjVex(int u, int &v); //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1

       int GetNextAdjVex(int u, int v, int &w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false

       bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值 

       bool InsertVer(const TypeOfVer &data); //往G中添加一个顶点 

       int LocateVer(TypeOfVer data); //返回G中指定顶点的位置 

       bool ExistEdge(int u, int v);

       bool PrintVer();  //输出顶点集 

       bool PrintAdjList();  //输出邻接矩阵 

       int GetVerNum(){ return Vers;}    //取得当前顶点数 

       int GetEdgeNum(){ return Edges;}  //取得当前边数 

       bool Insert_Edge(int u, int v); //无权图插入一条边

       bool Insert_Edge(int u, int v, TypeOfEdge w); //有权图插入一条边

       bool DeleteVer(const int  u); //往G中删除一个顶点 

       bool DeleteEdge( int u, int v ); //删除边 (外壳：有向（删除1条边）， 无向（删除2条边））

       void DFS_Traverse(int u); //DFS遍历（外壳部分）

       void BFS_Traverse(int u); //BFS遍历

       ~adjlist_graph(); //析构函数 

};

输入说明 :

建图的输入数据格式参见建图的算法说明。

第一行：图的类型

第二行：结点数

第三行：结点集

第四行：边数

第五行：边集

第六行：待删除的顶点的位序

输出说明 :

第一行：图的类型

第三行：删除前的顶点数

第四行：删除前的边数

第五行：删除前的邻接表

               空行

第六行：删除后的顶点集

第七行：删除后的顶点数

第八行：删除后的边数

第九行：删除后的邻接表

输入范例 :

UDG
6
A B C D E F
6
0 1
0 2
0 3
1 4
2 4
3 5
1

输出范例 :

UDG
A B C D E F
6
6
A->3->2->1->nullptr
B->4->0->nullptr
C->4->0->nullptr
D->5->0->nullptr
E->2->1->nullptr
F->3->nullptr

A C D E F
5
4
A->2->1->nullptr
C->3->0->nullptr
D->4->0->nullptr
E->1->nullptr
F->2->nullptr

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
int flag = 0,cou=0,flag2=0,flag1=0;
int cun[1000][3] = {0};
int am;
template<class TypeOfEdge>
struct Edge
{
    int vex;
    TypeOfEdge weight;
    struct Edge* next=NULL;
};
template<class TypeOfVer,class TypeOfEdge>
struct Ver
{
    string ver;
    Edge<TypeOfEdge>* next=NULL;
} ;
template<class TypeOfVer,class TypeOfEdge>
struct Graph
{
    Ver<TypeOfVer,TypeOfEdge> AdjList[100];
    int vnum;
    int bnum;
    void ADDUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    //void AWeight(Graph<TypeOfVer,TypeOfEdge>& G);
    void creatUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    void creatDG(Graph<TypeOfVer,TypeOfEdge> &G);
    int findvex(Graph<TypeOfVer,TypeOfEdge> *G,string v);
    void changeDG(Graph<TypeOfVer,TypeOfEdge> &G,int am);
    void changeUDG(Graph<TypeOfVer,TypeOfEdge> &G,int am);
} ;
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>:: ADDUDN(Graph& G)
{
    for (int j = 0; j < G.bnum; j++)
    {
        int temp = 0;
        cin >> temp;
        int qian= cun[j][0];
        int hou = cun[j][1];
        Edge<TypeOfEdge> * pa;
        Edge<TypeOfEdge>* ph;
        pa = G.AdjList[qian].next;
        ph = G.AdjList[hou].next;
        while (pa)
        {
            if (pa->vex == hou)
            {
                pa->weight = temp;
            }
            pa = pa->next;
        }
        while (ph)
        {
            if (ph->vex == qian)
            {
                ph->weight = temp;
            }
            ph = ph->next;
        }
    }
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatUDN(Graph &G)
{
    cin >>G.vnum ;
    for (int i = 0; i <G.vnum; i++)
    {
        cin >> G.AdjList[i].ver;
    }
    cin >> G.bnum;
    for (int i = 0; i < G.bnum; i++)
    {
        int x1;
        int x2;
        cin >> x1 >> x2;
        cun[i][0] = x1;
        cun[i][1] = x2;
        Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
        pa->vex = x2;
        pa->next= G.AdjList[x1].next ;
        G.AdjList[x1].next = pa;
        Edge<TypeOfEdge>* pb = new Edge<TypeOfEdge>;
        pb->vex = x1;
        pb->next= G.AdjList[x2].next ;
        G.AdjList[x2].next = pb;
    }
    //ADDUDN(G);
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatDG(Graph &G)
{
    cin >> G.vnum;
    for (int i = 0; i < G.vnum; i++)
    {
        cin >> G.AdjList[i].ver;
    }
    cin >> G.bnum;
    for (int i = 0; i < G.bnum; i++)
    {
        int x1;
        int x2;
        cin >> x1 >> x2;
        cun[i][0] = x1;
        cun[i][1] = x2;
        Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
        pa->vex = x2;
        pa->next=G.AdjList[x1].next;
        G.AdjList[x1].next = pa;
    }
}
template<class TypeOfVer,class TypeOfEdge>
int Graph<TypeOfVer,TypeOfEdge>::findvex(Graph *G,string v)
{
    int i;
    for(i=0; i<G->vnum; i++)
    {
        if(v==G->AdjList[i].ver)
        {
            return i;
        }
    }
    return -1;
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::changeDG(Graph &G,int am)
{
    for (int i = 0; i < G.vnum; i++)
    {
        Edge<TypeOfEdge>* t;
        t= G.AdjList[i].next;
        while (t != NULL)
        {
            if (t->vex == am)
            {
                cou++;
            }
            t = t->next;
        }
    }
    Edge<TypeOfEdge>* pa = G.AdjList[am].next;
    while (pa != NULL)
    {
        if (pa)
        {
            cou++;
        }
        pa = pa->next;
    }
    for (int i = 0; i < G.vnum; i++)
    {
        Edge<TypeOfEdge>* pr = G.AdjList[i].next;
        if (pr == NULL)
        {
            continue;
        }
        else if (pr->vex < am)
        {
        }
        else if (pr->vex == am)
        {
            G.AdjList[i].next = pr->next;
        }
        else if (pr->vex > am)
        {
            pr->vex--;
        }
        while (pr->next != NULL)
        {
            if (pr->next->vex< am)
            {
            }
            else if (pr->next->vex == am)
            {
                pr->next = pr->next->next;
            }
            else if (pr->next->vex > am)
            {
                pr->next->vex--;
            }
            if (pr == NULL)
            {
                break;
            }
            else if (pr->next != NULL)
            {
                pr = pr->next;
            }
        }
    }
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::changeUDG(Graph &G,int am)
{
    Edge<TypeOfEdge>* t;
     t= G.AdjList[am].next;
    while (t != NULL)
    {
        if (t)
        {
            cou++;
        }
        t = t->next;
    }
    for (int i = 0; i < G.vnum; i++)
    {
        Edge<TypeOfEdge>*pa = G.AdjList[i].next;

        if (pa == NULL)
        {
            continue;
        }
        else if (pa->vex == am)
        {
            G.AdjList[i].next = t->next;
        }
        else if (pa->vex < am)
        {
        }
        else if (pa->vex > am)
        {
            pa->vex--;
        }
        while (pa->next!=NULL)
        {
            if (pa->next->vex< am)
            {
            }
            else if (pa->next->vex == am)
            {
                pa->next = pa->next->next;
            }
            else if (pa->next->vex > am)
            {
                pa->next->vex--;
            }
            if (pa == NULL)
            {
                break;
            }
            else if (pa->next != NULL)
            {
                pa = pa->next;
            }
        }
    }
}
int main()
{
    string kind;
    cin >> kind;
    Graph<char,int> G;
    if (kind == "DG")//
    {
        G.creatDG(G);
        int am;
        cin>>am;
        cout << "DG" << endl;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        cout<<G.vnum<<endl;
        cout<<G.bnum<<endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa =G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.changeDG(G,am);
        for (int h = 0; h < G.vnum; h++)
        {
            if (h != am)
            {
                if (flag1 == 1)
                {
                    cout << " ";
                }
                flag1 = 1;

                cout << G.AdjList[h].ver;
            }
        }
        flag1 = 0;
        cout << endl;
        cout << G.vnum-1 << endl;
        cout << G.bnum-cou << endl;
        for (int u = 0; u < G.vnum; u++)
        {
            if (u == am)
            {
                continue;
            }
            cout << G.AdjList[u].ver;
            Edge<int>* mo = G.AdjList[u].next;
            while (mo)
            {
                cout << "->"<< mo->vex;
                mo = mo->next;
            }
            if (mo == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
    }
    else if (kind == "UDG")//
    {
        G.creatUDN(G);
        cin>>am;
        cout << "UDG" << endl;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        cout<<G.vnum<<endl;
        cout<<G.bnum<<endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa = G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.changeUDG(G,am);
        for (int h = 0; h < G.vnum; h++)
        {
            if (h != am)
            {
                if (flag2 == 1)
                {
                    cout << " ";
                }
                flag2 = 1;
                cout << G.AdjList[h].ver;
            }
        }
        flag2 = 0;
        cout << endl;
        cout << G.vnum-1 << endl;
        cout << G.bnum-cou << endl;
        for (int u = 0; u < G.vnum; u++)
        {
            if (u == am)
            {
                continue;
            }
            cout << G.AdjList[u].ver;
            Edge<int>* mo = G.AdjList[u].next;
            while (mo)
            {
                cout << "->"<< mo->vex;
                mo = mo->next;
            }
            if (mo == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
    }
    return 0;
}

nameofworld
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现邻接表顶点的删除
08-19
我们可以使用以下步骤来删除一个邻接表顶点： 1. 找到要删除的顶点v，并将其邻接顶点w的边删除掉。 2. 循环这个过程，直到把和顶点v有关的边都删除掉为止。 3. 删除顶点v。 在实现这个算法时，我们需要定义一个...
图的邻接表实现.rar
05-25
本项目提供了一个C++实现的邻接表，能够处理有向图和无向图，并且使用了类模板来增强代码的通用性。以下是对这个项目的详细解释： 首先，邻接表是一种存储图的有效方式，尤其适用于稀疏图（即边的数量远小于顶点...
30 邻接表：删除一个顶点
Ultravioletrays的博客
06-02 549
30 邻接表：删除一个顶点作者: 冯向阳时间限制: 1S章节: DS:图截止日期: 2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的
【邻接表】72 邻接表：删除一个顶点
windyuan~
05-25 1189
问题描述 : 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的边）；否则，返回。图的存储结构采用邻接表。将其加入到ADT中。 注意：DG（有向图）, DN（有向网）.
【东华大学oj】邻接表：删除一个顶点
的博客
06-25 538
///构造函数构造一个无权图。edgeNode(const int &d, const TypeOfEdge &w, edgeNode *ptr = NULL) //构造函数，用于构造其他结点（带权图）//返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。
邻接表：删除一个顶点（二臂版）
xiatutut的博客
07-05 392
邻接表：删除一个顶点 时间限制: 1S类别: DS：图->邻接表 晚于: 2022-07-31 23:55:00后提交分数乘系数50% 截止日期: 2022-08-07 23:55:00 问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实.......
邻接表：删除一个顶点（完全改变了图的邻接链表的结构）
Blackoutdragon的博客
12-22 2614
文章目录问题描述 :输入说明 :输出说明 :输入范例 :输出范例 :思路分析实现伪码事故现场分析总结 问题描述 : 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的边）；否则，返
邻接表：添加一个顶点
nameofworld的博客
07-02 689
邻接表：添加一个顶点作者: 冯向阳时间限制: 1S章节: DS:图截止日期: 2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，向已存在的图中添加一个顶点。图的存储结构采用邻接表。添加的顶点的位序在顶点集。
29 邻接表：添加一个顶点
Ultravioletrays的博客
06-02 1014
29 邻接表：添加一个顶点作者: 冯向阳时间限制: 1S章节: DS:图截止日期: 2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，向已存在的图中添加一个顶点。图的存储结构采用邻接表。添加的顶点的位序在顶
邻接表：删除一个顶点（正常版）
xiatutut的博客
07-05 584
正解函数在里面，是修改过的，把函数直接写在类里面比较好看也好找。 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的边）；否则，返回。图的存储结构采用邻接表。将其加入到ADT中..
【邻接表】70 邻接表：添加一个顶点
windyuan~
03-02 1327
问题描述 : 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实现一个算法，向已存在的图中添加一个顶点。图的存储结构采用邻接表。添加的顶点的位序在顶点集的末端。将其加入到ADT中。 注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN.
C++实现有向图的邻接表表示
12-20
在邻接表表示法中，有向图的每个顶点都有一个链表，链表中的每个节点代表与该顶点相连的其他顶点，即邻接顶点。 【邻接表的优势】 相比于邻接矩阵，邻接表在处理稀疏图时更为高效，因为它只存储实际存在的边，而不...
b.rar_删除邻接_邻接表删除
09-19
数据结构图的存储结构及基本操作 要求： ⑴能根据输入的顶点、边/弧的信息建立图； ⑵实现图中顶点、边/弧的插入、删除； ⑶实现对该图的深度优先...备注：单号基于邻接矩阵，双号基于邻接表存储结构实现上述操作。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 411
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3468
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 985
空心正方形，空心三角形，X形，沙漏图案打印
C++| STL之迭代器和vector
最新发布
qq_40306845的博客
07-25 349
C++STL迭代器是介绍和使用，以及vector工具的理解和使用。
邻接矩阵删除一个顶点
07-28
- *1* [邻接表：删除一个顶点（二臂版）](https://blog.csdn.net/xiatutut/article/details/125618817)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值