凸包

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

凸包算法

凸包类型的题算法主要有三种：JarvisMarch算法、Graham算法和Andrew算法，这三种算法时间性能上递增。

JarvisMarch算法

/******************************************************************
                    Jarvis March的步进算法
算法复杂度：O(nH)。（其中 n 是点的总个数，H 是凸包上的点的个数）
******************************************************************/

/*
思想：
纵坐标最小然后横坐标最小的点一定是凸包上的点， 我们将其记为p0，从p0
开始，按逆时针的方向，逐个找凸包上的点，每前进一步找到一个点，所以叫
作步进法。
选取下一个点的方法：
假设已找到p0、p1，则利用跟p0p1向量夹角最小的点作为p2。（p1则利用p0p1
向量和水平线的夹角）
*/

//#include <bits/stdc++.h>
#include <queue>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAXN = 10005;
const double MAXD = 1e9;
const double ACCUR = 1e-9;

struct node
{
    double x, y;        //点的坐标
    bool operator < (const node n) const
    {
        if (abs(y-n.y) < ACCUR) return x < n.x;
        else    return y < n.y;
    }
    bool operator == (const node n) const
    {
        return (abs(x-n.x) < ACCUR) && (abs(y-n.y) < ACCUR);
    }
    void operator = (const node n)
    {
        x = n.x;
        y = n.y;
    }
};

struct vect
{
    double x, y;
    void operator = (const vect v)
    {
        x = v.x;
        y = v.y;
    }
    double operator *(const vect v) const
    {
        return x*v.x + y*v.y;
    }
};

bool equal (const double d1, const double d2)
{
    return abs(d1-d2) < ACCUR;
}
vect vform(const node n1, const node n2)
{
    vect tmpv;
    tmpv.x = n2.x - n1.x;
    tmpv.y = n2.y - n1.y;
    return tmpv;
}
double vlen(const vect v)
{
    return sqrt(v.x*v.x+v.y*v.y);
}
double vcos(const vect v1, const vect v2)
{
    return (v1*v2)/(vlen(v1)*vlen(v2));
}
double area (const node n1, const node n2, const node n3)
{
    double b1, b2, b3;
    b1 = vlen(vform(n1,n2));
    b2 = vlen(vform(n2,n3));
    b3 = vlen(vform(n3,n1));
    double b = (b1+b2+b3)/2;
    return sqrt(b*(b-b1)*(b-b2)*(b-b3));
}

node p[MAXN];           //点集
queue <node> bq;        //凸包顶点集

int main()
{
    int n;
    while(scanf("%d", &n) == 1)
    {
        if(n == 0)
        {
            break;
        }
        /*【注意】第一个点先不标记，作为循环结束条件（即最后找到第一个点）*/
        int f[MAXN] = {0};      //点集标记数组;
        vect v;                 //v表示上两个点形成的向量。
        node p0, p1;             //p0表示第一个点，p1表示上一个点。
        p0.x = p0.y = MAXD;     //初始化

        for (int i = 0; i < n; ++i)
        {
            scanf("%lf%lf", &(p[i].x), &(p[i].y));
            if (p[i] < p0)
            {
                p0 = p[i];
            }
        }

        p1 = p0;                //初始化上一个点
        //【注意】初始化向量的选取跟第一个点的选取关。
        //如果第一个点是横坐标最小然后纵坐标最小则初始向量为竖直单位向量
        v.x = 1; v.y = 0;       //初始向量为水平单位向量。
        do
        {
            node p2;            //待判定的点。
            vect v1;            //待判定的向量
            int j;              //带判定的点的下标
            double minvcos = -1, minvlen = MAXD;    //初始最大夹角和最小向量长度。
            for (int i = 0; i < n; ++i)
            {
                if (!f[i])      //判断该点是否已经在凸包上
                {
                    vect tmpv;
                    tmpv.x = p[i].x-p1.x;
                    tmpv.y = p[i].y-p1.y;
                    if (vcos(v,tmpv) > minvcos)
                    {
                        p2 = p[i];
                        v1 = tmpv;
                        j = i;
                        minvcos = vcos(v,tmpv);
                        minvlen = vlen(tmpv);
                    }
                    else if (equal(vcos(v,tmpv),minvcos) && vlen(tmpv) < minvlen)
                    {
                        p2 = p[i];
                        v1 = tmpv;
                        j = i;
                        minvcos = vcos(v,tmpv);
                        minvlen = vlen(tmpv);
                    }
                }
            }
            bq.push(p2);
            p1 = p2;
            v = v1;
            f[j] = 1;
            //printf("minvcos=%f,minvlen=%f\n", minvcos, minvlen);
        }while(!(p1==p0));

        /*
        while(!bq.empty())
        {
            node tmpp = bq.front();
            printf("(%f,%f)\n", tmpp.x, tmpp.y);
            bq.pop();
        }
        */
        
        //凸包周长
        double ans = 0;
        node fp, ep;
        fp = p0;
        while(!bq.empty())
        {
            ep = bq.front();
            bq.pop();
            ans += vlen(vform(fp, ep));
            fp = ep;
        }
        printf("%.2f\n", ans);
     
        /*
        //凸包面积
        double ans = 0;
        node fp = bq.front();
        bq.pop();
        node np = bq.front();
        bq.pop();
        while(!bq.empty())
        {
            node ep = bq.front();
            bq.pop();
            ans += area(fp,np,ep);
            np = ep;
            //printf("(%f,%f)\n", tmpp.x, tmpp.y);
        }
        printf("%d\n", (int)ans/50);
        */
    }
    return 0;
}

