求大佬，遗传算法c语言实现，麻烦给详细注释
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <map>
#include <vector>
using namespace std;
const int N=1e6+5;
typedef pair <int,int> P;
int F[N],w[N];
int getf(int x)
{
if(x==F[x])
return x;
return F[x]=getf(F[x]);
}
int main(){
int i,T,n,m,t,q;
scanf("%d",&T);
priority_queue<P, vector<P>, greater<P> > Q;
while(T--)
{
while(!Q.empty())
Q.pop();
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
{
scanf("%d",&w[i]);
F[i]=i;
Q.push(P(w[i],i));
}
int now=0;
for(i=1;i<=m;i++)
{
scanf("%d%d",&t,&q);
for(now;now<t;now++)
{
P s1=Q.top();
Q.pop();
P s2=Q.top();
Q.pop();
P s3=P(s1.first+s2.first,min(s1.second,s2.second));
Q.push(s3);
int p1=getf(s1.second);
int p2=getf(s2.second);
if(p1<p2)
F[p2]=p1;
else
F[p1]=p2;
}
printf("%d\n",getf(q));
}
}
return 0;
}
第一次操作后。第1、2袋稀的泥在第1组中，第3袋稀的泥在第3组中，第4袋稀的泥在第4组中，第5袋稀的泥在第5组中。
第二次操作后。第1、2、3袋稀的泥在第1组中，第4袋稀的泥在第4组中，第5袋稀的泥在第5组中。
第三次操作后。第1、2、3袋稀的泥在第1组中，第4、5袋稀的泥在第4组中。
第四次操作后。第1、2、3、4、5袋稀的泥在第1组中。
代码没啥好注释的，都很容易理解的代码。
这个不是遗传算法啊
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
int dp[1001],w[1001],v[1001];
int main(){
int T;
scanf("%d",&T);
while(T--){
memset(dp,0,sizeof(dp));
int n,V,i,j,max1=0,maxpos=0;
scanf("%d%d",&n,&V);
for(i=1;i<=n;i++)
scanf("%d",&w[i]);
for(i=1;i<=n;i++)
scanf("%d",&v[i]);
dp[v[1]]=w[1];
for(i=2;i<=n;i++)
for(j=V;j>=v[i];j--)
if(j==v[i]||dp[j-v[i]])
dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
for(i=V;i>0;i--)
if(dp[i]>max1){
max1=dp[i];
maxpos=i;
}
printf("%d %d\n",max1,maxpos);
}
return 0;
}
一样的题目：https://www.cnblogs.com/87hbteo/p/8946578.html
大哥，这是动态规划
基本的遗传算法以初始种群为起点，经过自然选择、交叉和突变操作生成新的种群，经过反复更新种群直到寻找到最优解。其计算步骤如下：
编码：将问题空间转换为遗传空间；
生成初始种群：随机生成P个染色体；
种群适应度计算：按照确定的适应度函数，计算各个染色体的适应度；
选择：根据染色体适应度，按照选择算子进行染色体的选择；
交叉：按照交叉概率对被选择的染色体进行交叉操作，形成下一代种群；
突变：按照突变概率对下一代种群中的个体进行突变操作；
返回第3步继续迭代，直到满足终止条件。
小弟学识浅薄。。。好高深的东西
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctime>
#include <math.h>
#define N 30000000000
#define PI 3.14159265
#define MIN_(a,b) ((a)<(b)?(b):(a))//定义求最大值函数MIN_(a,b)
#define SIZE 50
#define MAXGEN 50
#define P_CORSS 0.75
#define P_MUTATION 0.05
#define LEN 22
typedef struct node//定义结构体，表示染色体，x是染色体二进制编码，fitness是该染色体的适应值，fitsum是当前所有染色体的适应值的总和
{
char x[LEN];
double fitness, fitsum;
}node;
node cur[SIZE], next[SIZE], max, min;//定义结构体数组，有当前染色体种群，下一代染色体种群，以及最优和最差染色体。
double randd()
{
return (double)rand() / RAND_MAX;//产生0-1之间随机数， RAND_MAX其值至少为32767，rand()在0-MAX之间
}
int randi(int k)
{
return (int)(randd()*k);//返回接近0-k之间的随机值
}
//计算当前种群中各个个体的适应度
void cal_fitness()
{
int i, j, k;
double d;
for (i = 0; i<SIZE; i++)
{
k = 0;
for (j = LEN - 1; j >= 0; j--) k = (k << 1) + cur[i].x[j];;//该循环用于将染色体二进制数转成十进制，<<是左移运算，x[j]是染色体i的第j位
d = (double)k / N;//用上面的k产生一个浮点数d，作为函数自变量x的值
cur[i].fitness = 7 * cos(4* d); //计算每个染色体的适应值 ////////////////////////////函数y= 7*cos(4*x)//////////////////////////////////
cur[i].fitsum = i>0 ? (cur[i].fitness + cur[i - 1].fitsum) : (cur[0].fitness);//计算所有适应值的总和，里面有迭代过程，就是若i=3,则cur[3].fitsum=cur[3].fitsum+cur[2].fitsum+cur[1].fitsum+cur[0].fitsum.
}
}
void init()//初始化染色体种群，共SIZE个，每个都是二进制LEN长度的串
{
int tmp;
for (int i = 0; i<SIZE; i++)
{
tmp = randi(N);//用randi函数产生一个大概N那么大的随机数
for (int j = 0; j<LEN; j++)
{
cur[i].x[j] = tmp % 2;//用temp对2取余，初始化每个染色体的每个位，共LEN位;一个数不是奇数就是偶数，对2取余得0或1，从而产生像001001010...11010001这样的串
tmp = tmp >> 1;//右移tmp，就是将temp缩小，使tmp值变化
}
}
cal_fitness();//计算当前种群各个个体的适应度
}
int sel()//选择种群中某个染色体
{
double p = randd();
double sum = cur[SIZE - 1].fitsum;//全部染色体的适应值总和
for (int i = 0; i<SIZE; i++)
{
if (cur[i].fitsum / sum>p) return i;//如果当前适应总值/全部总值大于随机数p，也就是当前适应总值不为0，不太差时，返回这个i值，循环停止
}
}
//换代
void tran()
{
int i, j, pos;
//找当前种群最优个体
max = cur[0];
for (i = 1; i<SIZE - 1; i++)
{
if (cur[i].fitness>max.fitness) max = cur[i];//记录种群中的最优染色体为max
}
for (int k = 0; k<SIZE; k += 2)
{
//选择交叉个体
i = sel();//用sel函数挑选一个个体，染色体号为i
j = sel();//同上，再选择个个体，号为j
//选择交叉位置
pos = randi(LEN - 1);//随机产生个LEN-1左右的数pos，如18,19,21等
//交叉
if (randd()<P_CORSS)//如果randd()产生的随机数(在0-1之间）小于设定的交叉率P_CORSS
{
memcpy(next[k].x, cur[i].x, pos);//提取染色体i的前pos位赋给下一代种群next的第k个染色体.——函数memcpy（&a,&b,n)用于从&b的位置开始数n个长度的数据拷贝赋给&a;
memcpy(next[k].x + pos, cur[j].x + pos, LEN - pos);//提取染色体j的 后面LEN-pos位赋给next的第k个染色体,结合上面，从而拼成一个新的染色体
memcpy(next[k + 1].x, cur[j].x, pos);//同样的方式给next的第k+1染色体赋值，这回换过来生成这个值，即提取j的前pos位数据 + i的后LEN-pos位数据
memcpy(next[k + 1].x + pos, cur[i].x + pos, LEN - pos);
}
else//否则不交叉，
{
memcpy(next[k].x, cur[i].x, LEN);
memcpy(next[k + 1].x, cur[j].x, LEN);
}
//变异
if (randd()<P_MUTATION)//如果一随机数小于设定的变异率P_MUTATION，则执行变异操作
{
pos = randi(LEN - 1);//仍然是从中间找个位置，执行变异
next[k].x[pos] ^= next[k].x[pos];// ^=按位异或后赋值函数，相同为0不同为1，此处是将第pos位上的值（不论是0或1）定为0
pos = randi(LEN - 1);
next[k + 1].x[pos] ^= next[k + 1].x[pos];//同样将下一代next的第k+1个染色体的第pos位也变为0；？？最好应该是0变1,1变0...,但这样也行，进化稍慢点
}
}
//找下一代的最差个体
min = next[0], j = 0;
for (i = 1; i<SIZE - 1; i++)
{
if (next[i].fitness<min.fitness) min = next[i], j = i;//用j记录最差染色体号
}
//用上一代的最优个体替换下一代的最差个体
next[j] = max;
memcpy(cur, next, sizeof(cur));//把整个改良过的（经过交叉，变异，替换等操作的）next代的值赋给当前种群cur，供下一次循环优化
cal_fitness();
}
//打印个体适应度和二进制编码
void print(node tmp)
{
printf("%.6lf", tmp.fitness);
for (int i = 0; i<LEN; i++) printf(" %d", tmp.x[i]);
printf("\n");
}
//打印种群
void printcur()
{
for (int i = 0; i<SIZE; i++) print(cur[i]);
}
void GA()
{
int cnt = 0;
double ans;
while (cnt++<MAXGEN)//当计数值cnt小于设定的最大进化次数MAXGEN，执行换代操作
{
tran();
// printf("%.6lf\n",max.fitness);
// printcur();
}
ans = cur[0].fitness;
for (int i = 1; i<SIZE; i++) ans = MIN_(ans, cur[i].fitness);//找出函数最小值，打印输出（应设定的是求函数最小值）
printf("%.6lf\n", ans);
}
int main()
{
srand((unsigned)time(NULL));//初始化随机数种子产生器，为使程序中每次的rand()函数产生的随机数不一样
init();//初始化种群
GA();//遗传换代操作
system("pause"); //输出结果在屏幕，而不是一闪而过
return 0;
}
你这答的不是我问的