基于分解的多目标进化算法中的局部搜索-LocalSeach

    因为在多目标进化算法中，进化到大约500代之后，（5个目标），下降的曲线趋于平缓，为了让曲线能否再进一步的下降，使用局部搜索进行对一些高覆盖小区进行分簇，然后选择最差的一个簇，进行重新规划这个簇，即初始化这个簇，产生一些的个体，然后评估这些个体，选取最好的一个个体，与当前精英进行比较，如果比当前精英效果好的话，就进行替换这个精英。这样就能继续让指标下降了。

  //循环每个子种群,找出每个子种群的簇

            for (int i = 0; i < subPopNum; i++)

            {

                //评估每个簇的适应度值,选出最差的那个簇的下标

                #region

                //1、首先求出这些簇中最大的所有目标的干扰

                double maxInterf = double.MinValue;

                int maxModfn = int.MinValue;

                int maxModfa3 = int.MinValue;

                int maxModfa6 = int.MinValue;

                double maxAdjInterf = double.MinValue;

                int maxfitnessindex=0;//求得对全网干扰最大的那个簇的下标

                double maxfitness = 0;//最大的干扰值

                   

                for (int j = 0; j < HighCoverClusters.Count(); j++)

                {

                    for (int k = 0; k < HighCoverClusters[j].Count; k++)

                    {

                        //计算单个小区给全网带来的影响,然后求和

                        List<double> interference = new List<double>();

                        List<int> modthreeFN = new List<int>();

                        List<int> modthreeFA = new List<int>();

                        List<int> modsixFA = new List<int>();

                        List<double> adjInterf = new List<double>();

                       //子目标适应度

                            double interf = getInterference(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            int modfn = getFNmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            int modfa = getFAmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            int modfa6 = getFAmodsix(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            double adjinterf;// = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            if (gSectorNum < smalldataThr)

                                adjinterf = getInterferenceAdjMod3(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            else

                                adjinterf = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                            if (maxInterf < interf)

                            {

                                maxInterf = interf;

                               // maxInterfIndex = HighCoverClusters[j][k];

                            }

                            if (maxModfn < modfn)

                            {

                                maxModfn = modfn;

                               // maxModIndex = HighCoverClusters[j][k];

                            }

                            if (maxModfa3 < modfa) maxModfa3 = modfa;

                            if (maxModfa6 < modfa6) maxModfa6 = modfa6;

                            if (maxAdjInterf < adjinterf) maxAdjInterf = adjinterf;

                        }

                    }

                //然后求出每个簇的干扰，去量纲的适应度值,求得最差的那个簇的下标，针对这个簇再进行初始化

                for (int j = 0; j < HighCoverClusters.Count(); j++)

                {

                    List<double> interference = new List<double>();

                    List<int> modthreeFN = new List<int>();

                    List<int> modthreeFA = new List<int>();

                    List<int> modsixFA = new List<int>();

                    List<double> adjInterf = new List<double>();

                    for (int k = 0; k < HighCoverClusters[j].Count; k++)

                    {

                        //计算单个小区给全网带来的影响,然后求和

                        //子目标适应度

                        double interf = getInterference(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        int modfn = getFNmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        int modfa = getFAmodthreeCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        int modfa6 = getFAmodsix(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        double adjinterf;// = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        if (gSectorNum < smalldataThr)

                            adjinterf = getInterferenceAdjMod3(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                        else

                            adjinterf = getC2ItopCount(population[i].gene[HighCoverClusters[j][k]], HighCoverClusters[j][k], population[i]);

                      

                       

                        interference.Add(interf);

                        modthreeFN.Add(modfn);

                        modthreeFA.Add(modfa);

                        modsixFA.Add(modfa6);

                        adjInterf.Add(adjinterf);

                    }

                    double tempfitness=0;

                    for (int k = 0; k < HighCoverClusters[j].Count; k++)

                    {

                        tempfitness += weightMatrix[i, 0] * interference[k] / maxInterf + weightMatrix[i, 1] * modthreeFN[k] / maxModfn + weightMatrix[i, 2] * modthreeFA[k] / maxModfa3 + weightMatrix[i, 3] * modsixFA[k] / maxModfa6 + weightMatrix[i, 4] * adjInterf[k]
/ maxAdjInterf;

                    }

                    if (j == 0)

                    {

                        maxfitness = tempfitness;

                        maxfitnessindex = j;

                    }

                    else

                    {

                        if (tempfitness > maxfitness)

                        {

                            maxfitness = tempfitness;

                            maxfitnessindex = j;

                        }

                    }

                }

                #endregion

                //最差的那个簇是maxfitnessindex,初始化，初始化------

                #region

                List<sortHelper> sortFlag = new List<sortHelper>();

                List<int> candidate;

                for (int j = 0; j < HighCoverClusters[maxfitnessindex].Count;j++)

                {

                    bool ret = false;

                    string celltype = sList.sectorList[HighCoverClusters[maxfitnessindex][j]].sectorType;

                    candidate = outdoor;

                    if (celltype == "INDOOR") candidate = indoor;

                    if (celltype == "SPECIAL") candidate = special;

                    ret = getUsablePCI(HighCoverClusters[maxfitnessindex][j], candidate, ancestor, out sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI);

                    sortFlag.Add(new sortHelper(HighCoverClusters[maxfitnessindex][j], sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI.Count));

                }

                sortFlag.Sort(SortRewrite.CompareUsablePCI);

                //初始化过程

                System.Diagnostics.Stopwatch Time = new System.Diagnostics.Stopwatch();

                Time.Start();

                Individual[] individuals = new Individual[subPopSize];

                for (int ii = 0; ii < individuals.Length; ii++)

                {

                    individuals[ii] = new Individual(sList.sectorList.Count, objectNum);

                    ancestors[i].clone(ref individuals[ii]);//这里出现过错误，是因为我用ancestor克隆的，不是ancestors[ii]

                }

                for (int indivIndex = 0; indivIndex < individuals.Length; indivIndex++)

                {

                    double r = rand.NextDouble();

                    if (r < 0.002)

                    {

                        List<pciSelection> usable = new List<pciSelection>();

                        for (int j = 0; j <= HighCoverClusters[maxfitnessindex].Count; j++)

                        {

                            usable.Clear();

                            for (int p = 0; p < sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI.Count; p++)

                                usable.Add(sList.sectorList[HighCoverClusters[maxfitnessindex][j]].UsablePCI[p]);

                            disSectorPCI(HighCoverClusters[maxfitnessindex][j], usable, ref individuals[indivIndex], i);

                        }

                    }

                    else

                    {

                        #region ；子段顺序为//逆；正；逆；正

                        if (indivIndex % 2 == 0)

                        {

                            List<pciSelection> usable = new List<pciSelection>();

                            for (int j = 0; j < sortFlag.Count / 4; j++)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count / 2; j >= sortFlag.Count / 4; j--)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count / 2 + 1; j <= sortFlag.Count * 3 / 4; j++)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count - 1; j > sortFlag.Count * 3 / 4; j--)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                        }

                        #endregion

                        #region ；子段顺序为//逆；正；逆；正

                        else

                        {

                            List<pciSelection> usable = new List<pciSelection>();

                            for (int j = sortFlag.Count / 4; j >= 0; j--)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count / 4 + 1; j < sortFlag.Count / 2; j++)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count * 3 / 4; j >= sortFlag.Count / 2; j--)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                            for (int j = sortFlag.Count * 3 / 4 + 1; j <= sortFlag.Count - 1; j++)

                            {

                                int curIndex = sortFlag[j].SectorIndex;

                                usable.Clear();

                                for (int p = 0; p < sList.sectorList[curIndex].UsablePCI.Count; p++)

                                    usable.Add(sList.sectorList[curIndex].UsablePCI[p]);

                                disSectorPCI(curIndex, usable, ref individuals[indivIndex], i);

                            }

                        }

                        #endregion

                    }

                    for (int k = 0; k < individuals[indivIndex].gene.Length; k++)

                    {

                        if (individuals[indivIndex].gene[k] == -1)

                            Console.WriteLine("在第" + indivIndex + "个个体中，第" + k + "个小区PCI分配失败");

                    }

                }

                Time.Stop();

                Console.WriteLine("局部搜索初始化,第{0}个种群 用时 {1}", i + 1, Time.Elapsed.TotalSeconds);

                #endregion

                //评估这subpopsize个个体，找到最好的，然后比较ancestor，是否替换该Ancestor

                #region

                double minfitness = 0;

                int minfitnessindex=0;

                 evaluate(ref individuals,0);//评估个体数组,**********这里出现了错误！！！！！！！！

                 for (int j = 0; j < individuals.Length; j++)

                {

                    double temp=0;

                    for(int ob=0;ob<objectNum;ob++)

                    {

                      temp += individuals[j].fitnessVec[ob]/individuals[j].fitnessVecOri[ob]*weightMatrix[i,ob];

                    }

                    if (j == 0)

                    {

                        minfitness = temp;

                        minfitnessindex=j;

                    }

                    else

                    {

                        if (minfitness > temp)

                        {

                            minfitness = temp;

                            minfitnessindex = j;

                        }

                    }

                }

               //计算ances的适应度值

                double ancestorfitness=0;

                   for(int ob=0;ob<objectNum;ob++)

                    {

                      ancestorfitness += ancestors[i].fitnessVec[ob]/ ancestors[i].fitnessVecOri[ob]*weightMatrix[i,ob];

                    }

                    //如果最小的适应度值比精英个体还要好，那么就替换掉ancestor[i]

                   if (minfitness < ancestorfitness)

                   {

                       individuals[minfitnessindex].clone(ref ancestors[i]);

                   }

                #endregion

            }//循环所有的子种群