Graham算法

/************************************************************************
                        Graham Scan算法
时间复杂度：O(nlogn)。Scan过程为O(n)，预处理排序为O(nlogn)。
预处理排序：极角排序。
************************************************************************/


/*
思想：
把所有点放在二维坐标系中，则纵坐标最小的点一定是凸包上的点，记为p0。计算
各个点相对p0的幅角，按从小到大的顺序对各个点排序。（当幅角相同是，距离p0
比较近的排在前面）则幅角最小的点和最大的点一定在凸包上。取幅角最小的点记
为p1，将p0、p1入栈。连接栈顶的点和次栈顶的点，得到直线l，看当前点是在直线
的右边还是左边，在右边则栈顶元素不是凸包上的点，将其弹出，返回继续执行。如
果在左边，则当前点是凸包上的点。一直到幅角最大的那个点为之。
分析：
两个向量的叉积P1xP2 = x1*y2 - x2*y1，其中用结果的正负代表叉乘结果的方向。
该公式本质是两个三维向量（z轴分量为0）叉乘的结果（原来结果为(x1*y2 - x2*y1)
*k，其中k是z轴单位向量）。
*/


//#include <bits/stdc++.h>
#include <stack>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAXN = 10005;
const double MAXD = 1e9;
const double ACCUR = 1e-9;

struct node
{
    double x, y;        //点的坐标
    bool operator < (const node n) const
    {
        if (abs(y-n.y) < ACCUR) return x < n.x;
        else    return y < n.y;
    }
    bool operator == (const node n) const
    {
        return (abs(x-n.x) < ACCUR) && (abs(y-n.y) < ACCUR);
    }
    void operator = (const node n)
    {
        x = n.x;
        y = n.y;
    }
};

struct vect
{
    double x, y;
    void operator = (const vect v)
    {
        x = v.x;
        y = v.y;
    }
    //叉积
    double operator *(const vect v) const
    {
        return x*v.y - y*v.x;
    }
};

node p0;            //纵坐标最小的点

