C++聚类算法中的动态聚类中心调整

在C++中实现动态聚类中心调整，我们可以使用K-means算法。K-means是一种非常流行的聚类算法，它通过迭代地更新聚类中心来最小化每个数据点到其所属聚类中心的距离之和。下面是一个简单的C++实现，展示了如何在每次迭代中更新聚类中心：

#include <iostream>
#include <vector>
#include <cmath>
#include <random>

// 计算两点之间的距离
double distance(const std::vector<double>& a, const std::vector<double>& b) {
    double sum = 0;
    for (size_t i = 0; i < a.size(); ++i) {
        sum += pow(a[i] - b[i], 2);
    }
    return sqrt(sum);
}

// K-means算法
void kMeans(std::vector<std::vector<double>>& data, int k, int maxIterations) {
    // 随机初始化聚类中心
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0, 1);
    std::vector<std::vector<double>> centroids(k);
    for (int i = 0; i < k; ++i) {
        centroids[i] = data[dis(gen)];
    }

    // 迭代更新聚类中心
    for (int iter = 0; iter < maxIterations; ++iter) {
        std::vector<int> clusters(data.size(), -1);
        std::vector<std::vector<double>> newCentroids(k, std::vector<double>(data[0].size(), 0));

        // 将数据点分配到最近的聚类中心
        for (size_t i = 0; i < data.size(); ++i) {
            double minDist = DBL_MAX;
            int closestCluster = -1;
            for (int j = 0; j < k; ++j) {
                double dist = distance(data[i], centroids[j]);
                if (dist < minDist) {
                    minDist = dist;
                    closestCluster = j;
                }
            }
            clusters[i] = closestCluster;
            newCentroids[closestCluster] += data[i];
        }

        // 更新聚类中心
        for (int j = 0; j < k; ++j) {
            double sum = 0;
            for (size_t i = 0; i < data.size(); ++i) {
                if (clusters[i] == j) {
                    sum += data[i][0]; // 假设数据只有一个特征
                }
            }
            newCentroids[j][0] /= clusters[j].size(); // 假设数据只有一个特征
        }

        // 检查聚类中心是否收敛
        bool converged = true;
        for (int j = 0; j < k; ++j) {
            if (distance(centroids[j], newCentroids[j]) > 1e-6) {
                converged = false;
                break;
            }
        }

        if (converged) {
            centroids = newCentroids;
            break;
        }
    }
}

int main() {
    std::vector<std::vector<double>> data = {{1, 2}, {1, 4}, {1, 0},
                                            {10, 2}, {10, 4}, {10, 0}};
    int k = 2; // 聚类数
    int maxIterations = 100; // 最大迭代次数

    kMeans(data, k, maxIterations);

    // 输出聚类结果
    for (int i = 0; i < data.size(); ++i) {
        std::cout << "Data point "<< i << " belongs to cluster " << clusters[i] << std::endl;
    }

    return 0;
}

在这个示例中，我们首先随机初始化聚类中心，然后在每次迭代中将数据点分配到最近的聚类中心，并更新聚类中心。我们使用了一个简单的收敛条件，即聚类中心之间的距离变化小于一个很小的阈值（例如1e-6）。当聚类中心不再发生变化时，算法收敛。