77、CVRP方法（整数规划、横扫式聚类、层次聚类、扫描法、T2C）

最新推荐文章于 2024-04-01 15:40:29 发布
最新推荐文章于 2024-04-01 15:40:29 发布
阅读量1.1k 收藏 16
点赞数
分类专栏： 车辆路径问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoyuzhang/article/details/118187601
版权

整数规划建模

import random as rd
from pyscipopt import Model, quicksum
from tool.Distance import calculate_distance
from VRP.CVRP.tool.Plot import *
from VRP.CVRP.tool.Print import *
from VRP.CVRP.tool.Data_generate import *

#一维装箱整数规划
def IP_1d(points, capacity, time_limit):

    n = len(points)

    model = Model("IP_1d")

    #i为车子下标，j为点下标
    X = [[model.addVar(vtype="B", name="x[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]
    Y = [model.addVar(vtype="B", name="y[%s]" % i) for i in range(n)]

    #以总包裹体积最小（即填充率最大）为目标
    model.setObjective(quicksum(Y[i] for i in range(n)), "minimize")

    #每个车子内货量不超
    for i in range(n):
        model.addCons(quicksum(points[j].demand*X[i][j] for j in range(n)) - capacity*Y[i] <= 0)

    #每个商品都能被装下
    for j in range(n):
        model.addCons(quicksum(X[i][j] for i in range(n)) == 1)

    #设置求解时间
    model.setRealParam("limits/time", time_limit)
    # model.hideOutput()
    model.optimize()
    print("\ngap:",model.getGap())

    X1 = [[round(model.getVal(X[i][j])) for j in range(n)] for i in range(n)]
    Y1 = [round(model.getVal(Y[i])) for i in range(n)]

    return sum(Y1)

#附：列出L的所有真子集
def subset(L):
    LL = []
    n = len(L)
    for i in range(1, pow(2, n)-1):
        L1 = []
        temp = i
        for j in range(n):
            if temp%2 == 1:
                L1.append(L[j])
            temp = temp//2
        LL.append(L1)
    return LL

def CVRP_IP(points, K, capacity, time_limit):
    n = len(points)
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(n)] for i in
           range(n)]

    model = Model("CVRP_IP")

    X = [[model.addVar(vtype="B", name="X[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]
    Y = [[model.addVar(vtype="B", name="Y[%s,%s]" % (i, k)) for k in range(K)] for i in range(n)]
    f = [[[model.addVar(vtype="B", name="f[%s,%s,%s]" % (i, j, k)) for k in range(K)] for j in range(n)] for i in range(n)]

    model.setObjective(quicksum(Dis[i][j] * X[i][j] for i in range(n) for j in range(n)), "minimize")

    #几辆车的约束
    model.addCons(quicksum(X[0][j] for j in range(1, n)) == K)
    model.addCons(quicksum(X[j][0] for j in range(1, n)) == K)

    #其余一度约束
    for i in range(1, n):
        model.addCons(quicksum(X[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(X[j][i] for j in range(n) if i != j) == 1)

    #无子环约束
    SS = subset([i for i in range(n)])
    for S in SS:
        model.addCons(quicksum(X[i][j] for i in S for j in range(n) if j not in S) >= 1)

    #车辆容积限制
    for k in range(K):
        model.addCons(quicksum(points[i].demand*Y[i][k] for i in range(n)) <= capacity)

    #点必须被分配出去
    for i in range(1, n):
        model.addCons(quicksum(Y[i][k] for k in range(K)) == 1)

    #起点在每辆车上
    for k in range(K):
        model.addCons(Y[0][k] == 1)

    #点放在一起的约束
    for i in range(n):
        for j in range(n):
            model.addCons(X[i][j] <= quicksum(f[i][j][k] for k in range(K)))
            for k in range(K):
                model.addCons(Y[i][k] + Y[j][k] >= 2*f[i][j][k])

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)
    model.optimize()
    print("\ngap:", model.getGap())

    X1 = [[round(model.getVal(X[i][j])) for j in range(n)] for i in range(n)]

    return X1

def IP(points, capacity, time_limit):
    #确定车数
    K = IP_1d(points, capacity, time_limit)
    print("\nK:", K)

    #分配点数
    A = CVRP_IP(points, K, capacity, time_limit)
    LL_print("\nA: ", A)
    return A

def price(A, Dis):
    n = len(A)
    return sum([Dis[i][j] * A[i][j] for i in range(n) for j in range(n)])

if __name__ == "__main__":

    #这里先定义一下标准的CVRP问题，简单的，先看同构车型
    #点的范围及个数
    x_min, y_min, x_max, y_max, nums = 0,0,100,100,10

    #车容量
    capacity = 3

    #点集生成
    points = points_generate_CVRP(x_min, y_min, x_max, y_max, nums, capacity)
    print("\npoints", points)

    A = IP(points, capacity, 100)

    #价值及画图
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(nums)] for i in
           range(nums)]
    print("A:", price(A, Dis))
    A1 = [[1 if i < j and (A[i][j] == 1 or A[j][i] == 1) else 0 for j in range(len(points))] for i in range(len(points))]
    A_plot(points, A1, x_min, y_min, x_max, y_max)

横扫式聚类

from tool.Distance import calculate_distance
from VRP.CVRP.tool.Plot import *
from VRP.CVRP.tool.Print import *
from TSP.Heuristic import TSP_insert
from VRP.CVRP.tool.Data_generate import *
from VRP.CVRP.tool.Graph_transform import *

def clustering(points, capacity):

    p0 = points[0]
    points1 = points[1:]
    points1.sort(key=lambda p: p.x)

    #横扫式聚类
    LLP = []
    points1_used = [0 for i in range(len(points1))]
    while sum(points1_used) < len(points1_used):
        LP = []
        start = 0
        for i in range(len(points1_used)):
            if points1_used[i] == 0:
                start = i
                LP.append(points1[start])
                points1_used[start] = 1
                break
        dis = [[i, calculate_distance(points1[start].x, points1[start].y, points1[i].x, points1[i].y, "EUC")] for i in range(len(points1)) if points1_used[i] == 0]
        dis.sort(key=lambda x:x[1])

        if len(dis) > 0:
            count = points1[start].demand
            i = 0
            while i < len(dis):
                if count+points1[dis[i][0]].demand > capacity:
                    break
                else:
                    LP.append(points1[dis[i][0]])
                    count += points1[dis[i][0]].demand
                    points1_used[dis[i][0]] = 1
                    i += 1
        LLP.append(LP)

    #每片作TSP
    edges = set()
    for LP in LLP:
        pointsi = [[0, p0.x, p0.y]] + [[j+1, LP[j].x, LP[j].y] for j in range(len(LP))]
        D = {0:0}
        for j in range(len(LP)):
            D[j+1] = LP[j].ID
        Dis = [[calculate_distance(pointsi[i][1], pointsi[i][2], pointsi[j][1], pointsi[j][2], "EUC") for j in
                range(len(pointsi))] for i in range(len(pointsi))]
        A_insert = TSP_insert(pointsi, Dis)
        for i in range(len(A_insert)):
            for j in range(i+1, len(A_insert)):
                if A_insert[i][j] == 1:
                    edges.add((D[i],D[j]))

    X = [[1 if (points[i].ID, points[j].ID) in edges or (points[j].ID, points[i].ID) in edges else 0 for j in range(len(points))] for i in range(len(points))]

    return Unirected_to_directed(X)

def price(A, Dis):
    n = len(A)
    return sum([Dis[i][j] * A[i][j] for i in range(n) for j in range(n)])

if __name__ == "__main__":

    #这里先定义一下标准的CVRP问题，简单的，先看同构车型
    #点的范围及个数
    x_min, y_min, x_max, y_max, nums = 0,0,100,100,10

    #车容量
    capacity = 4

    #点集生成
    points = points_generate_CVRP(x_min, y_min, x_max, y_max, nums, capacity)
    print(points)

    A = clustering(points, capacity)
    LL_print("A", A)

    #价值及画图
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(nums)] for i in range(nums)]
    print("A:", price(A, Dis))
    A_plot(points, A, x_min, y_min, x_max, y_max)

层次聚类

from tool.Distance import calculate_distance
from VRP.CVRP.tool.Plot import *
from VRP.CVRP.tool.Print import *
from TSP.Heuristic import TSP_insert
from VRP.CVRP.tool.Data_generate import *
from VRP.CVRP.tool.Graph_transform import *

def hierarchical_clustering(points, capacity):

    p0 = points[0]
    points1 = points[1:]

    #以带约束的层次聚类方法初始化
    LLP = [[points1[i]] for i in range(len(points1))]
    flag = True
    while flag:
        flag = False
        Dis = [[i,j,calculate_distance(sum([point.x for point in LLP[i]])/len(LLP[i]), sum([point.y for point in LLP[i]])/len(LLP[i]),
                                       sum([point.x for point in LLP[j]])/len(LLP[j]), sum([point.y for point in LLP[j]])/len(LLP[j]), "EUC")]
               for i in range(len(LLP)) for j in range(i+1, len(LLP))]
        Dis.sort(key=lambda x:x[2])
        for pair in Dis:
            i, j = pair[0], pair[1]
            #合并条件：载重，载容，件数，团点
            if sum([point.demand for point in LLP[i]]) + sum([point.demand for point in LLP[j]]) <= capacity:
                LLP = LLP[:i] + LLP[i+1:j] + LLP[j+1:] + [LLP[i]+LLP[j]]
                flag = True
                break

    edges = set()
    for LP in LLP:
        pointsi = [[0, p0.x, p0.y]] + [[j+1, LP[j].x, LP[j].y] for j in range(len(LP))]
        D = {0:0}
        for j in range(len(LP)):
            D[j+1] = LP[j].ID
        Dis = [[calculate_distance(pointsi[i][1], pointsi[i][2], pointsi[j][1], pointsi[j][2], "EUC") for j in
                range(len(pointsi))] for i in range(len(pointsi))]
        A_insert = TSP_insert(pointsi, Dis)
        for i in range(len(A_insert)):
            for j in range(i+1, len(A_insert)):
                if A_insert[i][j] == 1:
                    edges.add((D[i],D[j]))

    X = [[1 if (points[i].ID, points[j].ID) in edges or (points[j].ID, points[i].ID) in edges else 0 for j in range(len(points))] for i in range(len(points))]

    return Unirected_to_directed(X)

def price(A, Dis):
    n = len(A)
    return sum([Dis[i][j] * A[i][j] for i in range(n) for j in range(n)])

if __name__ == "__main__":

    #这里先定义一下标准的CVRP问题，简单的，先看同构车型
    #点的范围及个数
    x_min, y_min, x_max, y_max, nums = 0,0,100,100,10

    #车容量
    capacity = 4

    #点集生成
    points = points_generate_CVRP(x_min, y_min, x_max, y_max, nums, capacity)
    print(points)

    A = hierarchical_clustering(points, capacity)
    LL_print("A", A)

    #价值及画图
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(nums)] for i in range(nums)]
    print("A:", price(A, Dis))
    A_plot(points, A, x_min, y_min, x_max, y_max)