bool equal (const double d1, const double d2)
{
    return abs(d1-d2) < ACCUR;
}
vect vform(const node n1, const node n2)
{
    vect tmpv;
    tmpv.x = n2.x - n1.x;
    tmpv.y = n2.y - n1.y;
    return tmpv;
}
double vlen(const vect v)
{
    return sqrt(v.x*v.x+v.y*v.y);
}
double vcos(const vect v1, const vect v2)
{
    return (v1*v2)/(vlen(v1)*vlen(v2));
}
//极角排序
bool cmpp (const node p1, const node p2)
{
    vect v1, v2;
    v1 = vform(p0, p1);
    v2 = vform(p0, p2);
    if (equal(v1*v2,0))
    {
        return vlen(v1) < vlen(v2);
    }
    else
    {
        return v1*v2 > 0;
    }
}
//叉积判断点（v2的终点）在v1左边还是右边
bool cmpv (const vect v1, const vect v2)
{
    return (v1*v2 > 0) || equal(v1*v2,0);
}
double area (const node n1, const node n2, const node n3)
{
    /*
    //海伦公式
    double b1, b2, b3;
    b1 = vlen(vform(n1,n2));
    b2 = vlen(vform(n2,n3));
    b3 = vlen(vform(n3,n1));
    double b = (b1+b2+b3)/2;
    return sqrt(b*(b-b1)*(b-b2)*(b-b3));
    */

    //叉积公式（叉积为平行四边形面积）
    vect v1, v2;
    v1 = vform(n1, n2);
    v2 = vform(n1, n3);
    return abs(v1*v2)/2;
}

node p[MAXN];           //点集
stack <node> bs;        //凸包顶点集

int main()
{
    int n;
    p0.x = p0.y = MAXD; //初始化第一个点
    scanf("%d", &n);
    for(int i = 0; i < n; ++i)
    {
        scanf("%lf%lf", &(p[i].x), &(p[i].y));
        if(p[i] < p0)
        {
            p0 = p[i];
        }
    }
    sort(p,p+n,cmpp);
    bs.push(p[0]);
    bs.push(p[1]);
    int j = 2;
    while(j < n)
    {
        //取出栈顶和次栈顶
        node p1, p2;
        p2 = bs.top();
        bs.pop();
        p1 = bs.top();
        //构造叉乘向量
        vect v1, v2;
        v1 = vform(p1,p2);
        v2 = vform(p2,p[j]);
        if(cmpv(v1,v2))
        {
            bs.push(p2);
            bs.push(p[j]);
            ++j;
        }
    }
    /*
    while(!bs.empty())
    {
        node tmpp = bs.top();
        printf("(%f,%f)\n", tmpp.x, tmpp.y);
        bs.pop();
    }
    */
    /*
    //计算周长
    double ans = 0;
    node fp, ep;
    fp = p[0];
    while(!bs.empty())
    {
        ep = bs.top();
        bs.pop();
        ans += vlen(vform(fp, ep));
        fp = ep;
    }
    printf("%.2f\n", ans);
    */

    //计算面积
    double ans = 0;
    node fp, np, ep;
    fp = bs.top();
    bs.pop();
    np = bs.top();
    bs.pop();
    while(!bs.empty())
    {
        ep = bs.top();
        bs.pop();
        ans += area(fp,np,ep);
        np = ep;
    }
    printf("%d\n", (int)ans/50);
    return 0;
}

Andrew算法

/************************************************************************
                    Andrew算法（Graham Scan算法变种）
时间复杂度：O(nlogn)。Scan过程为O(n)，预处理排序为O(nlogn)。
预处理排序：水平排序排序。
************************************************************************/


/*
思想：
预处理排序改为水平排序，按照横坐标从小到大进行排序，横坐标相同则按纵坐标从
小到大排。按照graham算法思想从p0、p1扫描所有点得到下凸包，再从pn-1、pn-2扫
描所有点得到上凸包，二者结合即为整个凸包。（注意：这里的p1不一定在凸包里）
分析：
两个向量的叉积P1xP2 = x1*y2 - x2*y1，其中用结果的正负代表叉乘结果的方向。
该公式本质是两个三维向量（z轴分量为0）叉乘的结果（原来结果为(x1*y2 - x2*y1)
*k，其中k是z轴单位向量）。
*/


//#include <bits/stdc++.h>
#include <stack>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAXN = 10005;
const double MAXD = 1e9;
const double ACCUR = 1e-9;

struct node
{
    double x, y;        //点的坐标
    //水平排序（与极角排序不一样，只能确定p0和pn-1在凸包内）
    bool operator < (const node n) const
    {
        if (abs(x-n.x) < ACCUR) return y < n.y;
        else    return x < n.x;
    }
    bool operator == (const node n) const
    {
        return (abs(x-n.x) < ACCUR) && (abs(y-n.y) < ACCUR);
    }
    void operator = (const node n)
    {
        x = n.x;
        y = n.y;
    }
};

