A. 遗传算法求最短路径
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#include<string>
using namespace std;
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define INFINITY 200//最大值
#define MAX_VERTEX_NUM 20//最大顶点个数
typedef char VertexType;//定义为char类型
//以下是全局变量,用于保存弗洛伊德算法的路径和长度
int D[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//记录最短路径长度
int P[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];//记录最短路径标记
//以下是全局变量,用于保存迪杰斯特拉算法的路径和长度
int Distance[MAX_VERTEX_NUM];
VertexType former[MAX_VERTEX_NUM];//终点的前一个顶点
bool final[MAX_VERTEX_NUM];//记录顶点是否在V-S中
typedef struct ArcCell
{
int adj; //顶点关系类型
int weight; //该弧相关信息的指针,在此记录为权值
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
VertexType vexs[MAX_VERTEX_NUM]; //顶点向量
AdjMatrix arcs; //邻接矩阵
int vexnum; //顶点数
int arcnum; //弧数
}MGraph;
void InitialMGraph(MGraph &G)//初始化
{
G.arcnum=G.vexnum=0; //初始化边数跟顶点数都为零
for(int i=0;i<MAX_VERTEX_NUM;i++)
for(int j=0;j<MAX_VERTEX_NUM;j++)
{
if(i==j)
G.arcs[i][j].weight=0;
else
G.arcs[i][j].weight=INFINITY; //初始化为200,以200认为是无穷大
}
}
void InsertVex(MGraph &G,VertexType v)//插入顶点
{
if(G.vexnum<=MAX_VERTEX_NUM)
G.vexs[G.vexnum++]=v;
}
void InsertArc(MGraph &G,VertexType v1,VertexType v2)//插入边
{
int m,n;
G.arcnum++;
for(int k=0;k<G.vexnum;k++)
{
if(G.vexs[k]==v1)
m=k;
if(G.vexs[k]==v2)
n=k;
}
//插入
ArcCell A;
cout<<"请输入权值:";
cin>>A.weight;
G.arcs[m][n].weight=A.weight;
}
//迪杰斯特拉最短路径,假设始点就存储在数组中的第一个
void ShortestPath_DIJ(MGraph G,int v0)
{
//初始化距离
for(int v=0;v<G.vexnum;++v)
{
final[v]=false;
Distance[v]=G.arcs[v0][v].weight;
if(Distance[v]<INFINITY&&Distance[v]!=0)
{
former[v]=G.vexs[v0];
}
else
former[v]='#';
}
final[v0]=true;
former[v0]=G.vexs[v0];
for(int i=1;i<G.vexnum;++i)//剩余的G.vexnum-1个顶点
{
int w;
int min=INFINITY;
int v=-1;
for(w=0;w<G.vexnum;++w)
{
if(!final[w]&&Distance[w]<min)
{
v=w;
min=Distance[w];
}
}
if(v!=-1)
{
final[v]=true;//将离顶点V0最近的顶点v加入S集合中
for(w=0;w<G.vexnum;++w)//更新当前的最短路径及距离
{
if(!final[w]&&(min+G.arcs[v][w].weight<Distance[w])&&G.arcs[v][w].weight<INFINITY)
{
Distance[w]=min+G.arcs[v][w].weight;
former[w]=G.vexs[v];
}
}
}
}
}
//输出迪杰斯特拉中的最短路径
void output_ShortestPath_DIJ(MGraph G,int v0)
{
int i;
for(i=1;i<G.vexnum;i++)
{
cout<<G.vexs[v0]<<"->"<<G.vexs[i]<<":";
if(Distance[i]!=INFINITY)
{
cout<<"最短路径长度为:"<<Distance[i]<<" 最短路径的前一个顶点为:"<<former[i];
cout<<endl;
}
else
cout<<"此两顶点之间不存在路径"<<endl;
}
}
//弗洛伊德最短路径
void shortestPath_FLOYD(MGraph G)
{
for(int v=0;v<G.vexnum;++v)
{
for(int w=0;w<G.vexnum;++w)
{
D[v][w]=G.arcs[v][w].weight;
for (int k=0;k< G.vexnum;k++)
P[v][w][k]=-1;
if(D[v][w]<INFINITY) //从v到w有直接路径
P[v][w][v]=w;
}
}
for(int k=0;k<G.vexnum;++k)
{
for(int v=0;v<G.vexnum;v++)
for(int w=0;w<G.vexnum;++w)
if(D[v][w]>D[v][k]+D[k][w])
{
D[v][w]=D[v][k]+D[k][w];
for(int i=0;i<G.vexnum;i++)
{
if(P[v][k][i]!=-1)//原来存了顶点
P[v][w][i]=P[v][k][i];
else
P[v][w][i]=P[k][w][i];
}
}
}
}
//输出弗洛伊德中的最短路径
void output_shortestPath_FLOYD(MGraph G)
{
for(int i=0;i<G.vexnum;++i)
{
for(int j=0;j<G.vexnum;++j)
{
if(i!=j)//自己不能到达自己
{
cout<<G.vexs[i]<<"->"<<G.vexs[j]<<":";
if(D[i][j]==INFINITY)
{
cout<<"此两顶点之间不存在路径"<<endl;
}
else
{
cout<<"最短路径长度为:"<<" "<<D[i][j]<<" ";
cout<<"最短路径为:";
cout<<G.vexs[i];
for(int k=i;k!=-1;k=P[i][j][k])
{
if(k!=i)
cout<<G.vexs[k];
}
cout<<endl;
}
}
}
}
}
int main()
{
int num1;//顶点个数
int num2;//弧个数
cout<<"请输入顶点个数:";
cin>>num1;
cout<<"请输入弧个数:";
cin>>num2;
VertexType v;
MGraph G;
InitialMGraph(G);
cout<<"请输入顶点的信息:"<<endl;
for(int i=0;i<num1;++i)
{
cin>>v;;
InsertVex(G,v);
}
VertexType v1,v2;
for(int j=0;j<num2;++j)
{
cout<<"请输入两个结点数据来表示的边:";
cin>>v1>>v2;
InsertArc(G,v1,v2);
}
ShortestPath_DIJ(G,0);
cout<<"迪杰斯特拉中的最短路径如下:"<<endl;
output_ShortestPath_DIJ(G,0);
cout<<endl<<endl;
shortestPath_FLOYD(G);
cout<<"弗洛伊德中的最短路径如下:"<<endl;
output_shortestPath_FLOYD(G);
return 0;
}
B. 基于遗传算法，解决TSP问题中双点交叉C语言程序怎么编写
解决TSP问题的交叉方法不像其他的那么简单，跟它的编码方法有关系。如果是顺序编码，那么交叉时要考虑到子代个体是否是合法的。一般用顺序交叉方法的比较多。参考资料中为单点交叉方法的代码，两点交叉与之类似，不过是多了一点交叉点而已。
C. 求遗传算法（GA）C语言代码
.----来个例子，大家好理解..--
基于遗传算法的人工生命模拟
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
#include<math.h>
#include<time.h>
#include<string.h>
#include "graph.c"
/* 宏定义 */
#define TL1 20 /* 植物性食物限制时间 */
#define TL2 5 /* 动物性食物限制时间 */
#define NEWFOODS 3 /* 植物性食物每代生成数目 */
#define MUTATION 0.05 /* 变异概率 */
#define G_LENGTH 32 /* 个体染色体长度 */
#define MAX_POP 100 /* 个体总数的最大值 */
#define MAX_FOOD 100 /* 食物总数的最大值 */
#define MAX_WX 60 /* 虚拟环境的长度最大值 */
#define MAX_WY 32 /* 虚拟环境的宽度最大值 */
#define SX1 330 /* 虚拟环境图左上角点x坐标 */
#define SY1 40 /* 虚拟环境图左上角点y坐标 */
#define GX 360 /* 个体数进化图形窗口的左上角点X坐标 */
#define GY 257 /* 个体数进化图形窗口的左上角点Y坐标 */
#define GXR 250 /* 个体数进化图形窗口的长度 */
#define GYR 100 /* 个体数进化图形窗口的宽度 */
#define GSTEP 2 /* 个体数进化图形窗口的X方向步长 */
#define R_LIFE 0.05 /* 初期产生生物数的环境比率 */
#define R_FOOD 0.02 /* 初期产生食物数的环境比率 */
#define SL_MIN 10 /* 个体寿命最小值 */
/* 全局变量 */
unsigned char gene[MAX_POP][G_LENGTH]; /* 遗传基因 */
unsigned char iflg[MAX_POP]; /* 个体死活状态标志变量 */
D. 如图，如何用这个PSO算法或遗传算法来求函数极值,用C语言编写代码
需要很多的子函数 %子程序：新物种交叉操作，函数名称存储为crossover.m function scro=crossover(population,seln,pc); BitLength=size(population,2); pcc=IfCroIfMut(pc);%根据交叉概率决定是否进行交叉操作，1则是，0则否 if pcc==1 chb=round(rand*(BitLength-2))+1;%在[1，BitLength-1]范围内随机产生一个交叉位 scro(1,:)=[population(seln(1),1:chb) population(seln(2),chb+1:BitLength)] scro(2,:)=[population(seln(2),1:chb) population(seln(1),chb+1:BitLength)] else scro(1,:)=population(seln(1),:); scro(2,:)=population(seln(2),:); end %子程序：计算适应度函数，函数名称存储为fitnessfun.m function [Fitvalue,cumsump]=fitnessfun(population); global BitLength global boundsbegin global boundsend popsize=size(population,1);%有popsize个个体 for i=1:popsize x=transform2to10(population(i,:));%将二进制转换为十进制 %转化为[-2，2]区间的实数 xx=boundsbegin+x*(boundsend-boundsbegin)/(power(2,BitLength)-1); Fitvalue(i)=targetfun(xx);%计算函数值，即适应度 end %给适...
望采纳！
E. 遗传算法改进的模糊C-均值聚类MATLAB源码范例
function [BESTX,BESTY,ALLX,ALLY]=GAFCM(K,N,Pm,LB,UB,D,c,m)
%% 此函数实现遗传算法，用于模糊C－均值聚类
%% 输入参数列表
% K 迭代次数
% N 种群规模，要求是偶数
% Pm 变异概率
% LB 决策变量的下界，M×1的向量
% UB 决策变量的上界，M×1的向量
% D 原始样本数据，n×p的矩阵
% c 分类个数
% m 模糊C均值聚类数学模型中的指数
%% 输出参数列表
% BESTX K×1细胞结构，每一个元素是M×1向量，记录每一代的最优个体
% BESTY K×1矩阵，记录每一代的最优个体的评价函数值
% ALLX K×1细胞结构，每一个元素是M×N矩阵，记录全部个体
% ALLY K×N矩阵，记录全部个体的评价函数值
%% 第一步：
M=length(LB);%决策变量的个数
%种群初始化，每一列是一个样本
farm=zeros(M,N);
for i=1:M
x=unifrnd(LB(i),UB(i),1,N);
farm(i,:)=x;
end
%输出变量初始化
ALLX=cell(K,1);%细胞结构，每一个元素是M×N矩阵，记录每一代的个体
ALLY=zeros(K,N);%K×N矩阵，记录每一代评价函数值
BESTX=cell(K,1);%细胞结构，每一个元素是M×1向量，记录每一代的最优个体
BESTY=zeros(K,1);%K×1矩阵，记录每一代的最优个体的评价函数值
k=1;%迭代计数器初始化
%% 第二步：迭代过程
while k<=K
%% 以下是交叉过程
newfarm=zeros(M,2*N);
Ser=randperm(N);%两两随机配对的配对表
A=farm(:,Ser(1));
B=farm(:,Ser(2));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];%产生子代a
b=[B(1:P0,:);A((P0+1):end,:)];%产生子代b
newfarm(:,2*N-1)=a;%加入子代种群
newfarm(:,2*N)=b;???
for i=1:(N-1)
A=farm(:,Ser(i));
B=farm(:,Ser(i+1));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];
b=[B(1:P0,:);A((P0+1):end,:)];
newfarm(:,2*i-1)=a;
newfarm(:,2*i)=b;
end
FARM=[farm,newfarm];
%% 选择复制
SER=randperm(3*N);
FITNESS=zeros(1,3*N);
fitness=zeros(1,N);
for i=1:(3*N)
Beta=FARM(:,i);
FITNESS(i)=FIT(Beta,D,c,m);
end
for i=1:N
f1=FITNESS(SER(3*i-2));
f2=FITNESS(SER(3*i-1));
f3=FITNESS(SER(3*i));
if f1<=f2&&f1<=f3
farm(:,i)=FARM(:,SER(3*i-2));
fitness(:,i)=FITNESS(:,SER(3*i-2));
elseif f2<=f1&&f2<=f3
farm(:,i)=FARM(:,SER(3*i-1));
fitness(:,i)=FITNESS(:,SER(3*i-1));
else
farm(:,i)=FARM(:,SER(3*i));
fitness(:,i)=FITNESS(:,SER(3*i));
end
end
%% 记录最佳个体和收敛曲线
X=farm;
Y=fitness;
ALLX{k}=X;
ALLY(k,:)=Y;
minY=min(Y);
pos=find(Y==minY);
BESTX{k}=X(:,pos(1));
BESTY(k)=minY;???
%% 变异
for i=1:N
if Pm>rand&&pos(1)~=i
AA=farm(:,i);
BB=GaussMutation(AA,LB,UB);
farm(:,i)=BB;
end
end
disp(k);
k=k+1;
end
%% 绘图
BESTY2=BESTY;
BESTX2=BESTX;
for k=1:K
TempY=BESTY(1:k);
minTempY=min(TempY);
posY=find(TempY==minTempY);
BESTY2(k)=minTempY;
BESTX2{k}=BESTX{posY(1)};
end
BESTY=BESTY2;
BESTX=BESTX2;
plot(BESTY,'-ko','MarkerEdgeColor','k','MarkerFaceColor','k','MarkerSize',2)
ylabel('函数值')
xlabel('迭代次数')
grid on
忘记写了，这个是源代码！谢谢谢谢！