扫描法

from tool.Distance import calculate_distance
from VRP.CVRP.tool.Plot import *
from VRP.CVRP.tool.Print import *
from TSP.Heuristic import TSP_insert
from VRP.CVRP.tool.Data_generate import *
from VRP.CVRP.tool.Graph_transform import *

import math

def angle_dir(p0, p1):
    dx, dy = p1.x-p0.x, p1.y-p0.y
    if dx > 0:
        if dy >= 0:
            angle = math.atan(dy/dx)
        else:
            angle = math.atan(dy/dx) + 2*math.pi
    elif dx == 0:
        if dy > 0:
            angle = math.pi/2
        elif dy == 0:
            angle = 0
        else:
            angle = math.pi*3/2
    else:
        angle = math.atan(dy/dx)+math.pi
    return angle

def sweep(points, capacity):

    p0 = points[0]
    points1 = points[1:]

    #按极坐标排序
    LL = [[points1[i], angle_dir(p0, points1[i])] for i in range(len(points1))]
    LL.sort(key=lambda x:x[1])
    points1 = [L[0] for L in LL]

    #初始化片区
    LLP = [[]]
    c = 0
    for p in points1:
        if p.demand + c <= capacity:
            LLP[-1].append(p)
            c += p.demand
        else:
            LLP.append([p])
            c = p.demand

    edges = set()
    for LP in LLP:
        pointsi = [[0, p0.x, p0.y]] + [[j+1, LP[j].x, LP[j].y] for j in range(len(LP))]
        D = {0:0}
        for j in range(len(LP)):
            D[j+1] = LP[j].ID
        Dis = [[calculate_distance(pointsi[i][1], pointsi[i][2], pointsi[j][1], pointsi[j][2], "EUC") for j in
                range(len(pointsi))] for i in range(len(pointsi))]
        A_insert = TSP_insert(pointsi, Dis)
        for i in range(len(A_insert)):
            for j in range(i+1, len(A_insert)):
                if A_insert[i][j] == 1:
                    edges.add((D[i],D[j]))

    X = [[1 if (points[i].ID, points[j].ID) in edges or (points[j].ID, points[i].ID) in edges else 0 for j in range(len(points))] for i in range(len(points))]

    return Unirected_to_directed(X)