struct vect
{
    double x, y;
    void operator = (const vect v)
    {
        x = v.x;
        y = v.y;
    }
    //叉积
    double operator *(const vect v) const
    {
        return x*v.y - y*v.x;
    }
};

bool equal (const double d1, const double d2)
{
    return abs(d1-d2) < ACCUR;
}
vect vform(const node n1, const node n2)
{
    vect tmpv;
    tmpv.x = n2.x - n1.x;
    tmpv.y = n2.y - n1.y;
    return tmpv;
}
//计算向量长度
double vlen(const vect v)
{
    return sqrt(v.x*v.x+v.y*v.y);
}
//计算向量夹角余弦值
double vcos(const vect v1, const vect v2)
{
    return (v1*v2)/(vlen(v1)*vlen(v2));
}
/*
//极角排序
bool cmpp (const node p1, const node p2)
{
    vect v1, v2;
    v1 = vform(p0, p1);
    v2 = vform(p0, p2);
    if (equal(v1*v2,0))
    {
        return vlen(v1) < vlen(v2);
    }
    else
    {
        return v1*v2 > 0;
    }
}
*/
//叉积判断点（v2的终点）在v1左边还是右边
bool cmpv (const vect v1, const vect v2)
{
    return (v1*v2 > 0) || equal(v1*v2,0);
}
double area (const node n1, const node n2, const node n3)
{
    /*
    //海伦公式
    double b1, b2, b3;
    b1 = vlen(vform(n1,n2));
    b2 = vlen(vform(n2,n3));
    b3 = vlen(vform(n3,n1));
    double b = (b1+b2+b3)/2;
    return sqrt(b*(b-b1)*(b-b2)*(b-b3));
    */

    //叉积公式（叉积为平行四边形面积）
    vect v1, v2;
    v1 = vform(n1, n2);
    v2 = vform(n1, n3);
    return abs(v1*v2)/2;
}

node p[MAXN];           //点集
stack <node> bs;        //凸包顶点集

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i)
    {
        scanf("%lf%lf", &(p[i].x), &(p[i].y));
    }
    sort(p,p+n);
    //正向扫描（上凸包）
    bs.push(p[0]);
    bs.push(p[1]);
    int j = 2;
    while(j < n)
    {
        //取出栈顶和次栈顶
        node p1, p2;
        p2 = bs.top();
        bs.pop();
        //p1不一定在凸包中
        if(bs.empty())
        {
            bs.push(p2);
            bs.push(p[j]);
            ++j;
        }
        else
        {
            p1 = bs.top();
            //构造叉乘向量
            vect v1, v2;
            v1 = vform(p1,p2);
            v2 = vform(p2,p[j]);
            if(cmpv(v1,v2))
            {
                bs.push(p2);
                bs.push(p[j]);
                ++j;
            }
        }
    }
    //反向扫描（下凸包）
    int k = n-2;
    while(k >= 0)
    {
        //取出栈顶和次栈顶
        node p1, p2;
        p2 = bs.top();
        bs.pop();
        p1 = bs.top();
        //构造叉乘向量
        vect v1, v2;
        v1 = vform(p1,p2);
        v2 = vform(p2,p[k]);
        if(cmpv(v1,v2))
        {
            bs.push(p2);
            bs.push(p[k]);
            --k;
        }
    }
    bs.pop();   //p0重复进栈一次

    /*
    while(!bs.empty())
    {
        node tmpp = bs.top();
        printf("(%f,%f)\n", tmpp.x, tmpp.y);
        bs.pop();
    }
    */
    /*
    //计算周长
    double ans = 0;
    node fp, ep;
    fp = p[0];
    while(!bs.empty())
    {
        ep = bs.top();
        bs.pop();
        ans += vlen(vform(fp, ep));
        fp = ep;
    }
    printf("%.2f\n", ans);
    */
    
    //计算面积
    double ans = 0;
    node fp, np, ep;
    fp = bs.top();
    bs.pop();
    np = bs.top();
    bs.pop();
    while(!bs.empty())
    {
        ep = bs.top();
        bs.pop();
        ans += area(fp,np,ep);
        np = ep;
    }
    printf("%d\n", (int)ans/50);

    return 0;
}

 

