Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

#include <iostream> #include <fstream> #include <vector> #include <string> #include…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    #include #include #include #include #include #include #include #include #include

    using namespace std;

    const int BASE = 26; const int POPULATION_SIZE = 500; // 种群大小 const int MAX_GENERATIONS = 1000; // 最大代数 const double MUTATION_RATE = 0.03; // 变异率

    random_device rd; mt19937 generator(rd());

    // 一个个体 struct Individual { vector keymap; // 染色体,字根布局 int fitness; // 个体的适应度

    Individual() : fitness(0) {}
    Individual(const vector<vector<int>>& cfb);
    void calc_fitness(const vector<vector<int>>& cfb);
    Individual mate(const Individual& partner) const;
    void mutate();
    

    };

    set extract_unique_numbers(const vector<vector>& cfb) { set unique_numbers; for (const auto& row : cfb) { unique_numbers.insert(row.begin(), row.end()); } return unique_numbers; }

    Individual::Individual(const vector<vector>& cfb) { set root = extract_unique_numbers(cfb); uniform_int_distribution distribution(1, BASE); keymap.resize(root.size()); for (size_t i = 0; i < keymap.size(); i++) { keymap[i] = distribution(generator); } calc_fitness(cfb); }

    inline void Individual::calc_fitness(const vector<vector>& cfb) { fitness = 0; vector duplication(BASE * BASE * BASE + BASE * BASE + BASE, false); for (const auto& zi : cfb) { int code = 0; for (int j = zi.size()-1; j >= 0; j--) { code = code * BASE + keymap[zi[j]]; // if (duplication[code] && j != 0) { // continue; // } else if(duplication[code]&&j==0){ // fitness++; // } else{ // duplication[code]=true; // break; // } } if (duplication[code]) { fitness--; } else{ duplication[code]=true; } } }

    Individual Individual::mate(const Individual& partner) const { Individual child; uniform_int_distribution distribution(0, 1); child.keymap.resize(keymap.size()); for (size_t i = 0; i < keymap.size(); i++) { child.keymap[i] = distribution(generator) ? keymap[i] : partner.keymap[i]; } return child; }

    void Individual::mutate() { uniform_real_distribution<> dis(0, 1); uniform_int_distribution<> key_dis(1, BASE); for (int& key : keymap) { if (dis(generator) < MUTATION_RATE) { key = key_dis(generator); } } }

    vector<vector> read_cfb(const string& filename) { vector<vector> cfb; ifstream file(filename);

    if (!file.is_open()) {
        cerr << "无法打开文件: " << filename << endl;
        return cfb;
    }
    
    string line;
    while (getline(file, line)) {
        vector<int> row;
        istringstream iss(line);
        string token;
        
        while (getline(iss, token, '\t')) {
            try {
                row.push_back(stoi(token));
            } catch (const invalid_argument& e) {
                cerr << "无法转换为整数: " << token << endl;
            } catch (const out_of_range& e) {
                cerr << "数字超出范围: " << token << endl;
            }
        }
        
        if (!row.empty()) {
            cfb.push_back(row);
        }
    }
    file.close();
    
    cout << "从 " << filename << " 读取了 " << cfb.size() << " 行数据。" << endl;
    
    return cfb;
    

    }

    // 主函数 int main() { string filename = "cfb.txt"; vector<vector> cfb = read_cfb(filename);

    // 初始化种群
    vector<Individual> population(POPULATION_SIZE, Individual(cfb));
    
    // 遗传算法主循环
    for (int generation = 0; /*generation < MAX_GENERATIONS*/; generation++) {
        // 计算适应度
        for (auto& individual : population) {
            individual.calc_fitness(cfb);
        }
    
        // 排序
        sort(population.begin(), population.end(), [](const Individual& a, const Individual& b) {
            return a.fitness > b.fitness;
        });
    
        // 输出当前最佳解
        cout << "第 " << generation << " 代,最佳适应度: " << -population[0].fitness << endl;
    
        // 创建新一代
        vector<Individual> new_population;
    
        // 精英保留
        new_population.push_back(population[0]);
        new_population.push_back(population[1]);
    
        // 生成新个体
        while (new_population.size() < POPULATION_SIZE) {
            // 选择父母
            uniform_int_distribution<> select(0, POPULATION_SIZE / 2 - 1);
            Individual parent1 = population[select(generator)];
            Individual parent2 = population[select(generator)];
    
            // 交叉
            Individual child = parent1.mate(parent2);
    
            // 变异
            child.mutate();
    
            new_population.push_back(child);
        }
    
        // 更新种群
        population = new_population;
    }
    
    // 输出最终结果
    population[0].calc_fitness(cfb);
    cout << "最终结果:单字重码数 " << -population[0].fitness << endl;
    cout << "最佳键位映射:";
    for (int key : population[0].keymap) {
        cout << key << " ";
    }
    cout << endl;
    
    return 0;
    

    }将代码改为遗传算法与退火算法相结合,并写上详细的注释

  2. Mistral Assistant

    遗传算法与模拟退火算法结合的优化程序

    下面是改进后的代码,结合了遗传算法和模拟退火算法,并添加了详细的注释:

    #include <iostream>
    #include <fstream>
    #include <vector>
    #include <string>
    #include <sstream>
    #include <set>
    #include <random>
    #include <algorithm>
    #include <ctime>
    #include <cmath>
    #include <limits>
    
    using namespace std;
    
    // 基础参数设置
    const int BASE = 26;  // 字母表大小
    const int POPULATION_SIZE = 500;  // 种群大小
    const int MAX_GENERATIONS = 1000;  // 最大遗传算法迭代代数
    const double MUTATION_RATE = 0.03;  // 变异率
    const double SA_INIT_TEMP = 1000.0;  // 模拟退火初始温度
    const double SA_COOLING_RATE = 0.95;  // 模拟退火冷却速率
    const int SA_ITERATIONS = 100;  // 每个温度下的模拟退火迭代次数
    
    // 随机数生成器
    random_device rd;
    mt19937 generator(rd());
    
    // 个体结构体
    struct Individual {
        vector<int> keymap; // 染色体,字根布局
        int fitness; // 个体的适应度(这里是负的重码数)
    
        Individual() : fitness(0) {}
        Individual(const vector<vector<int>>& cfb);
        void calc_fitness(const vector<vector<int>>& cfb);
        Individual mate(const Individual& partner) const;
        void mutate();
        void sa_optimize(const vector<vector<int>>& cfb); // 模拟退火优化
    };
    
    // 提取CFB文件中的唯一字根编号
    set<int> extract_unique_numbers(const vector<vector<int>>& cfb) {
        set<int> unique_numbers;
        for (const auto& row : cfb) {
            unique_numbers.insert(row.begin(), row.end());
        }
        return unique_numbers;
    }
    
    // 构造函数,初始化个体
    Individual::Individual(const vector<vector<int>>& cfb) {
        set<int> root = extract_unique_numbers(cfb);
        uniform_int_distribution<int> distribution(1, BASE);
        keymap.resize(root.size());
        for (size_t i = 0; i < keymap.size(); i++) {
            keymap[i] = distribution(generator);
        }
        calc_fitness(cfb);
    }
    
    // 计算个体适应度(负的重码数)
    void Individual::calc_fitness(const vector<vector<int>>& cfb) {
        fitness = 0;
        vector<bool> duplication(BASE * BASE * BASE + BASE * BASE + BASE, false);
    
        for (const auto& zi : cfb) {
            int code = 0;
            // 计算当前字的编码
            for (int j = zi.size()-1; j >= 0; j--) {
                code = code * BASE + keymap[zi[j]];
            }
            // 如果编码已经存在,增加重码数(适应度减少)
            if (duplication[code]) {
                fitness--;
            } else {
                duplication[code] = true;
            }
        }
    }
    
    // 交叉操作,生成子代
    Individual Individual::mate(const Individual& partner) const {
        Individual child;
        uniform_int_distribution<int> distribution(0, 1);
        child.keymap.resize(keymap.size());
        for (size_t i = 0; i < keymap.size(); i++) {
            // 随机选择父母的基因
            child.keymap[i] = distribution(generator) ? keymap[i] : partner.keymap[i];
        }
        return child;
    }
    
    // 变异操作
    void Individual::mutate() {
        uniform_real_distribution<> dis(0, 1);
        uniform_int_distribution<> key_dis(1, BASE);
        for (int& key : keymap) {
            if (dis(generator) < MUTATION_RATE) {
                key = key_dis(generator);
            }
        }
    }
    
    // 模拟退火优化
    void Individual::sa_optimize(const vector<vector<int>>& cfb) {
        double temperature = SA_INIT_TEMP;
        Individual current = *this;
        Individual best = *this;
    
        uniform_real_distribution<> dis(0, 1);
        uniform_int_distribution<> index_dis(0, keymap.size() - 1);
        uniform_int_distribution<> key_dis(1, BASE);
    
        while (temperature > 0.1) {
            for (int i = 0; i < SA_ITERATIONS; i++) {
                // 生成邻域解
                Individual neighbor = current;
                int index = index_dis(generator);
                neighbor.keymap[index] = key_dis(generator);
                neighbor.calc_fitness(cfb);
    
                // 计算能量差
                int delta = neighbor.fitness - current.fitness;
    
                // 判断是否接受新解
                if (delta > 0 || dis(generator) < exp(delta / temperature)) {
                    current = neighbor;
    
                    // 更新最佳解
                    if (current.fitness > best.fitness) {
                        best = current;
                    }
                }
            }
            // 降温
            temperature *= SA_COOLING_RATE;
        }
    
        // 将优化后的结果赋值回当前个体
        *this = best;
    }
    
    // 读取CFB文件
    vector<vector<int>> read_cfb(const string& filename) {
        vector<vector<int>> cfb;
        ifstream file(filename);
    
        if (!file.is_open()) {
            cerr << "无法打开文件: " << filename << endl;
            return cfb;
        }
    
        string line;
        while (getline(file, line)) {
            vector<int> row;
            istringstream iss(line);
            string token;
    
            while (getline(iss, token, '\t')) {
                try {
                    row.push_back(stoi(token));
                } catch (const invalid_argument& e) {
                    cerr << "无法转换为整数: " << token << endl;
                } catch (const out_of_range& e) {
                    cerr << "数字超出范围: " << token << endl;
                }
            }
    
            if (!row.empty()) {
                cfb.push_back(row);
            }
        }
        file.close();
    
        cout << "从 " << filename << " 读取了 " << cfb.size() << " 行数据。" << endl;
        return cfb;
    }
    
    // 主函数
    int main() {
        string filename = "cfb.txt";
        vector<vector<int>> cfb = read_cfb(filename);
    
        // 初始化种群
        vector<Individual> population(POPULATION_SIZE, Individual(cfb));
    
        // 遗传算法主循环
        for (int generation = 0; generation < MAX_GENERATIONS; generation++) {
            // 计算适应度
            for (auto& individual : population) {
                individual.calc_fitness(cfb);
            }
    
            // 排序种群(适应度从高到低)
            sort(population.begin(), population.end(), [](const Individual& a, const Individual& b) {
                return a.fitness > b.fitness;
            });
    
            // 输出当前最佳解
            cout << "第 " << generation << " 代,最佳适应度: " << -population[0].fitness << endl;
    
            // 创建新一代
            vector<Individual> new_population;
    
            // 精英保留(保留最好的个体)
            new_population.push_back(population[0]);
            new_population.push_back(population[1]);
    
            // 对精英个体进行模拟退火优化
            new_population[0].sa_optimize(cfb);
            new_population[1].sa_optimize(cfb);
    
            // 生成新个体
            while (new_population.size() < POPULATION_SIZE) {
                // 选择父母(使用轮盘赌选择)
                uniform_int_distribution<> select(0, POPULATION_SIZE / 2 - 1);
                Individual parent1 = population[select(generator)];
                Individual parent2 = population[select(generator)];
    
                // 交叉
                Individual child = parent1.mate(parent2);
    
                // 变异
                child.mutate();
    
                // 随机选择部分个体进行模拟退火优化
                if (dis(generator) < 0.1) {  // 10%的概率进行SA优化
                    child.sa_optimize(cfb);
                }
    
                new_population.push_back(child);
            }
    
            // 更新种群
            population = new_population;
        }
    
        // 对最终结果进行模拟退火优化
        population[0].sa_optimize(cfb);
    
        // 输出最终结果
        population[0].calc_fitness(cfb);
        cout << "最终结果:单字重码数 " << -population[0].fitness << endl;
        cout << "最佳键位映射:";
        for (int key : population[0].keymap) {
            cout << key << " ";
        }
        cout << endl;
    
        return 0;
    }
    

    代码说明

    1. 算法结合策略

    1. 遗传算法主体:保持了原有的遗传算法框架,包括种群初始化、选择、交叉和变异操作。
    2. 模拟退火优化:
      • 在遗传算法的每一代中,对精英个体进行模拟退火优化
      • 随机选择部分新生成的个体进行模拟退火优化
      • 在遗传算法结束后,对最终结果再次进行模拟退火优化

    2. 模拟退火算法实现

    在Individual类中添加了sa_optimize方法,实现了模拟退火算法:

    1. 初始化:设置初始温度、冷却速率和每个温度下的迭代次数
    2. 邻域生成:随机选择一个字根并随机改变其键位映射
    3. 接受准则:使用Metropolis准则决定是否接受新解
    4. 降温过程:逐渐降低温度,使算法从全局搜索转向局部优化

    3. 参数设置

    1. 模拟退火参数:

      • SA_INIT_TEMP:初始温度设为1000.0
      • SA_COOLING_RATE:冷却速率设为0.95
      • SA_ITERATIONS:每个温度下的迭代次数设为100
    2. 遗传算法参数:保持原有参数不变

    4. 优化策略

    1. 精英优化:对每一代的精英个体进行模拟退火优化
    2. 随机优化:以10%的概率对新生成的个体进行模拟退火优化
    3. 最终优化:在遗传算法结束后对最佳解再次进行模拟退火优化

    这种结合方式可以充分发挥遗传算法的全局搜索能力和模拟退火算法的局部优化能力,从而获得更好的优化结果。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.