def price(A, Dis):
    n = len(A)
    return sum([Dis[i][j] * A[i][j] for i in range(n) for j in range(n)])

if __name__ == "__main__":

    #这里先定义一下标准的CVRP问题，简单的，先看同构车型
    #点的范围及个数
    x_min, y_min, x_max, y_max, nums = 0,0,100,100,30

    #车容量
    capacity = 10

    #点集生成
    points = points_generate_CVRP(x_min, y_min, x_max, y_max, nums, capacity)
    print(points)

    A = sweep(points, capacity)
    LL_print("A", A)

    #价值及画图
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(nums)] for i in range(nums)]
    print("A:", price(A, Dis))
    A_plot(points, A, x_min, y_min, x_max, y_max)

T2C

from tool.Distance import calculate_distance
from VRP.CVRP.tool.Plot import *
from VRP.CVRP.tool.Print import *
from TSP.Heuristic import TSP_insert
from VRP.CVRP.tool.Data_generate import *
from VRP.CVRP.tool.Graph_transform import *

def X_init(points):
    D = {}
    for j in range(len(points)):
        D[j] = points[j]
    points1 = [[j, points[j].x, points[j].y] for j in range(len(points))]
    Dis = [[calculate_distance(points1[i][1], points1[i][2], points1[j][1], points1[j][2], "EUC") for j in range(len(points1))] for i in range(len(points1))]
    A_insert = TSP_insert(points1, Dis)

    edges = {i:[] for i in range(len(A_insert))}
    for i in range(len(A_insert)):
        for j in range(i+1, len(A_insert)):
            if A_insert[i][j] == 1:
                edges[i].append(j)
                edges[j].append(i)

    X = [0]
    now = 0
    while True:
        next = edges[now][0]
        if next in X:
            next = edges[now][1]
        if next in X:
            break
        X.append(next)
        now = next

    return [D[x] for x in X]

