C++聚類算法與遺傳算法的結合

C++聚類算法與遺傳算法的結合是一個有趣且具有挑戰性的研究課題。聚類算法用于將數據分組，而遺傳算法則用于優化問題求解。將這兩種算法結合，可以在聚類過程中尋找最優解。

以下是一個簡單的C++示例，展示了如何將K-means聚類算法與遺傳算法結合：

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

// K-means聚類算法
void kmeans(std::vector<std::vector<double>>& data, int k, std::vector<std::vector<double>>& centroids) {
    int n = data.size();
    std::vector<int> labels(n, -1);
    std::vector<std::vector<double>> centroids_new(k, std::vector<double>(data[0].size(), 0));

    // 初始化質心
    for (int i = 0; i < k; ++i) {
        centroids_new[i] = data[rand() % n];
    }

    // 迭代過程
    bool converged = false;
    while (!converged) {
        converged = true;

        // 計算每個點到質心的距離并更新標簽
        for (int i = 0; i < n; ++i) {
            double min_dist = std::numeric_limits<double>::max();
            int min_idx = -1;
            for (int j = 0; j < k; ++j) {
                double dist = 0;
                for (int d = 0; d < data[i].size(); ++d) {
                    dist += pow(data[i][d] - centroids_new[j][d], 2);
                }
                if (dist < min_dist) {
                    min_dist = dist;
                    min_idx = j;
                }
            }
            labels[i] = min_idx;

            // 更新質心
            for (int d = 0; d < data[i].size(); ++d) {
                centroids_new[min_idx][d] += data[i][d];
            }
            centroids_new[min_idx][d] /= n;
        }

        // 檢查質心是否收斂
        for (int i = 0; i < k; ++i) {
            bool is_converged = true;
            for (int j = i + 1; j < k; ++j) {
                if (std::linalg::norm(centroids_new[i] - centroids_new[j]) > 1e-6) {
                    is_converged = false;
                    break;
                }
            }
            if (!is_converged) {
                converged = false;
                break;
            }
        }

        // 更新質心
        centroids = centroids_new;
    }
}

// 遺傳算法
std::vector<int> genetic_algorithm(std::vector<std::vector<double>>& data, int k, int population_size, int max_generations) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, k - 1);

    // 初始化種群
    std::vector<std::vector<int>> population(population_size, std::vector<int>(data[0].size(), -1));
    for (int i = 0; i < population_size; ++i) {
        for (int j = 0; j < data[0].size(); ++j) {
            population[i][j] = dis(gen);
        }
    }

    // 迭代過程
    for (int gen = 0; gen < max_generations; ++gen) {
        // 計算適應度
        std::vector<int> fitness(population_size, 0);
        for (int i = 0; i < population_size; ++i) {
            fitness[i] = 0;
            for (int j = 0; j < data.size(); ++j) {
                double min_dist = std::numeric_limits<double>::max();
                int min_idx = -1;
                for (int l = 0; l < k; ++l) {
                    double dist = 0;
                    for (int d = 0; d < data[j].size(); ++d) {
                        dist += pow(data[j][d] - population[i][d], 2);
                    }
                    if (dist < min_dist) {
                        min_dist = dist;
                        min_idx = l;
                    }
                }
                fitness[i] += min_dist;
            }
        }

        // 選擇
        std::vector<int> selected;
        std::vector<double> fitness_sum(population_size, 0);
        for (int i = 0; i < population_size; ++i) {
            double rand_val = static_cast<double>(rand()) / RAND_MAX;
            double cumulative_fitness = 0;
            for (int j = 0; j < population_size; ++j) {
                cumulative_fitness += fitness[j];
                if (rand_val < cumulative_fitness) {
                    selected.push_back(j);
                    break;
                }
            }
        }

        // 交叉
        std::vector<std::vector<int>> offspring(population_size, std::vector<int>(data[0].size(), -1));
        for (size_t i = 0; i < selected.size(); i += 2) {
            int parent1 = selected[i];
            int parent2 = selected[i + 1];
            for (int j = 0; j < data[0].size(); ++j) {
                if (rand() % 2 == 0) {
                    offspring[i][j] = parent1[j];
                } else {
                    offspring[i][j] = parent2[j];
                }
            }
        }

        // 變異
        for (size_t i = 0; i < offspring.size(); ++i) {
            int idx = rand() % data[0].size();
            offspring[i][idx] = dis(gen);
        }

        // 更新種群
        population = offspring;
    }

    // 返回最優解
    int best_idx = 0;
    double min_fitness = fitness[0];
    for (int i = 1; i < population_size; ++i) {
        if (fitness[i] < min_fitness) {
            min_fitness = fitness[i];
            best_idx = i;
        }
    }

    return population[best_idx];
}

int main() {
    std::vector<std::vector<double>> data = {{1, 2}, {1, 4}, {1, 0}, {10, 2}, {10, 4}, {10, 0}};
    int k = 2;
    int population_size = 10;
    int max_generations = 50;

    std::vector<std::vector<double>> centroids = genetic_algorithm(data, k, population_size, max_generations);
    kmeans(data, k, centroids);

    std::cout << "質心: ";
    for (const auto& centroid : centroids) {
        std::cout << "(" << centroid[0] << ", " << centroid[1] << ") ";
    }
    std::cout << std::endl;

    return 0;
}

這個示例中，我們首先使用遺傳算法找到一組初始質心，然后將這些質心作為K-means算法的輸入。K-means算法會迭代地更新質心和標簽，直到收斂。最后，我們輸出找到的最優質心。