|
- //#include "stdio.h"
- //#include "cmath"
- #include "time.h"
- constexpr auto PI = 3.141592;
- //#include "stdlib.h"
- #include <fstream>
- #include <string.h>
- #include <string>
- #include "wolvesAlgorithm.h"
- using namespace std;
- const int iniWolfPackNum = 400; //初始化狼群数量
- //initialParameter
- int exploreWolfPackNum = 209; //探狼数量--等同于游走次数
- int raidWolfPackNum = 190; //猛狼数量
- int captureWolfPackNum; //围捕狼群数量
- //int wolfCaptureRadius = 4; //狼围捕半径
- int wolfCaptureRadius = 1; //狼围捕半径
- int finalCaptureRadius = 2; //围捕时距离头狼的最终半径
- int recordPosition[3][25]; //用来记录猛狼与头狼之间没有重复的位置
- //int Kmax = 30; //迭代次数
- int Kmax = 50; //迭代次数
- //int Tmax = 20; //游走次数
- int Tmax = 40; //游走次数
- int stepa = 2; //游走步长
- int stepb = 1; //奔袭步长
- int stepc = 1; //围攻步长
- double updateIndex = 0.2; //更新比例因子
- int raidPosition[3][2]; //猛狼奔袭的位置 改了,原来是[5][2]
- int capturePosition[3][1]; //围捕狼围捕的位置 改了,原来是[5][1]
- int wolfPosition; //随机新的狼群位置
- int targetPosition; //随机目标
- int targetPositionStore[25]; //临时存贮随机的目标位置 改了,原来是18
- int headWolfPosition; //头狼位置
- int newWolfPackNum = 0; //记录变化的狼群数量
- double MaxGoalFunctionValue; //用于选出人工狼中目标函数最大的那匹人工狼
- int planNum = 2; //至少要派的planNum个艇
- int outWhile = 30; //用来处理不能跳出循环的数据
- int Area_proportion0 = 9;//每个任务区域需要多少个水下机器人
- int Area_proportion1 = 8;
- int Area_proportion2 = 8;
- //编队位置
- //存储艇的编号
- int ROBOTID[25];
- //int g_steps;
- //艇损坏重分配标志位
- int robotReduceFLAG;
- int robotReduceId;
-
- struct target
- {
- double Target_X; ///有用
- double Target_Y;///有用
- double mianji;///目标区域的面积
- };
- struct solution
- {
- int wolfPositionNum;
-
- int wolfPosition[25];
- };
- struct tagVERTEX
- {
- double x;
- double y;
- double z;
- double angle;
- int longcell;
- int shortcell;
- };
-
- struct RobotStatus
- {
-
-
- double Length, Width, High;
- struct tagVERTEX RobotPosition;
- double a2, a3;
- double h, vx, vy, vz;
- double fv, fvangle;
- double gx, gy;
- double pangle, acc, dcd;
- unsigned long FaultNum;
- };
- struct RobotMove
- {
- struct tagVERTEX MovePosition;
- double a2;
- double vx, vy, vz;
- int f;
- };
-
- struct RobotIndex ///主要用这个
- {
- int ID;
- double abilityValue;
- double dealThreatTndex;
- double vx;//姑且作为移动速度
- struct tagVERTEX RobotPosition;
- int robot_under_sea_number;
- };
-
- struct wolf
- {
- int WOLF[3][25]; //人工狼位置
- int wolfPositionNum[3]; //转置位置数量,即解中艇的数量
- int wolfPosition[3][25]; //转置位置
- double GoalFunctionValue; //目标函数值
- };
-
- struct wolf initialPack[500]; //初始化狼群
- struct wolf updatePack[500]; //更新狼群
- struct wolf wolfPack[1000]; //狼群数量
- struct wolf tempWolfPack[2]; //临时变量
- struct wolf raidWolfPack[200]; //奔袭狼群
- struct wolf raidWolfPackTemp[2]; //奔袭狼群
- struct wolf captureWolfPack[200]; //围捕狼群
- struct wolf captureWolfPackTemp[2];//围捕狼群
- struct solution optimalSolution[3]; //存储分配的解
- struct solution tempOptimalSolution[3];
- extern struct RobotPoint robotPoint[10];//没用
- extern struct CapturePoint distributePoint[3];
- extern struct RobotMove Move[25]; //没用
- extern struct RobotStatus Status[25];//没用
- //struct RobotIndex robotIndex[25]; //主要用这个
- struct RobotIndex robotIndex[25]; //主要用这个
- struct target tt[3];
- double GetDistance(double x1, double y1, double x2, double y2);
- struct wolf ceshi[2];//用来测试的狼群
-
- //extern double GetAngle(double x1, double y1, double x2, double y2); //角度计算公式
- //extern double DealAngle(double x); //将角度处理到(-PI~+PI)之间
- //extern double Sign(double x);
- //extern double Minimum(double x, double y); //用来返回最小值
- extern int g_steps;
- //计算目标函数值
- double GoalFunctionValue(struct wolf* array1, int n1, struct target* Target, int n2, struct RobotIndex* robotIndex, int RobotNum);
- //给狼群排序并输出目标函数值最大的那匹人工狼
- double wolfPackSort(struct wolf* array, int n);
- //曼哈顿距离计算公式
- int ManhattanDis(struct wolf* array1, struct wolf* array2, int n1, int n2, int RobotNum, int TargetNum);
- //初始化狼群
- void iniWolfPack(int RobotNum, struct target* Target, int TargetNum);
- //给狼群按照目标函数是否相等去重
- //void removeRepetition();
- //狼群算法核心函数
- void wolvesAlgorithm(struct RobotIndex* robotIndex, int RobotNum, struct target* Target, int TargetNum);
- double DDistance(double x1, double y1, double x2, double y2);
- //曼哈顿距离计算公式 //LY相当于是对比了两个狼(分配方案)的二维数组中值不一样的个数
- int ManhattanDis(struct wolf* array1, struct wolf* array2, int n1, int n2, int RobotNum, int TargetNum)
- {
- int temp = 0;
- int i, l;
- int disValue = 0;
- for (l = 0; l < TargetNum; l++)
- {
- for (i = 0; i < RobotNum; i++)
- {
- temp = array1[n1 - 1].WOLF[l][i] - array2[n2 - 1].WOLF[l][i];
- temp = fabs(temp);
- disValue += temp;
- }
- }
- return disValue;
- }
- //给狼群排序并输出目标函数值最大的那匹人工狼
- double wolfPackSort(struct wolf* array, int n)
- {
- struct wolf wolfPackTemp1[2];
- struct wolf wolfPackTemp2[2];
- int i, j;
- //按目标函数值从小到大冒泡排序排序狼群
- for (i = 0; i < n - 1; i++)
- {
- for (j = i + 1; j < n; j++)
- {
- if (array[i].GoalFunctionValue > array[j].GoalFunctionValue)
- {
- wolfPackTemp1[0] = array[j];
- wolfPackTemp2[0] = array[i];
- array[i] = wolfPackTemp1[0];
- array[j] = wolfPackTemp2[0];
- }
- }
- }
- return array[n - 1].GoalFunctionValue;
- }
- //计算目标函数值/////传入了第n1匹狼,所有的任务区域Target,任务区域的个数n2,无人艇的信息robotIndex,无人艇的个数RobotNum
- double GoalFunctionValue(struct wolf* array1, int n1, struct target* Target, int n2, struct RobotIndex* robotIndex, int RobotNum)
- {///////期望:输入一匹狼,输出他的适应度
- //goalFuntionParameter
- double w1 = 5000, w2 = 0.001;
- double goalFunctionValue = 0; //用于计算人工狼的目标函数值
- double X_r, Y_r, Z_r, V_r, ABILIT_Y;
- double X_t, Y_t, mianji_t; //一般用不到z
- double cur_distance, cur_time[3] = { 0,0,0 };
- int robot_under_sea_number[3] = { 0,0,0 };
- int robot_under_sea_cur = 0;//临时计数
- int robot_under_sea_number_want[3] = { Area_proportion0,Area_proportion1,Area_proportion2 };//我们所期待的每个区域有多少个水下机器人 //也可放在函数外部,便于更改与调试
- double robot_fit = 0.0; //作为水下机器人最终的一个综合评判指标,最终会与时间指标进行叠加作为最终的目标值goalFunctionValue
- double cur_ttime;
- double distance_all, time_all;
- double single_target_ablility[3] = { 0.0,0.0,0.0 };//执行第i个目标的所有无人艇的总探测能力(包括了行进速度和探测效率,具体为执行该任务的每个无人艇的速度*探测效率之和)
- distance_all = 0;
- int RobotID;
- time_all = 0;
- int i, j, k, l;///用作循环的变量
- for (i = 0; i < n2; i++) { //对于一个狼中的所有任务进行遍历
- cur_distance = 0; //对于每一个任务中的cur_distance 和 cur_time 进行初始化,计算完毕后加入到总消耗中
-
- for (k = 0; k < array1[n1 - 1].wolfPositionNum[i]; k++) {
- for (j = 0; j < RobotNum; j++)
- {
- if (array1[n1 - 1].wolfPosition[i][k] == robotIndex[j].ID) {//后期根据艇的编号可以进行更改,只要位置和能力对应上就可以
- //说明此时对于一个任务而言,需要第j个无人艇进行任务的执行,需要对代价进行更新(时间与距离(主要还是时间,将时间都记录下来,然后找出时间的最小值))
- //利用第j个无人艇和第i个任务的各种信息进行时间和距离的计算
- //获取无人艇的信息:位置坐标x,y,航行速度v,探测能力
- X_r = robotIndex[j].RobotPosition.x;
- Y_r = robotIndex[j].RobotPosition.y;
- V_r = robotIndex[j].vx;
- robot_under_sea_cur = robotIndex[j].robot_under_sea_number;
- ABILIT_Y = robotIndex[j].abilityValue;
- //获取任务点的信息,包括了任务的x,y的坐标,任务区域的面积mianji
- X_t = tt[i].Target_X;
- Y_t = tt[i].Target_Y;
- mianji_t = tt[i].mianji;
- //接下来进行代价的计算
- cur_distance = DDistance(X_r, Y_r, X_t, Y_t);
- cur_ttime = cur_distance / V_r;
- if (cur_time[i] == 0) {
- cur_time[i] = cur_ttime;
- }
- if (cur_time[i] < cur_ttime) {
- cur_time[i] = cur_ttime; //保证cur_ttime记录的是最长的时间
- }
- //针对于总探测效率进行一个计算
- single_target_ablility[i] = single_target_ablility[i] + V_r * ABILIT_Y;
- //printf("%f\n", single_target_ablility[i]);
- //进行水下机器人数量的计数
- robot_under_sea_number[i] = robot_under_sea_number[i] + robot_under_sea_cur;
- }
- }
- }
- //进行展示,查看是否有误
- //printf("%d\n", robot_under_sea_number[i]);
- }
- ///
-
-
-
-
- //进行水下机器人适应度的计算robot_fit
- for (int cur = 0; cur < n2; cur++) {
- robot_fit += abs(robot_under_sea_number[cur] - robot_under_sea_number_want[cur]);
- }
- if (robot_fit == 0) {
- robot_fit = 1;
- }
- else if (robot_fit == 1)
- {
- robot_fit = 0.75;
- }
- else {
- robot_fit = 1 / robot_fit;
- }
-
-
-
-
-
- ///////下述函数为了验证水下机器人函数计算是否正确
- //wolf cur_wolf;
- //cur_wolf = array1[n1 - 1];
- //for (j = 0; j < 3; j++) {
- // for (k = 0; k < cur_wolf.wolfPositionNum[j]; k++) {
- // printf("%d", cur_wolf.wolfPosition[j][k]);
- // printf(",");
- // //robot_under_sea_number[j] += robotIndex[cur_wolf.wolfPosition[j][k]].robot_under_sea_number;
- // }
- // printf("该任务区分配到的水下机器人的个数为:%d", robot_under_sea_number[j]);
- // printf("\n");
- //}
- //printf("%.2f\n", robot_fit);
- //printf("\n");
- //printf("\n");
-
-
-
- //对总时间进行计算,期望每个任务去往的时间分别最小,总时间相加也最小
- for (i = 0; i < n2; i++) {
- time_all = time_all + cur_time[i];
- }
- //打印single_target_ablility查看
- //for (int cur = 0; cur < 5; cur++) {
- // printf("%f", single_target_ablility[cur]);
- //}
-
-
- //printf("%f $$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", time_all);
- //计算每一个任务,需要分配的无人艇执行的时间,同样,将计算出的结果加入到总时间中
- double cur_mmianji;
- for (i = 0; i < n2; i++) {
- cur_mmianji = tt[i].mianji;
- time_all = time_all + (cur_mmianji / single_target_ablility[i]);
- //printf("%f ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", single_target_ablility[i]);
- }
- time_all = 1 / time_all;
-
- //我们希望时间越小越好,初步思路直接取倒数
-
- goalFunctionValue = w1 * time_all + w2 * robot_fit; //0.8~1.48左右
- //将新产生人工狼的目标函数保存起来
- array1[n1 - 1].GoalFunctionValue = goalFunctionValue;
- //printf("%f ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", goalFunctionValue);
- //return goalFunctionValue;
- return goalFunctionValue;
- }
-
-
- /*************初始化狼群************/
- void iniWolfPack(int RobotNum, struct target* Target, int TargetNum)
- {
- int l, i, j, k, g, h, m, n, p, q;
- newWolfPackNum = 0; //初始化
- for (i = 0; i < iniWolfPackNum; i++) //iniWolfPackNum,初始狼群的数量
- {
- int N1 = 0;
- for (l = 0; l < TargetNum; l++)
- {
- // 先随机一位转置位数,每个目标保证至少有2个艇的位置被转置。
- initialPack[i].wolfPositionNum[l] = rand() % (RobotNum - N1 - (TargetNum - l) * planNum + 1) + planNum; //去掉每位至少要派的两个艇,看还剩多少位可供转置///////不懂什么叫做“去掉每位至少要派的两个艇”
- N1 += initialPack[i].wolfPositionNum[l];
- //根据前面随机的位数继续随机出相应位数的随机数
- for (j = 0; j < initialPack[i].wolfPositionNum[l]; j++)
- {
- loop1:
- initialPack[i].wolfPosition[l][j] = rand() % RobotNum;
- for (g = 0; g < l + 1; g++) //检查目标中被转置的位
- {
- if (l == 0) //第一个目标
- {
- for (k = 0; k < j; k++)
- {
- if (initialPack[i].wolfPosition[l][j] == initialPack[i].wolfPosition[g][k])
- goto loop1; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- else //别的目标
- {
- if (l == g) //检查到最后一个目标
- {
- for (k = 0; k < j; k++)
- {
- if (initialPack[i].wolfPosition[l][j] == initialPack[i].wolfPosition[g][k])
- {
- goto loop1; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- }
- else
- {
- for (k = 0; k < initialPack[i].wolfPositionNum[g]; k++)
- {
- if (initialPack[i].wolfPosition[l][j] == initialPack[i].wolfPosition[g][k]) //xiao bug 0位问题
- goto loop1; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- }
- }
- }
- for (g = 0; g < RobotNum; g++)
- {
- for (h = 0; h < initialPack[i].wolfPositionNum[l]; h++) //转置为二进制编码
- {
- if (g == initialPack[i].wolfPosition[l][h])
- {
- initialPack[i].WOLF[l][g] = 1;
- break;
- }
- else
- initialPack[i].WOLF[l][g] = 0;
- }
- }
- }
- }
- /*FILE *fpDoc4;
- fpDoc4 = fopen("E:\\testWolf2.dat","a+");
- fprintf(fpDoc4,"Time:%d\n",g_steps);
- fprintf(fpDoc4,"测试一组狼群数据\n");
- for(p = 0;p < iniWolfPackNum;p++)
- {
- fprintf(fpDoc4,"编号%d\n",p);
- for(m = 0;m < TargetNum;m++)
- {
- for(q = 0;q < initialPack[p].wolfPositionNum[m];q++) //测试数据
- {
- fprintf(fpDoc4,"%d",initialPack[p].wolfPosition[m][q]);
- }
- fprintf(fpDoc4,"\n");
- for(q = 0;q < RobotNum;q++)
- {
- fprintf(fpDoc4,"%d",initialPack[p].WOLF[m][q]); //测试初始化狼群数据
- }
- fprintf(fpDoc4,"\n");
- }
- //fprintf(fpDoc4,"initialPack[%d].GoalFunctionValue = %lf\n",p,initialPack[p].GoalFunctionValue);
- }
- fprintf(fpDoc4,"\n");
- fclose(fpDoc4);*/
- /*************将初始化的狼群保存起来************/
- for (m = 0; m < iniWolfPackNum; m++)//iniWolfPackNum
- {
- wolfPack[m] = initialPack[m];
- //狼群数量加一
- newWolfPackNum += 1;
- GoalFunctionValue(wolfPack, newWolfPackNum, Target, TargetNum, robotIndex, RobotNum);
- }
- /*FILE *fpDoc5;
- fpDoc5 = fopen("E:\\testWolf3.dat","a+");
- fprintf(fpDoc5,"Time:%d\n",g_steps);
- fprintf(fpDoc5,"测试一组狼群数据\n");
- fprintf(fpDoc5,"TargetNum = %d\n",TargetNum);
- for(p = 0;p < newWolfPackNum;p++)
- {
- fprintf(fpDoc5,"编号%d\n",p);
- for(m = 0;m < TargetNum;m++)
- {
- for(q = 0;q < wolfPack[p].wolfPositionNum[m];q++) //测试数据
- {
- fprintf(fpDoc5,"%d",wolfPack[p].wolfPosition[m][q]);
- }
- fprintf(fpDoc5,"\n");
- for(q = 0;q < RobotNum;q++)
- {
- fprintf(fpDoc5,"%d",wolfPack[p].WOLF[m][q]); //测试初始化狼群数据
- }
- fprintf(fpDoc5,"\n");
- }
- fprintf(fpDoc5,"wolfPack[%d].GoalFunctionValue = %lf\n",p,wolfPack[p].GoalFunctionValue);
- }
- fprintf(fpDoc5,"\n");
- fprintf(fpDoc5,"狼群数量为%d\n",newWolfPackNum);
- fclose(fpDoc5); */
- }
- double GetDistance(double x1, double y1, double x2, double y2)
- {
- x1 = x1 / 3600;
- y1 = y1 / 3600;
- x2 = x2 / 3600;
- y2 = y2 / 3600;
- double dx = x1 - x2;
- double dy = y1 - y2;
- double d = sqrt((dx * 30.82) * (dx * 30.82) + (dy * cos(x1 / (3600 * 57.3)) * 30.82) * (dy * cos(x1 / (3600 * 57.3)) * 30.82));
- return 1000 * d;
- }
- double DDistance(double x1, double y1, double x2, double y2)
- {
- x1 = x1 / 3600;
- y1 = y1 / 3600;
- x2 = x2 / 3600;
- y2 = y2 / 3600;
- double dx = x1 - x2;
- double dy = y1 - y2;
- double d = sqrt((dx * 30.82) * (dx * 30.82) + (dy * cos(x1 / (3600 * 57.3)) * 30.82) * (dy * cos(x1 / (3600 * 57.3)) * 30.82));
- return 1000 * d;
- //double dx = x1 - x2;
- //double dy = y1 - y2;
- //double d = sqrt((dx) * (dx)+(dy) * (dy));
- //return d;
- }
-
-
- void init_obstcal(double* x, double* y, double* value, int number) {
- int i;
- for (i = 0; i < number; i++) {
- tt[i].Target_X = x[i];
- tt[i].Target_Y = y[i];
- tt[i].mianji = value[i];
- }
- }
-
- void init_robot(double* x, double* y, double* v, double* value, int* robot_under_sea, int number) {
- //printf("%d", a[0],"/n");
- //printf("%d", a[1], "/n");
- //printf("%d", a[2], "/n");
- //printf("%d", a[3], "/n");
- int i, j = 0;
- for (i = 0; i < 25; i++, j++) {
- if (j < number) {
- robotIndex[i].RobotPosition.x = x[i];
- robotIndex[i].RobotPosition.y = y[i];
- robotIndex[i].abilityValue = value[i];
- robotIndex[i].ID = i;
- robotIndex[i].vx = v[i];
- //iniRobotIndex[i] = robotIndex[i];
- //reRobotIndex[i] = robotIndex[i];
- robotIndex[i].robot_under_sea_number = robot_under_sea[i];
- }
- else {//将后续没有的无人艇也需要进行赋值,可以给予很小的速度和探测效率来使其默认不进行分配
- robotIndex[i].RobotPosition.x = 99999;
- robotIndex[i].RobotPosition.y = 99999;
- robotIndex[i].abilityValue = 0.00;
- robotIndex[i].ID = i;
- robotIndex[i].vx = 0.0000;
- //iniRobotIndex[i] = robotIndex[i];
- //reRobotIndex[i] = robotIndex[i];
- robotIndex[i].robot_under_sea_number = 0;
- }
-
- }
-
- }
- void show_all(int number1, int number2) {
- int i, j;
- printf("以下为无人艇的信息\n");
- for (i = 0; i < number1; i++) {
- printf("无人艇%d的坐标为(%.3f,%.3f),探测能力为:%.3f,携带水下机器人的个数为:%d,移动速度为:%.2f\n", robotIndex[i].ID, robotIndex[i].RobotPosition.x, robotIndex[i].RobotPosition.y, robotIndex[i].abilityValue, robotIndex[i].robot_under_sea_number, robotIndex[i].vx);
- }
- printf("\n\n以下为目标点的信息\n");
- for (i = 0; i < number2; i++) {
- printf("第%d个目标的坐标为(%.3f,%.3f),大小为:%.3f\n", i, tt[i].Target_X, tt[i].Target_Y, tt[i].mianji);
- }
- }
-
- void wolvesAlgorithm(struct RobotIndex* robotIndex, int RobotNum, struct target* Target, int TargetNum) {
- FILE* fpDoc2;
- //fpDoc2 = fopen("E:\\test\\testWolfTime.dat", "a+");
- double total_t, min_total_t;//记录用时
- //clock_t start_t, end_t;
- //clock_t temp_t;
- //start_t = clock();
- int time_flag = 0;
- int l, i, j, k, g, h, m, n, p, q;
- //临时存储艇的编号
- int robotID;
- //时间种子使每次随机数不同
- srand(time(0));
- //初始化狼群
- iniWolfPack(RobotNum, Target, TargetNum);
- //将人工狼按目标函数从小到大排序并输出最大的目标函数
- MaxGoalFunctionValue = wolfPackSort(wolfPack, newWolfPackNum);
- printf("初始化狼群完成,并进行排序");
- //记录头狼位置
- headWolfPosition = newWolfPackNum - 1;
- //初始化中出现最优解时,游走奔袭过程不产生最优解,即输出初始化的最优解。
- int initialSolution = 0;
- /**************游走-奔袭-围捕行为**************/
- for (l = 0; l < Kmax; l++) //设置最大迭代次数Kmax
- {
- double tempGoalFunValue;
- for (i = newWolfPackNum - 2; i > newWolfPackNum - 2 - exploreWolfPackNum; i--)
- {
- for (k = 0; k < Tmax; k++) //最大游走次数
- {
- /*********游走行为***********/
- int key = 0;//限定条件跳出循环
- int key2 = 0;
- while (key < stepa) //stepa游走步长
- {
- int key1 = 0; //每一轮循环之前重新置0
- tempWolfPack[0] = wolfPack[i];//产生新的人工狼tempWolfPack
- wolfPosition = rand() % RobotNum; //随机新的狼群转置位置 //随机选择一个无人艇(确定了y的坐标)
- targetPosition = rand() % TargetNum;
- if (tempWolfPack[0].WOLF[targetPosition][wolfPosition] == 1 && tempWolfPack[0].wolfPositionNum[targetPosition] > planNum) //LY 二进制矩阵的一个位置为1,并且他所对应的任务目前执行的无人艇超过了该任务需要的最低无人艇数量(1),即:保证有一个无人艇执行该任务即可,其他的都可以进行变化
- {
- tempWolfPack[0].WOLF[targetPosition][wolfPosition] = 0;
- for (j = 0; j < tempWolfPack[0].wolfPositionNum[targetPosition]; j++)
- {
- if (wolfPosition == tempWolfPack[0].wolfPosition[targetPosition][j])
- {
- for (g = j; g < tempWolfPack[0].wolfPositionNum[targetPosition]; g++)
- {
- tempWolfPack[0].wolfPosition[targetPosition][g] = tempWolfPack[0].wolfPosition[targetPosition][g + 1]; //移位????探索部分
- }
- }
- }
- tempWolfPack[0].wolfPositionNum[targetPosition] -= 1;
- key += 1;
- key2 = 1;
- }
- if (tempWolfPack[0].WOLF[targetPosition][wolfPosition] == 0 && key2 != 1) //如果被转至的位置为0,扫描其他目标对应位置是否为1,若是1,则转置为0;保证每个艇只能派给一个目标
- {
- for (j = 0; j < TargetNum; j++)
- {
- if (tempWolfPack[0].WOLF[j][wolfPosition] == 1 && tempWolfPack[0].wolfPositionNum[j] > planNum)
- {
- tempWolfPack[0].WOLF[j][wolfPosition] = 0;
- for (m = 0; m < tempWolfPack[0].wolfPositionNum[j]; m++)
- {
- if (wolfPosition == tempWolfPack[0].wolfPosition[j][m])
- {
- for (g = m; g < tempWolfPack[0].wolfPositionNum[j]; g++)
- {
- tempWolfPack[0].wolfPosition[j][g] = tempWolfPack[0].wolfPosition[j][g + 1];
- }
- }
- }
- tempWolfPack[0].wolfPositionNum[j] -= 1;
- }
- if (tempWolfPack[0].WOLF[j][wolfPosition] == 1 && tempWolfPack[0].wolfPositionNum[j] == planNum) //保证对于每个目标至少派两个艇 //planNum的值为1
- {
- key1 = 1;
- break;
- }
- }
- if (key1 != 1)
- {
- //printf("2222\n");
- tempWolfPack[0].WOLF[targetPosition][wolfPosition] = 1;
- int temp;
- tempWolfPack[0].wolfPositionNum[targetPosition] += 1; //把游走后产生的人工狼位置数量保存起来
- temp = tempWolfPack[0].wolfPositionNum[targetPosition];
- tempWolfPack[0].wolfPosition[targetPosition][temp - 1] = wolfPosition;
- key += 1;
- }
- }
- }
- //计算目标函数值GoalFunctionValue(tempWolfPack,1,Target,TargetNum,robotIndex,RobotNum);
- tempGoalFunValue = GoalFunctionValue(tempWolfPack, 1, Target, TargetNum, robotIndex, RobotNum);
- //printf("tempGoalFunValue = %lf\n",tempGoalFunValue);
- if (tempGoalFunValue > wolfPack[i].GoalFunctionValue)
- {
- //printf("11\n");
- wolfPack[i] = tempWolfPack[0];
- break; //如果游走到比原来位置好的位置停止游走
- }
- if (tempGoalFunValue > MaxGoalFunctionValue)
- {
- initialSolution = 1; //游走过程发现新优解
- }
- }
- }
- int circulKey = 1;
- /**********奔袭和围捕行为***********/
- while (circulKey != 0)
- {
- initialSolution = 1; //游走过程发现新优解
- circulKey = 0; //如果在奔袭或围捕过程中发现头狼,这个key用于跳出循环
- wolfPackSort(wolfPack, newWolfPackNum); //发现头狼,更新排序狼群
- //头狼发生改变,并发起召唤行为。
- MaxGoalFunctionValue = wolfPack[newWolfPackNum - 1].GoalFunctionValue;
- headWolfPosition = newWolfPackNum - 1; //记录头狼所在数组位置
- captureWolfPackNum = 0; //头狼放生改变,围捕的狼群随之改变。
- for (j = 0; j < raidWolfPackNum; j++) //头狼发生改变,猛狼狼群随之改变,把远离头狼的一部分人工狼变成猛狼。
- {
- raidWolfPack[j] = wolfPack[j];
- }
- /***********奔袭行为***********/
- //testnum = 0;
- for (j = 0; j < raidWolfPackNum; j++) //raidWolfPackNum
- {
- int dataFlag = 0; //用来处理不能跳出循环的数据
- while (1)
- {
- dataFlag++;
- int recordPositionNum[10]; //记录没有重复位置数量
- if (ManhattanDis(wolfPack, raidWolfPack, headWolfPosition + 1, j + 1, RobotNum, TargetNum) > wolfCaptureRadius) //奔袭至围捕半径内并加入围捕队列
- {
- //printf("******raidWolfPack***\n");
- for (k = 0; k < TargetNum; k++)
- {
- int index2 = 0;
- for (g = 0; g < RobotNum; g++) //找到每个目标的猛狼与头狼之间没有重叠的二进制位,即找到要奔袭的位置
- {
- if ((wolfPack[headWolfPosition].WOLF[k][g] == 0 && raidWolfPack[j].WOLF[k][g] == 1) || (wolfPack[headWolfPosition].WOLF[k][g] == 1 && raidWolfPack[j].WOLF[k][g] == 0))
- {
- recordPosition[k][index2++] = g; //LY 利用index2,实现了记录针对于每个任务,记录了那几个无人艇的分配方案不一样,而不是简单的0、1矩阵
- }
- }
- recordPositionNum[k] = index2; //记录每个目标要奔袭随机的位置数目
- }
- /*for(k = 0;k < targetNum;k++)
- {
- for(g = 0;g < recordPositionNum[k];g++)
- {
- printf("%d",recordPosition[k][g]);
- }
- printf("\n");
- printf("recordPositionNum[%d] = %d\n",k,recordPositionNum[k]);
- }*/
- for (k = 0; k < TargetNum; k++)//在要奔袭的位置中随机一位可能为0,去掉初始值默认为0的情况 //why?
- {
- raidPosition[k][0] = 10; //raidPosition[5][2]猛狼奔袭的位置
- }
- int raidKey = 0;
- int dataFlag2 = 0;
- int dataIndex1 = 0;
- while (raidKey < stepb)
- {
- dataFlag2++;
- if (dataFlag2 > outWhile) //LY 用来处理不能跳出循环的数据outWhile
- {
- dataIndex1 = 1;
- break;
- }
- //printf("111\n");
- int index3 = 0;
- int index4 = 0;
- raidKey = 0;//每次循环之前置0
- raidWolfPackTemp[0] = raidWolfPack[j];
- while (index4 < stepb) //在要奔袭的位置中随机stepb位向头狼奔袭 index4和stepb作比较是为了进行这么多次的随机选择坐标进行转置
- {
- wolfPosition = rand() % RobotNum; //随机新的狼群转置位置
- targetPosition = rand() % TargetNum; //随机目标
- for (k = 0; k < recordPositionNum[targetPosition]; k++)
- {
- if (wolfPosition == recordPosition[targetPosition][k] && index4 < stepb)
- {
- raidPosition[targetPosition][index4++] = wolfPosition;
- targetPositionStore[index3++] = targetPosition; //targetPositionStore临时存贮随机的目标位置
- }
- }
- }
- /*for(k = 0;k < index4;k++)
- {
- printf("raidPosition[%d][%d] = %d\n",targetPositionStore[k],k,raidPosition[targetPositionStore[k]][k]);
- }*/
- for (k = 0; k < stepb; k++) //转置猛狼要奔袭的二进制位,并把这匹猛狼其他信息改变以及重新计算目标函数并保存起来
- {
- int raidKey1 = 0; //每次循环之前都要置0;
- int raidPositionTemp;
- raidPositionTemp = raidPosition[targetPositionStore[k]][k];
- if (raidWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] == 1 && raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] > planNum)
- {
- raidWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] = 0;
- raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] -= 1; //对应的任务中的无人艇的数量减一
- for (h = 0; h < raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]]; h++)
- {
- if (raidPositionTemp == raidWolfPackTemp[0].wolfPosition[targetPositionStore[k]][h])
- {
- for (g = h; g < raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]]; g++)
- {
- raidWolfPackTemp[0].wolfPosition[targetPositionStore[k]][g] = raidWolfPackTemp[0].wolfPosition[targetPositionStore[k]][g + 1];
- }
- }
- }
- raidKey += 1;
- }
- else if (raidWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] == 1 && raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] == planNum)
- {
- break;
- }
- else
- {
- for (n = 0; n < TargetNum; n++)
- {
- if (raidWolfPackTemp[0].WOLF[n][raidPositionTemp] == 1 && raidWolfPackTemp[0].wolfPositionNum[n] > planNum)
- {
- raidWolfPackTemp[0].WOLF[n][raidPositionTemp] = 0;
- for (m = 0; m < raidWolfPackTemp[0].wolfPositionNum[n]; m++)
- {
- if (raidPositionTemp == raidWolfPackTemp[0].wolfPosition[n][m])
- {
- for (g = m; g < raidWolfPackTemp[0].wolfPositionNum[n]; g++)
- {
- raidWolfPackTemp[0].wolfPosition[n][g] = raidWolfPackTemp[0].wolfPosition[n][g + 1];
- }
- }
- }
- raidWolfPackTemp[0].wolfPositionNum[n] -= 1;
- }
- if (raidWolfPackTemp[0].WOLF[n][raidPositionTemp] == 1 && raidWolfPackTemp[0].wolfPositionNum[n] == planNum) //保证对于每个目标至少派两个艇
- {
- //printf("1111\n");
- raidKey1 = 1;
- break;
- }
- }
- if (raidKey1 != 1)
- {
- //printf("2222\n");
- int temp;
- raidWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] = 1;
- raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] += 1; //把游走后产生的人工狼位置数量保存起来 //为啥不是奔袭
- temp = raidWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]];
- raidWolfPackTemp[0].wolfPosition[targetPositionStore[k]][temp - 1] = raidPositionTemp;
- raidKey += 1;
- }
- }
- }
- }
- if (dataIndex1 != 1)
- {
- raidWolfPack[j] = raidWolfPackTemp[0]; //成功奔袭一次
- GoalFunctionValue(raidWolfPack, j + 1, Target, TargetNum, robotIndex, RobotNum); //奔袭过后从新计算目标函数
- }
- wolfPack[j] = raidWolfPack[j]; //将猛狼奔袭过程中产生的新解保存起来
-
- if (GoalFunctionValue(raidWolfPack, j + 1, Target, TargetNum, robotIndex, RobotNum) > MaxGoalFunctionValue)
- {
- //printf("奔袭过程\n");
- initialSolution = 1; //奔袭过程发现新优解
- circulKey = 1;//如果在奔袭或围捕过程中发现头狼,这个key用于跳出循环
- break;
- }
- }
- if (ManhattanDis(wolfPack, raidWolfPack, headWolfPosition + 1, j + 1, RobotNum, TargetNum) <= wolfCaptureRadius) //加入围捕队列
- {
- captureWolfPack[captureWolfPackNum++] = raidWolfPack[j];
- break;
- }
- if (dataFlag > outWhile) //dataFlag用来跳出循环
- {
- captureWolfPack[captureWolfPackNum++] = raidWolfPack[j];
- break;
- }
- }
- if (circulKey == 1) { //如果在奔袭或围捕过程中发现头狼,这个key用于跳出循环
- break;
- }
- }
- /***********围捕行为***********/
- if (circulKey != 1) //如果奔袭过程中出现新的头狼,则跳过围捕重新奔袭围捕。
- {
- for (j = 0; j < captureWolfPackNum; j++) //raidWolfPackNum
- {
- int dataFlag1 = 0;
- while (1)
- {
- dataFlag1++;
- int recordPositionNum[10]; //记录没有重复位置数量
- if (ManhattanDis(wolfPack, captureWolfPack, headWolfPosition + 1, j + 1, RobotNum, TargetNum) > finalCaptureRadius) //奔袭至围捕半径内并加入围捕队列
- {
- for (k = 0; k < TargetNum; k++)
- {
- int index2 = 0;
- for (g = 0; g < RobotNum; g++) //找到每个目标的捕狼与头狼之间没有重叠的二进制位,即找到要奔袭的位置
- {
- if ((wolfPack[headWolfPosition].WOLF[k][g] == 0 && captureWolfPack[j].WOLF[k][g] == 1) || (wolfPack[headWolfPosition].WOLF[k][g] == 1 && captureWolfPack[j].WOLF[k][g] == 0))
- {
- recordPosition[k][index2++] = g;
- }
- }
- recordPositionNum[k] = index2; //记录每个目标要围捕随机的位置数目
- }
- for (k = 0; k < TargetNum; k++)//在要围捕的位置中随机一位可能为0,去掉初始值默认为0的情况
- {
- capturePosition[k][0] = 10;
- }
- int captureKey = 0;
- int dataFlag3 = 0;
- int dataIndex2 = 0;
- while (captureKey < stepc)
- {
- dataFlag3++;
- if (dataFlag3 > outWhile)
- {
- dataIndex2 = 1;
- break;
- }
- //printf("222\n");
- int index3 = 0;
- int index4 = 0;
- captureKey = 0;//每次循环之前置0
- captureWolfPackTemp[0] = captureWolfPack[j];
- while (index4 < stepc) //在要围捕的位置中随机两位向头狼奔袭
- {
- wolfPosition = rand() % RobotNum; //随机新的狼群转置位置
- targetPosition = rand() % TargetNum; //随机目标
- for (k = 0; k < recordPositionNum[targetPosition]; k++)
- {
- if (wolfPosition == recordPosition[targetPosition][k] && index4 < stepc)
- {
- capturePosition[targetPosition][index4++] = wolfPosition;
- targetPositionStore[index3++] = targetPosition;
- }
- }
- }
- for (k = 0; k < stepc; k++) //转置猛狼要奔袭的二进制位,并把这匹猛狼其他信息改变以及重新计算目标函数并保存起来
- {
- int raidKey1 = 0; //每次循环之前都要置0;
- int raidPositionTemp;
- raidPositionTemp = capturePosition[targetPositionStore[k]][k];
- if (captureWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] == 1 && captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] > planNum)
- {
- captureWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] = 0;
- captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] -= 1;
- for (h = 0; h < captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]]; h++)
- {
- if (raidPositionTemp == captureWolfPackTemp[0].wolfPosition[targetPositionStore[k]][h])
- {
- for (g = h; g < captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]]; g++)
- {
- captureWolfPackTemp[0].wolfPosition[targetPositionStore[k]][g] = captureWolfPackTemp[0].wolfPosition[targetPositionStore[k]][g + 1];
- }
- }
- }
- captureKey += 1;
- }
- else if (captureWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] == 1 && captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] == planNum)
- {
- break;
- }
- else
- {
- for (n = 0; n < TargetNum; n++)
- {
- if (captureWolfPackTemp[0].WOLF[n][raidPositionTemp] == 1 && captureWolfPackTemp[0].wolfPositionNum[n] > planNum)
- {
- captureWolfPackTemp[0].WOLF[n][raidPositionTemp] = 0;
- for (m = 0; m < captureWolfPackTemp[0].wolfPositionNum[n]; m++)
- {
- if (raidPositionTemp == captureWolfPackTemp[0].wolfPosition[n][m])
- {
- for (g = m; g < captureWolfPackTemp[0].wolfPositionNum[n]; g++)
- {
- captureWolfPackTemp[0].wolfPosition[n][g] = captureWolfPackTemp[0].wolfPosition[n][g + 1];
- }
- }
- }
- captureWolfPackTemp[0].wolfPositionNum[n] -= 1;
- }
- if (captureWolfPackTemp[0].WOLF[n][raidPositionTemp] == 1 && captureWolfPackTemp[0].wolfPositionNum[n] == planNum) //保证对于每个目标至少派两个艇
- {
- //printf("1111\n");
- raidKey1 = 1;
- break;
- }
- }
- if (raidKey1 != 1)
- {
- //printf("2222\n");
- int temp;
- captureWolfPackTemp[0].WOLF[targetPositionStore[k]][raidPositionTemp] = 1;
- captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]] += 1; //把游走后产生的人工狼位置数量保存起来
- temp = captureWolfPackTemp[0].wolfPositionNum[targetPositionStore[k]];
- captureWolfPackTemp[0].wolfPosition[targetPositionStore[k]][temp - 1] = raidPositionTemp;
- captureKey += 1;
- }
- }
- }
- }
- if (dataIndex2 != 1)
- {
- captureWolfPack[j] = captureWolfPackTemp[0]; //成功奔袭一次
- GoalFunctionValue(captureWolfPack, j + 1, Target, TargetNum, robotIndex, RobotNum); //奔袭过后从新计算目标函数
- }
- wolfPack[j] = captureWolfPack[j]; //将猛狼奔袭过程中产生的新解保存起来
-
- if (GoalFunctionValue(captureWolfPack, j + 1, Target, TargetNum, robotIndex, RobotNum) > MaxGoalFunctionValue)
- {
- //printf("围捕过程\n");
- initialSolution = 1; //围捕过程发现新优解
- circulKey = 1;//如果在奔袭或围捕过程中发现头狼,这个key用于跳出循环
- break;
- }
- }
- else
- {
- break;
- }
- if (dataFlag1 > outWhile)
- {
- break;
- }
- }
- if (circulKey == 1) { //如果在奔袭或围捕过程中发现头狼,这个key用于跳出循环
- break;
- }
- }
- }
-
-
- }
- /////////////得改改无人艇的编号ROBOTID
- wolfPackSort(wolfPack, newWolfPackNum);
- for (p = 0; p < TargetNum; p++)
- {
- optimalSolution[p].wolfPositionNum = wolfPack[headWolfPosition].wolfPositionNum[p];
- optimalSolution[p].wolfPositionNum = wolfPack[headWolfPosition].wolfPositionNum[p]; //optimalSolution[5]---->记录每个艇分配到的任务数量
- tempOptimalSolution[p].wolfPositionNum = wolfPack[headWolfPosition].wolfPositionNum[p];
- for (h = 0; h < wolfPack[headWolfPosition].wolfPositionNum[p]; h++) //测试解的数量
- {
- robotID = ROBOTID[wolfPack[headWolfPosition].wolfPosition[p][h]];
- optimalSolution[p].wolfPosition[h] = robotID;
- tempOptimalSolution[p].wolfPosition[h] = robotID;
- }
- }
- //更新数据//////////////////////////////////////////////////////////////////////////////////////////////////////
- int updateData;
- updateData = floor(newWolfPackNum * updateIndex); //向下取整 //updateIndex更新比例因子
- for (i = 0; i < updateData; i++) //iniWolfPackNum
- {
- //printf("1111\n");
- int N1 = 0;
- for (m = 0; m < TargetNum; m++)
- {
- // 先随机一位转置位数,每个目标保证至少有planNum个艇的位置被转置。
- updatePack[i].wolfPositionNum[m] = rand() % (RobotNum - N1 - (TargetNum - m) * planNum + 1) + planNum; //去掉每位至少要派的两个艇,看还剩多少位可供转置
- N1 += updatePack[i].wolfPositionNum[m];
- //根据前面随机的位数继续随机出相应位数的随机数
- for (j = 0; j < updatePack[i].wolfPositionNum[m]; j++)
- {
- loop3:
- updatePack[i].wolfPosition[m][j] = rand() % RobotNum;
- for (g = 0; g < m + 1; g++) //检查目标中被转置的位
- {
- if (m == 0) //第一个目标
- {
- for (k = 0; k < j; k++)
- {
- if (updatePack[i].wolfPosition[m][j] == updatePack[i].wolfPosition[g][k])
- goto loop3; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- else //别的目标
- {
- if (m == g) //检查到最后一个目标
- {
- for (k = 0; k < j; k++)
- {
- if (updatePack[i].wolfPosition[m][j] == updatePack[i].wolfPosition[g][k])
- {
- goto loop3; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- }
- else
- {
- for (k = 0; k < updatePack[i].wolfPositionNum[g]; k++)
- {
- if (updatePack[i].wolfPosition[m][j] == updatePack[i].wolfPosition[g][k]) //xiao bug 0位问题
- goto loop3; //转置过的位置不能被重复转置,即生成一组不重复的随机数,
- }
- }
- }
- }
- }
- for (g = 0; g < RobotNum; g++)
- {
- for (h = 0; h < updatePack[i].wolfPositionNum[m]; h++) //转置为二进制编码
- {
- if (g == updatePack[i].wolfPosition[m][h])
- {
- updatePack[i].WOLF[m][g] = 1;
- break;
- }
- else
- updatePack[i].WOLF[m][g] = 0;
- }
- }
- }
- }
- for (i = 0; i < updateData; i++)
- {
- wolfPack[i] = updatePack[i];
- }
- if (wolfPack[headWolfPosition].GoalFunctionValue > 20.5 && time_flag == 0)
- {
- //temp_t = clock();
- time_flag = 1;
- }
-
-
-
-
-
-
- }
- if (initialSolution == 0)
- {
- //headWolfPosition = newWolfPackNum - 1; //记录头狼所在数组位置
- //保存最优解
- for (p = 0; p < TargetNum; p++)
- {
- optimalSolution[p].wolfPositionNum = wolfPack[headWolfPosition].wolfPositionNum[p];
- //tempOptimalSolution[p].wolfPositionNum = wolfPack[headWolfPosition].wolfPositionNum[p];
- for (h = 0; h < wolfPack[headWolfPosition].wolfPositionNum[p]; h++) //测试解的数量
- {
- robotID = ROBOTID[wolfPack[headWolfPosition].wolfPosition[p][h]];
- optimalSolution[p].wolfPosition[h] = robotID;
- //tempOptimalSolution[p].wolfPosition[h] = robotID;
- }
- }
- }
- //end_t = clock();
- //total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
- //min_total_t = (double)(temp_t - start_t) / CLOCKS_PER_SEC;
- //fprintf(fpDoc2, "total_t = %lf\n", total_t);
- //fprintf(fpDoc2, "min_total_t = %lf\n", min_total_t);
- //fclose(fpDoc2);
- //文件
-
- }
-
-
-
-
-
-
-
-
-
-
-
-
-
- void inti_ceshi1() {
-
- //101011000000110011
- //000100010001000000
- //000000100010000000
- //010000000100000000
- //000000001000000100
-
- printf("对狼群算法的评估算法进行测试\n");
- //利用ceshi[2]进行测试
-
- int cc;
- int l1[18] = { 1,0,1,0,1,1,0,0,0,0,0,0,1,1,0,0,1,1 };
- int l2[18] = { 0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0 };
- int l3[18] = { 0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0 };
- int l4[18] = { 0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 };
- int l5[18] = { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0 };
- for (cc = 0; cc < 18; cc++) {
- ceshi[0].WOLF[0][cc] = l1[cc];
- }
- for (cc = 0; cc < 18; cc++) {
- ceshi[0].WOLF[1][cc] = l2[cc];
- }
- for (cc = 0; cc < 18; cc++) {
- ceshi[0].WOLF[2][cc] = l3[cc];
- }
- for (cc = 0; cc < 18; cc++) {
- ceshi[0].WOLF[3][cc] = l4[cc];
- }
- for (cc = 0; cc < 18; cc++) {
- ceshi[0].WOLF[4][cc] = l5[cc];
- }
- ceshi[0].wolfPositionNum[0] = 8;
- ceshi[0].wolfPositionNum[1] = 3;
- ceshi[0].wolfPositionNum[2] = 2;
- ceshi[0].wolfPositionNum[3] = 2;
- ceshi[0].wolfPositionNum[4] = 2;
-
- int ll1[18];
- int cur = 0;
- for (cc = 0; cc < 18; cc++) {
- if (l1[cc] == 1) {
- ll1[cur] = cc;
- ceshi[0].wolfPosition[0][cur] = cc;
- cur += 1;
- }
- }
- ceshi[0].wolfPositionNum[0] = cur;
-
- int ll2[18];
- cur = 0;
- for (cc = 0; cc < 18; cc++) {
- if (l2[cc] == 1) {
- ll2[cur] = cc;
- ceshi[0].wolfPosition[1][cur] = cc;
- cur += 1;
- }
- }
- ceshi[0].wolfPositionNum[1] = cur;
-
- int ll3[18];
- cur = 0;
- for (cc = 0; cc < 18; cc++) {
- if (l3[cc] == 1) {
- ll3[cur] = cc;
- ceshi[0].wolfPosition[2][cur] = cc;
- cur += 1;
- }
- }
- ceshi[0].wolfPositionNum[2] = cur;
-
- int ll4[18];
- cur = 0;
- for (cc = 0; cc < 18; cc++) {
- if (l4[cc] == 1) {
- ll4[cur] = cc;
- ceshi[0].wolfPosition[3][cur] = cc;
- cur += 1;
- }
- }
- ceshi[0].wolfPositionNum[3] = cur;
-
- int ll5[18];
- cur = 0;
- for (cc = 0; cc < 18; cc++) {
- if (l5[cc] == 1) {
- ll5[cur] = cc;
- ceshi[0].wolfPosition[4][cur] = cc;
- cur += 1;
- }
- }
- ceshi[0].wolfPositionNum[4] = cur;
- double goal;
- goal = GoalFunctionValue(ceshi, 1, tt, 5, robotIndex, 18);
- printf("%f\n", goal);
- }
-
- void inti_ceshi2() {
- iniWolfPack(25, tt, 3); //默认只初始化了400只狼
- //以下代码用来查看狼群是否成功的初始化了
- int i, j, k;
- wolf cur_wolf;
- for (i = 0; i < iniWolfPackNum; i++) {
- printf("第%d匹狼的分配结果:\n", i);
- cur_wolf = wolfPack[i];
- for (j = 0; j < 3; j++) {
- for (k = 0; k < cur_wolf.wolfPositionNum[j]; k++) {
- printf("%d", cur_wolf.wolfPosition[j][k]);
- printf(",");
- }
- printf("\n");
- }
- printf("这匹狼的适应度为%.3f\n", cur_wolf.GoalFunctionValue);
- }
- }
- string iin(int i) {
- switch (i) {
- case 1:
- return "1";
- break;
- case 2:
- return "2";
- break;
- case 3:
- return "3";
- break;
- case 4:
- return "4";
- break;
- case 5:
- return "5";
- break;
- case 6:
- return "6";
- break;
- case 7:
- return "7";
- break;
- case 8:
- return "8";
- break;
- case 9:
- return "9";
- break;
- case 0:
- return "0";
- break;
- }
- }
- string change_int2char(int a) {
- if (a == 0) {
- return "0";
- }
- int b = 0, c = 0;
- b = a / 10;
- c = a % 10;
- string cur = "";
- cur += iin(b);
- cur += iin(c);
- return cur;
- }
- string inti_ceshi3(int* iid, int carft_number) {
- wolvesAlgorithm(robotIndex, 25, tt, 3);
- int i, j, k;
- //int robot_under_sea_number_cur;
- wolf cur_wolf;
- string cur;
- string re = "";
- for (i = 399; i < iniWolfPackNum; i++) {
- re = "";
- int robot_under_sea_number[3] = { 0,0,0 };
- printf("第%d匹狼的分配结果:\n", i);
- cur_wolf = wolfPack[i];
- for (j = 0; j < 3; j++) {
- for (k = 0; k < cur_wolf.wolfPositionNum[j]; k++) {
- if (cur_wolf.wolfPosition[j][k] < carft_number) {
- cur = change_int2char(iid[cur_wolf.wolfPosition[j][k]]);
- re += cur;
- re += ",";
- //if (k == cur_wolf.wolfPositionNum[j] - 1) {
-
- //}
- //else {
- // re += ",";
- //}
-
- }
- //printf("%s", re);
- printf("%d", cur_wolf.wolfPosition[j][k]);
- printf(",");
- robot_under_sea_number[j] += robotIndex[cur_wolf.wolfPosition[j][k]].robot_under_sea_number;
- }
- re += "#";
- //re += ",";
- printf("该任务区分配到的水下机器人的个数为:%d", robot_under_sea_number[j]);
- printf("\n");
- }
-
- printf("这匹狼的适应度为%.3f\n", cur_wolf.GoalFunctionValue);
- }
- //printf("re的长度为:%d\n", re.size());
- string result = "";
- for (int j = 0; j < re.size(); j++) {
- result += re[j];
- //printf("%c", re[j]);
- }
- return result;
- }
- void save_ting(int number) {
- //经过这个操作,data.txt文件里面的内容会清零
- //ofstream outfile("无人艇状态信息.txt", ios::trunc);
- ofstream outfile("无人艇状态信息.txt", ios::trunc);
- int i;
- for (i = 0; i < number; i++) {
- /*robotIndex[i].RobotPosition.x = x[i];
- robotIndex[i].RobotPosition.y = y[i];
- robotIndex[i].abilityValue = value[i];
- robotIndex[i].ID = i;
- robotIndex[i].vx = v[i];*/
- outfile << robotIndex[i].RobotPosition.x << " " << robotIndex[i].RobotPosition.y << "\n";
- }
- //outfile << "i:" << " " << "start_row: " << "\n";
- //outfile << "j:" << " " << "start_col: " << "\n";
- outfile.close();
- }
- void save_phere() {
- ofstream outfile("任务区域状态信息.txt", ios::trunc);
- int i;
- for (i = 0; i < 3; i++) {
- //tt[i].Target_X = x[i];
- //tt[i].Target_Y = y[i];
- //tt[i].mianji = value[i];
- outfile << tt[i].Target_X << " " << tt[i].Target_Y << "\n";
- }
- //outfile << "i:" << " " << "start_row: " << "\n";
- //outfile << "j:" << " " << "start_col: " << "\n";
- outfile.close();
- }
- void save_way(int number) {
- ofstream outfile("分配结果.txt", ios::trunc);
- int i, j, k;
- for (j = 0; j < 3; j++) {
- for (k = 0; k < wolfPack[399].wolfPositionNum[j]; k++) {
- if (wolfPack[399].wolfPosition[j][k] < number) {
- outfile << wolfPack[399].wolfPosition[j][k] << " ";
- }
-
- }
- outfile << "\n";
- }
-
- //outfile << "i:" << " " << "start_row: " << "\n";
- //outfile << "j:" << " " << "start_col: " << "\n";
- outfile.close();
- }
- void INIT_robot(double* x1, double* y1, double* v1, double* xiaolv1, int* robot_under_sea, int carft_len) {
- //double x[25] = { 0,100,200,300,400,500,600,700,800,3000,3100,3200,3300,3400,3500,3600,3700,6000,6100,6200,6300,6400,6500,6600,6700 };
- //double y[25] = { 1,2,1,2,1,2,1,2,1,2,3,3,3,3,3,3,3,3,5,5,5,5,5,5,5 };
- //double v[25] = { 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15 };
- ////double xiaolv[25] = { 1,2,2,1.2,1.5,1.6,2.3,1,2.4,3.1,1,1,2,3,4,2,2,3,4,3,4,2,4,5,4};
- //double xiaolv[25] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 };
- init_robot(x1, y1, v1, xiaolv1, robot_under_sea, carft_len); //对无人艇进行初始化
- }
- void INIT_renwu(double* x1, double* y1, double* value1) {
- //double x1[3] = { 300,3300,6300 };
- //double y1[3] = { 3000,3000,3000 };
- ////double mianji[5] = { 40,40,50,60,50 };
- //double mianji[3] = { 4000,4000,5000 };
- init_obstcal(x1, y1, value1, 3);
- }
- string init(double* ROBOT_x, double* ROBOT_y, double* ROBOT_v, double* ROBOT_xiaolv, int* craft_robot_under_sea, double* TASK_x, double* TASK_y, double* TASK_value, int* iid, int craft_len, int task_len, int* Area_proportion) {
- //craft_len,task_len分别为无人艇的数量和任务的数量
- Area_proportion0 = Area_proportion[0];
- Area_proportion1 = Area_proportion[1];
- Area_proportion2 = Area_proportion[2];
- INIT_robot(ROBOT_x, ROBOT_y, ROBOT_v, ROBOT_xiaolv, craft_robot_under_sea, craft_len);
- INIT_renwu(TASK_x, TASK_y, TASK_value);
- show_all(25, 3);
- //inti_ceshi1();
- //inti_ceshi2();
- string reult;
- reult = inti_ceshi3(iid, craft_len);
- save_ting(craft_len);
- save_phere();
- save_way(craft_len);
- return reult;
- }
|