def T2C(points, capacity):

    p0 = points[0]

    #先把所有点串一下
    X = X_init(points)

    #初始化片区
    LLP = [[]]
    c = 0
    for p in X[1:]:
        if p.demand + c <= capacity:
            LLP[-1].append(p)
            c += p.demand
        else:
            LLP.append([p])
            c = p.demand

    #每片作TSP
    edges = set()
    for LP in LLP:
        pointsi = [[0, p0.x, p0.y]] + [[j+1, LP[j].x, LP[j].y] for j in range(len(LP))]
        D = {0:0}
        for j in range(len(LP)):
            D[j+1] = LP[j].ID
        Dis = [[calculate_distance(pointsi[i][1], pointsi[i][2], pointsi[j][1], pointsi[j][2], "EUC") for j in
                range(len(pointsi))] for i in range(len(pointsi))]
        A_insert = TSP_insert(pointsi, Dis)
        for i in range(len(A_insert)):
            for j in range(i+1, len(A_insert)):
                if A_insert[i][j] == 1:
                    edges.add((D[i],D[j]))

    X = [[1 if (points[i].ID, points[j].ID) in edges or (points[j].ID, points[i].ID) in edges else 0 for j in range(len(points))] for i in range(len(points))]

    return Unirected_to_directed(X)