今を生きる
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
凸包问题
ly's Blog
09-28 1073
凸包问题是计算机几何中的一个典型问题 凸包问题的定义就是在平面上n个点组成的集合，其凸包就是包含这些点的最小凸多边形，凸多边形的任何一条边所在的直线把凸多边形全部划在同一个半平面内。 求凸包问题的算法有枚举法，分治法，格雷厄姆扫描法等 先介绍枚举法： 枚举法就是通过将每两个点都一遍一遍去尝试的求出满足条件的解 凸包的重要性质： 如果点集中的两个点的连线属于凸多边形的边，当且仅当点集中其...
Jarvis步进法（Jarvis March）凸包算法
言午日月
01-10 669
这样可以确保在构建的凸包上，点的极角是递增的，最终形成一个逆时针方向的凸多边形。算法的时间复杂度主要取决于对点的排序操作，通常为O(n log n)，其中n是点的数量。从点集中选择一个起始点，然后在每一步中选择下一个顶点，该顶点是当前点集中与当前点形成的线段上，极角最小的点。扫描过程： 从起始点开始，选择当前点（假设为p），然后选择下一个点（假设为q），这个点是当前点p与其他点形成的线段上，极角最小的点。选择起始点的过程可以通过遍历点集，找到y坐标最小的点，并在y坐标相同时，选择x坐标最小的点。
计算几何入门 1.4：凸包的构造——Jarvis March算法
Housz的博客
02-06 4665
回顾凸包构造算法：极点法、极边法和增量构造法，其复杂度分别为O(n^4)、O(n^3)和O(n^2)，效率经过优化已经大大提高了。接下来引入一种新的算法——Jarvis March，其复杂度也是O(n^2)，但是相较于增量构造在最好情况下效率是较高的。 一、选择排序 依旧是先回顾一个经典算法：选择排序（selection sort）。排序过程可以归结为下图： 对比插入排序，可以发现sor...
凸包算法Jarvis's march步进法和Graham扫描法的原理及实现
沉默、凝视的博客
11-10 1595
凸包概念 在二维欧几里得空间中，凸包可想象为一条刚好包著所有点的橡皮圈。 用自己的话说就是在一个点集中，能够包含所有点的凸多边形（所有的点都能落入多边形的内部）。专业的描述可以通过百度百科了解。在作者Kyle Loudon的《Mastering Algorithms with C》一书的中文版中描述到一个点集的凸包是指包含该点集中的所有点的最小凸多边形。如果一个多边形内任意两...
2D凸包算法（一）：Jarvis' March （ Gift Wrapping Algorithm ）
shungry的博客
02-16 2731
Jarvis’ March 图示 先从一个凸包上的顶点开始，顺着外围绕一圈。 每当寻找下一个要被包围的点，则遍历平面上所有点，找出最外围的一点来包围。可以利用叉积运算来判断。 时间复杂度为 O(NM) ， N 为所有点的数目， M 为凸包的顶点数目。 具体思想： 先确定边界上的点v1和与下一个点v2 在点集里去寻找下一个点v3，使得v1 v3 v2满足CCW 如果满足，这就说明v3是更外...
凸包算法 Jarvis GrahamScan 两种算法对比
09-02
两种凸包算法 算法导论的详细实现 C++ VS2008
凸包算法 matlab程序
02-14
凸包算法在计算机科学中是一种重要的几何计算方法，特别是在机器学习和数据分析领域有着广泛的应用。在给定的标题和描述中，重点强调了"凸包算法"在解决"二元分类问题"时使用MATLAB编程的情况。下面我们将深入探讨...
Python求凸包及多边形面积教程
01-20
一般有两种算法来计算平面上给定n个点的凸包：Graham扫描法(Graham’s scan)，时间复杂度为O(nlgn)；Jarvis步进法(Jarvis march)，时间复杂度为O(nh)，其中h为凸包顶点的个数。这两种算法都按逆时针方向输出凸包顶点...
Python 凸包算法
10-28
凸包问题是指在n个点中，寻找一个凸多边形，使所有的点在凸多边形的边界或者内部。实现语言：Python
Graham Scan && Jarvis March
09-29
vs 2010 解决Convex Hull 其中包括了用Graham Scan和Jarvis March两种算法， GUI用得picturebox， 可以改成panel效果更好 生成点更快 如有疑问 email wanglu1989224@yahoo.com.cn
凸包的JarvisMarch算法java实现
09-24
我个人用java写的关于凸包的JarvisMarch算法，也称gift wrapping算法。比较完美，算法的实现很简洁，只有加减乘除的基本运算，程序运行效率很高，计算10万个点的运行时间大概20秒左右。适当增加Point类中的屏幕范围，可以实现更多的点的运算。将x，y修改成double类型可以获得更多。代码量不多，所有没写什么注释，这本来就是为完成作业而仓促而就，文件里有6个测试类，看看基本就明白该怎么用了。借鉴了一些网上的代码，原作者现在也找不到名字了，在此一并致谢。
凸包自动生成
07-01
在计算机图形学中，"凸包自动生成"是一种重要的算法技术，主要用于找出一组二维点集中的最小外接凸多边形。这个过程可以应用于多种场景，如路径规划、碰撞检测和几何形状分析等。在本案例中，我们将讨论如何利用C#...
生成凸包代码
02-06
在计算机科学中，"生成凸包"是一种常见的几何算法，特别是在图形处理、机器学习和路径规划等领域有着广泛应用。凸包可以被理解为一个点集在二维或三维空间中包围的最小凸多边形或凸体。这篇内容我们将讨论如何使用C#...
Convex Hull：O(h*n)算法 Jarvis March
sherlockreal的博客
06-23 718
课程：计算几何 书籍：计算几何：算法与应用 Jarvis March算法也是一种递增式的思路。以极边的一个端点为起点，来查找另一条极边。以此进行下去，最后构成一个环路时（极点的末端等于最初的起始端点）。凸包构造结束。 关于以一个极边为起始点的一天极边。可以用ToLeft测试进行比较，就如同O（n^2）中对点集逆时针排序那样。 关于如何确定起始点，我们选取字典序最小的点作为起始点（Y值最...
平面凸包(jarvis算法)
肘子的博客
08-29 2031
算法大体思想：形成凸包的构造函数是这样的，找到一条直线l过其中一点(记为A)并且所有其他点都在l的同侧(显然这样的直线一定可以找到)，则A必为凸包上的一点。让l以A为轴点向一个方向(比如：顺时针方向)不断旋转，直到l碰到除A以外的第一个点(记为B)。如果同时碰到多于一个点，则取与A点距离最大的。再次以B为轴点，向相同的方向的旋转l，重复上述过程，直到l回到A点。 附上代码： #includ...
构造凸包-Jarvis March(Gift Wrapping)算法
longlongqin的博客
03-14 384
回顾凸包构造算法：极点法、极边法和增量构造法，其复杂度分别为O(n^4^)、O(n^3^)和O(n^2^)，效率经过优化已经大大提高了。接下来引入一种新的算法——Jarvis March，其复杂度也是O(n^2^)，但是相较于增量构造在最好情况下效率是较高的。实现策略先想一下为何极边法复杂度高达O(n^3^)。实际上我们要对点集中所有边进行遍历，这需要n^2^复杂度，然后对每个边进行鉴别，又需要n...
全国计算机三级（网络技术）做题技巧
07-22
全国计算机三级（网络技术）做题技巧
记录 cocos 开发问题 ，微信 wx.xxx函数 报找不到名称“wx”
最新发布
07-22
wx api 文件
OPENCV凸包算法
12-28
OpenCV提供了convexHull函数来实现凸包算法。该函数使用Sklansky算法来寻找凸包。下面是使用OpenCV进行凸包算法的示例代码： ```python import cv2 import numpy as np # 定义一些点 points = np.array([[0, 0], ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

今を生きる

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

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

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

打赏作者

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

抵扣说明：

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

余额充值