假定配送中心最多可以用2辆车对8个客户进行运输配送。每个车辆载重均为8吨，车辆每次配送的最大行驶距离为50km，配送中心（编号0）与8个客户之间及8个客户相互之间的距离dij（i, j = 1, 2, , 8）、8个客户的货物需求rj（j = 1, 2, , 8）如表1所示。要求寻找一条路径，使得配送总里程最短。表1 物流中心各节点之间的距离及客户需求dij01234567800467.5920101681406.541057.51110266.507.510107.57.57.537.547.501059915491010100107.57.5105205105100797.56107.57.597.570710716117.597.59701088107.515107.510100rj（吨）12121422c++代码是什么

以下是一个简单的贪心算法的C++代码实现：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

const int N = 9; // 节点数目，包括配送中心

double dist[N][N]; // 节点之间的距离
double demand[N]; // 客户节点的货物需求
bool visited[N]; // 是否已经访问过
double capacity = 8; // 车辆载重
double max_distance = 50; // 车辆最大行驶距离

// 计算两个节点之间的欧几里得距离
double euclidean_distance(int i, int j) {
    double dx = (double)(i / 3 - j / 3);
    double dy = (double)(i % 3 - j % 3);
    return sqrt(dx * dx + dy * dy);
}

// 贪心算法求解VRP问题
void solve_vrp() {
    // 初始化
    for (int i = 0; i < N; i++) {
        visited[i] = false;
        demand[i] = 0;
        for (int j = 0; j < N; j++) {
            dist[i][j] = euclidean_distance(i, j);
        }
    }
    demand[1] = demand[2] = demand[3] = demand[4] = 12;
    demand[5] = demand[6] = demand[7] = demand[8] = 22;

    // 贪心算法
    double total_distance = 0;
    int current_node = 0; // 当前节点为配送中心
    double current_capacity1 = 0; // 车辆1当前载重
    double current_capacity2 = 0; // 车辆2当前载重
    int last_visited_node1 = 0; // 车辆1上一个访问节点
    int last_visited_node2 = 0; // 车辆2上一个访问节点
    vector<int> path1; // 车辆1的路径
    vector<int> path2; // 车辆2的路径
    while (true) {
        visited[current_node] = true;
        if (current_node != 0) {
            current_capacity1 += demand[current_node];
            current_capacity2 += demand[current_node];
        }
        if (current_capacity1 <= capacity) {
            path1.push_back(current_node);
            last_visited_node1 = current_node;
            if (current_capacity2 <= capacity) {
                current_node = min_element(dist[current_node] + 1, dist[current_node] + N) - dist[current_node];
            } else {
                current_node = last_visited_node2;
                path1.push_back(0);
                total_distance += dist[last_visited_node1][0];
                current_capacity1 = 0;
            }
        } else if (current_capacity2 <= capacity) {
            path2.push_back(current_node);
            last_visited_node2 = current_node;
            current_node = min_element(dist[current_node] + 1, dist[current_node] + N) - dist[current_node];
            path2.push_back(0);
            total_distance += dist[last_visited_node2][0];
            current_capacity2 = 0;
        } else {
            break;
        }
        if (current_node == 0) {
            if (path1.size() > 1) {
                path1.push_back(0);
                total_distance += dist[last_visited_node1][0];
                current_capacity1 = 0;
            }
            if (path2.size() > 1) {
                path2.push_back(0);
                total_distance += dist[last_visited_node2][0];
                current_capacity2 = 0;
            }
            current_node = min_element(dist[0] + 1, dist[0] + N) - dist[0];
        }
        if (total_distance > max_distance) {
            break;
        }
    }

    // 输出结果
    cout << "Total distance: " << total_distance << endl;
    cout << "Path of vehicle 1: ";
    for (int i = 0; i < path1.size(); i++) {
        cout << path1[i] << " ";
    }
    cout << endl;
    cout << "Path of vehicle 2: ";
    for (int i = 0; i < path2.size(); i++) {
        cout << path2[i] << " ";
    }
    cout << endl;
}

int main() {
    solve_vrp();
    return 0;
}

需要注意的是，在这个代码中，我们假定节点的编号是从0到8，其中0为配送中心。同时，我们使用了欧几里得距离来计算节点之间的距离。这个距离可以根据具体情况进行修改。