def price(A, Dis):
    n = len(A)
    return sum([Dis[i][j] * A[i][j] for i in range(n) for j in range(n)])

if __name__ == "__main__":

    #这里先定义一下标准的CVRP问题，简单的，先看同构车型
    #点的范围及个数
    x_min, y_min, x_max, y_max, nums = 0,0,100,100,10

    #车容量
    capacity = 4

    #点集生成
    points = points_generate_CVRP(x_min, y_min, x_max, y_max, nums, capacity)
    print(points)

    A = T2C(points, capacity)
    LL_print("A", A)

    #价值及画图
    Dis = [[calculate_distance(points[i].x, points[i].y, points[j].x, points[j].y, "EUC") for j in range(nums)] for i in range(nums)]
    print("A:", price(A, Dis))
    A_plot(points, A, x_min, y_min, x_max, y_max)
chaoyuzhang
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python蚁群算法解决TSP和CVRP
weixin_44700966的博客
05-03 1911
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、TSP与CVRP的区别二、使用步骤1.引入库2.直接上代码总结 前言 蚁群算法，懂的自然懂，不懂的不会进来看 提示：以下是本篇文章正文内容，下面案例可供参考 一、TSP与CVRP的区别 TSP简单的说就是一个人以最短的路程走遍天下所有城市并回到出发城市不带重复的。 CVRP简单地说就是一个货车去各个城市接货，装满就拖车带回来，没装满就继续去写一个城市接货，直到所有城市的货都被他接收完，并且用的总路程最短。 二、使用步骤.
cvrp_cvrp_matlab_
10-01
MATLAB 求解CVRP（带容量的路径优化问题）
【CVRP】基于matlab节约算法求解带容量的车辆路径规划问题【含Matalb源码 157期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
01-26 4375
节约算法求解带容量的车辆路径规划问题 完整的代码，方可运行；可提供运行操作视频！适合小白！
运筹学经典问题（八）：CVRP和VRP-TW
最新发布
JESSIENOTCAR的博客
04-01 1073
给定一个图，图上的点代表客户，边代表客户之间的路线，边的权重代表客户之间的距离，点上的数字代表每个用户的需求量。如果只是上面的模型，可能会出现下图这种解，： 假设我们的问题是车辆去客户那里取货，需要一个约束去消除这种不包含仓库的子环。这也是VRP建模的一个略难的约束。会有图上的哪些边被选中，形成。没有约束车辆的容量限制！
【CVRP】基于matlab蚁群算法求解带容量的车辆路径规划问题【含Matlab源码 1039期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
06-20 5433
蚁群算法求解带容量的车辆路径规划问题 完整代码，直接运行，适合小白！可提供运行操作视频！
【VRP问题】基于节约算法CW求解带容量的车辆路径规划问题（CVRP）
m0_60703264的博客
08-17 1326
clear clc tic %% 用importdata这个函数来读取文件 rc208=importdata('rc208.txt'); cap=1000; %% 提取数据信息 vertexs=rc208(:,2:3); %所有点的坐标x和y customer=vertexs(2:end,:); %顾客坐标 cusnum=si...
【路径规划】基于节约算法实现CVRP问题matlab源码.md
08-05
【路径规划】基于节约算法实现CVRP问题
CVRP问题的一种启发式算法
06-02
CVRP问题的一种启发式算法，解决CVRP问题的优良算法
露天矿运输问题的模拟退火优化_彭程_路径规划matlab_cvrp_露天矿_matlab_matlab论文_
10-04
一篇基于matlab，解决的CVRP问题的论文。关键词包含路径规划等。
143.MATLAB编程 整数规划 源程序代码.zip
09-01
1.3.2 各类车辆路径规划问题研究（vrp、VRPTW、CVRP） 1.3.3 机器人路径规划问题研究 1.3.4 无人机三维路径规划问题研究 1.3.5 多式联运问题研究 1.3.6 无人机结合车辆路径配送 **1.4 三维装箱求解** **1.5 ...
【模糊聚类】基于模糊C均值聚类（FCM）实现数据聚类附Matlab代码.zip
07-29
1.3.2 各类车辆路径规划问题研究（vrp、VRPTW、CVRP） 1.3.3 机器人路径规划问题研究 1.3.4 无人机三维路径规划问题研究 1.3.5 多式联运问题研究 1.3.6 无人机结合车辆路径配送 **1.4 三维装箱求解** **1.5 ...
百度地图开发java源码-CVRP:车辆路径规划(带车辆数量以及载重约束VRP)
06-06
百度地图开发java源码 华为云DevCloud软件编程大赛·口罩配送大作战（赛道一） 用于测试 使用方式： 编译命令（要求jdk1.8）：javac MaskTest.java 运行命令：java MaskTest <你的代码进程启动命令> 例如： C++(windows): java MaskTest Main.exe C++(linux): java MaskTest ./Main.out java: java MaskTest java Main python: java MaskTest python Main.py 【赛题规则】 1）某市每日会公布五个已预约口罩派送的小区和每个小区的需求量（50-200）盒。 2）当日会安排一名志愿者配送员向已预约的五个小区投递口罩。配送员从仓库出发前往各小区派送点。（仓库容量：无限；配送员负载容量：100盒） 3）在派送过程中，配送员可能会收到某个新小区主动捐献口罩（1-100）盒的消息，他根据自己负载情况和原计划投送的路线进行评估，决定后续行走策略。 4）任务完成条件：五个已预约小区口罩投送完成。 5）评分标准：在满足任务完成条件后，按
车辆路径问题 CVRP
08-11
CPLEX的车辆路径问题的CVRP代码，基于OPL语言，已调，方便使用
遗传算法实现CVRP【matlab】
05-17
采用遗传算法实现CVRP问题，站点数32个，优化目标，运输成本最低化
蚁群算法cvrp
09-13
全新的蚁群算法cvrp，解决经典的VRP问题，np难题
CVRP建模与求解-基于粒子群算法（python实现）
_2312
04-27 1万+
本文为单配送中心、单车型、车辆封闭、非满载、需求不可拆分的VRP场景建立数学模型，并设计粒子群算法进行求解。
运筹系列17：routing模型之CVRP问题
热门推荐
kittyzc的博客
11-21 1万+
1. CVRP模型 CVRP指的是有容量（capacity）限制的VRP模型，是最常见的VRP模型。 2. 示例 依旧用上一章节的点，不同的是每个点多了一个送货需求。每辆车的最大容量是15，最小化总运输距离。 dimension可以使用AddDimensionWithVehicleCapacity方法，和AddDimension唯一的区别就是，第三个参数从一个固定值变成了一个列表，表示每一辆车有自...
关于CVRP问题的研究
ellsom的博客
03-19 2837
# Routing-problem--CVRP # 项目准备阶段 # 准备相关论文，设计准备数据集，最终决定采用CVRPLIB (opens new window)上的标准数据集作为实验用数据。 # 项目第一阶段 # 参考论文用各种元启发式算法求解CVRP问题 # 采取的算法主要有： # 贪心 (opens new window)、遗传 (opens new window)、蚁群 (op...
cvrp matlab
07-25
如果你想使用数学规划工具箱来解决CVRP问题，你可以定义目标函数和约束条件，并使用线性规划或混合整数线性规划进行求解。你可以使用Matlab提供的函数（如linprog、intlinprog等）来求解数学规划模型。 另一种方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值