精华内容
下载资源
问答
  • 双层规划模型

    2014-05-20 20:29:03
    双层规划模型在供应链选址中的应用_高国飞
  • 双层规划模型模型03版-双层规划模型模型03版.doc 第一次传的是10版本的,这个是03版本的。。。谢谢了
  • 双层规划模型的遗传算法求解的Matlab源码-双层规划模型的遗传算法求解的Matlab源码.doc 非常实用,值得一看
  • 当团队人数大于航线上任一航班的剩余...文中提出利用双层规划模型对团队旅客进行拆团,使得航空公司在增加收益的同时又不会失去旅行代理商。最后,设计了双层迭代算法求解模型,并结合实例验证了模型和算法的有效性。
  • 论文研究-水资源优化配置的双层规划模型.pdf, 采用双层规划模型来描述水资源优化配置问题.根据用水者在水市场上的行为特征,建立了以水资源社会总效益以及各用水者效益...
  • 论文研究-排污权市场交易的双层规划模型.pdf, 应用双层规划研究了排污权管理部门如何利用初始排污权分配和排污权费对排污权市场进行有效的宏观调控,以实现排污权的优化...
  • 论文研究-求解双层规划模型的粒子群优化算法 .pdf,
  • 考虑服务水平、产品价格、沟通便利性和距离对客户效用的影响以及服务水平和产品价格之间的关系, 建立动态竞争环境下, 以企业为领导者、以竞争者为跟随者的物流配送中心双层规划模型, 以带精英策略的快速 非支配排序...
  • 论文研究-含有模糊变量双层规划模型的混合智能算法.pdf,
  • 论文研究-区域公交时刻表及车辆调度双层规划模型 .pdf,
  • 论文研究-一种多损失条件风险值的双层规划模型及应用.pdf, 在两级供应链中制造商与零售商之间的多产品定价与订购问题, 是一个多损失的双层风险决策问题, 可以建立双层...
  • 论文研究-动态公交网络设计的双层规划模型及算法研究 .pdf,
  • 论文研究-城市公交系统连续平衡网络设计的双层规划模型及求解算法.pdf, 根据城市公交网络的具体特点 ,对公交网络进行了系统的描述 ,提出一个双层规划模型来描述连续平衡...
  • 论文研究-基于双层规划模型的制造业选址布局优化方法研究.pdf, 经济全球化趋势和全球多式联运网络的形成推动了资源的自由流通和优化配置, 改变了制造产业的空间分布形态...
  • 建立了双层规划模型,其中上层模型为上层交通主管部门以社会总成本最小为目标建设机场运输通道,下层模型为旅客以效用最大化为目标选择运输通道,设计了基于敏感性分析的模拟退火算法,最后通过算例仿真了算法的可行...
  • 论文研究-模式间相互影响时估计O-D需求的双层规划模型及求解算法.pdf, 考虑各种交通模式间的相互影响 ,利用多模式均衡配流的变分不等式模型 ,建立了拥挤条件下多模式 O-...
  • 城市交通网络设计问题中双层规划模型_方法及应用_高自友
  • 在物流服务供应链体系下,针对功能型物流服务供应商的选择问题,提出了使用双层规划模型分析方法。上层规划以集成物流服务供应商的外包业务成本最低为目标,下层规划以客户服务满意度最大为目标。其中,在下层规划中...
  • 论文研究-城市道路单行系统布局优化的双层规划模型和混合算法.pdf, 研究了基于出行者路径选择行为的单行道布局优化问题.借助于双层规划思想,以最小化研究区域内的总旅行...
  • 为了促使供应商在降低产品成本的同时,提高服务质量,提出了利用双层规划建立供应商选择模型。上层规划以制造企业的采购费用最小为目标,下层以选择的供应商的服务质量最大为目标。其中,下层规划中供应商的服务质量...
  • 构建了一个以上层物流成本最低、下层物流时间最短为目标的双层规划模型,并设计了一种混合禁忌搜索遗传算法(HTSGA,hybrid tabu search genetic algorithm)求解模型,解决了灾后应急物流的运输路径优化问题。...
  • 基于环境容量和交通容量,建立了一个双层多目标规划模型描述城市快速道路网的污染控制与匝道控制,并考虑了用户的路径选择行为.设计了基于改进遗传算法的启发式求解算法,该算法借助不可微精确罚函数将约束问题转化为...
  • 针对非常规突发事件中应急资源布局问题,在受灾点需求不确定和应急救援过程分为多个阶段的情景下,建立了省市两级应急储备仓库定位和物资配置的鲁棒双层规划模型。运用相对鲁棒优化方法,将上述具有不确定性系数的...
  • 针对综合能源系统规划运行时缺乏对负荷、可再生能源预测误差和购能价格波动不确定性的考虑,构建了基于粒子群优化-区间线性规划双层优化模型,用于求解计及不确定性的综合能源系统规划问题。为了说明所提优化配置...
  • 主要研究上层函数及其约束函数不要求具有凸性和可微性,下层是关于下层决策变量是凸二次规划的双层规划模型,通过Karush-Kuhn-Tucher 条件转化为一个单层规划,利用下层是正定二次规划,将下层的决策变量表示为关于 ...
  • 在交通与物流网络系统规划中的许多决策问题可以归结为双层规划模型, 这类问题大多属于非凸优化问题. 现有算法要么难以获得全局最优解, 要么在解决大规模问题时存在算法...
  • 优化模型未包含在论文中,暂不能公布。说明的一点是,算法约束用的是简单的罚函数–内点法,未采用拉格朗日罚函数。精通算法的前辈大佬若扫到该文,如能提出复杂度更低的优化算法,晚辈感激不尽!初衷不变,以便日后...

    前言

    标题该算法针对高速铁路列车开行方案设计,在VS2017 .NETFramework 4.7.1平台 RAM 8G 配置上跑了173分钟。优化模型未包含在论文中,暂不能公布。说明的一点是,算法约束用的是简单的罚函数–内点法,未采用拉格朗日罚函数。精通算法的前辈大佬若扫到该文,如能提出复杂度更低的优化算法,晚辈感激不尽!初衷不变,以便日后查看。
    窗体应用程序+Chart控件,该算法可复制。

    代码

    1.编写LinkExcel类,针对特点Excel表进行存取

    public class LinkExcel
        {
            string[] sheetName = new string[] { };//客流数据表
            /// <summary>
            /// 连接EXCEL并读取客流数据
            /// </summary>
            /// <param name="filePath">客流数据表路径</param>
            /// <returns>数据集</returns>
            public DataSet LoadDataFormExcel(string filePath)
            {
                try
                {
                    string strConn;
                    strConn = "Provider=Microsoft.Ace.OleDb.12.0;Data Source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=1'";
                    OleDbConnection oleConn = new OleDbConnection(strConn);
                    oleConn.Open();
    
                    string sql="";
                    OleDbDataAdapter oleDaExcel;
                    DataSet oleDsExcel = new DataSet();
                    for (int i = 0; i < sheetName.Length; i++)
                    {
                        if (i < 3)
                        {
                            sql = "SELECT * FROM [" + sheetName[i] + "$] where OD is not null";
                        }
                        else
                        {
                            sql = "SELECT Factors,1,2,3,4 FROM [" + sheetName[i] + "$] where Factors is not null";
                        }
                        oleDaExcel = new OleDbDataAdapter(sql, oleConn);
                        oleDaExcel.Fill(oleDsExcel, sheetName[i]);
                    }
                    oleConn.Close();
                    return oleDsExcel;
                }
                catch (Exception err)
                {
                    MessageBox.Show("数据绑定Excel失败!!\n失败原因:" + err.Message, "提示信息", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return null;
                }
            }
            /// <summary>
            /// 更新Excel中数据
            /// </summary>
            /// <param name="filePath">客流数据路径</param>
            /// <param name="dataTable">待传入数据表</param>
            /// <param name="strSheet">待修改数据表表名</param>
            public void DSToExcel(string filePath, DataTable dataTable, string strSheet)
            {
                string strCon = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=0'";
                using (OleDbConnection myConn = new OleDbConnection(strCon))
                {
                    myConn.Open();
                    using (OleDbCommand dbComm = myConn.CreateCommand())
                    {
                        for (int i = 0; i < dataTable.Rows.Count; i++)
                        {
                            for (int j = 1; j < dataTable.Columns.Count; j++)
                            {
                                dbComm.CommandText = "update [" + strSheet + "$] " + "set " + j.ToString() +
                                    "=" + dataTable.Rows[i][j]+" where Factors="+(i+1).ToString();
                                dbComm.ExecuteNonQuery();
                            }
                        }
                        //MessageBox.Show("数据更新成功!!", "操作成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                }
            }
            /// <summary>
            /// 将数据写入Excel中--重载
            /// </summary>
            /// <param name="filePath">路径</param>
            /// <param name="dataSet">数据集</param>
            public void DSToExcel(string filePath, DataSet dataSet)
            {
                string strCon = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + filePath + ";Extended Properties='Excel 12.0;HDR=Yes;IMEX=0'";
                using (OleDbConnection myConn = new OleDbConnection(strCon))
                {
                    myConn.Open();
                    for (int k = 0; k < dataSet.Tables.Count; k++)
                    {
                        using (OleDbCommand dbComm = myConn.CreateCommand())
                        {
                            for (int i = 0; i < dataSet.Tables[k].Rows.Count; i++)
                            {
                                for (int j = 1; j < dataSet.Tables[k].Columns.Count; j++)
                                {
                                    dbComm.CommandText = "update [" + dataSet.Tables[k].TableName + "$] " + "set " + j.ToString() +
                                        "=" + dataSet.Tables[k].Rows[i][j] + " where Factors=" + (i + 1).ToString();
                                    dbComm.ExecuteNonQuery();
                                }
                            }
                            //MessageBox.Show("数据更新成功!!", "操作成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                }
            }
            /// <summary>
            /// 构造函数
            /// </summary>
            public LinkExcel()
            {
                StringBuilder strb = new StringBuilder();
                for (int i = 1; i <= 21; i++)
                {
                    for (int j = i+1; j <= 22; j++)
                    {
                        for (int k = 1; k <= 3; k++)
                        {
                            strb.AppendLine(i + "-" + j + "g" + k + "Customer");
                        }
                    }
                }
                string str = strb.ToString();
                string[] tempStr = str.Split(new char[] { '\n', '\r', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                sheetName = new string[tempStr.Length + 3];
                sheetName[0] = "g1Customer";
                sheetName[1] = "g2Customer";
                sheetName[2] = "g3Customer";
                for (int i = 0; i < tempStr.Length; i++)
                {
                    sheetName[i + 3] = tempStr[i];
                }
            }
        }
    

    2.编写NAGA-Ⅱ算法,各算子针对模型设计

     //染色体--解结构
        public struct Chromosome
        {
            //解的数据
            public int[][] x;//二进制解
            public double[] f;//目标函数数组      
            //解的Pareto属性
            public int n;//强帕累托支配该解的解个数
            public int[] S;//被该解强帕累托支配的解集合--运用索引下标进行访问;
            public double N;//拥挤度
            //开行频率
            public int[,] Frequent;
        }
        //上层非支配排序算法
        public class NSGA_{
            //全局变量
            public static int popsize = 100;//种群规模
            public static int f_num = 2;//目标函数个数
            double pc = 0.95;//交叉概率
            double pm = 0.01;//变异概率
            internal Chromosome[] chromosomes = new Chromosome[popsize];//种群数组--粒子集合
            internal Chromosome[][] f_sort;//父代非支配排序交错数组--存储分层后的粒子
            internal Chromosome[][] c_sort;//子代非支配排序交错数组--存储分层后的粒子
            Random rand = new Random(DateTime.Now.Millisecond);//随机产生器
    
            LinkExcel linkExcel = new LinkExcel();//Excel连接器--读取数据
            internal DataSet dS = new DataSet();//数据集--存储从Excel中读取的数据
    
            internal DataSet dSCustomer = new DataSet();//数据集--存储下层客流博弈结果
    
            string strDataPath = "客流数据.xlsx";//"E:\\CajDocuments\\高速铁路开行方案\\客流数据.xlsx";
    
            //NAGA-Ⅱ特有方法(非支配排序、拥挤度、精英保留策略)
    
            /// <summary>
            /// 初始化种群
            /// </summary>
            internal void UpperInitation()
            {
                dS = linkExcel.LoadDataFormExcel(strDataPath);//加载Excel数据
                //初始化g1Customer、g2Customer、g3Customer数组
                for (int i = 0; i < dS.Tables[0].Rows.Count; i++)
                {
                    for (int j = 1; j < dS.Tables[0].Columns.Count; j++)
                    {
                        g1Customer[i, j - 1] = Convert.ToInt32(dS.Tables[0].Rows[i][j]);
                        g2Customer[i, j - 1] = Convert.ToInt32(dS.Tables[1].Rows[i][j]);
                        g3Customer[i, j - 1] = Convert.ToInt32(dS.Tables[2].Rows[i][j]);
                    }
                }
                //初始化开行区段
                trainDepartureSection[0] = new int[5] { 1, 2, 3, 4, 5 };//开行区段1
                trainDepartureSection[1] = new int[9] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };//开行区段2
                trainDepartureSection[2] = new int[14] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };//开行区段3
                trainDepartureSection[3] = new int[22] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 };//开行区段4
                trainDepartureSection[4] = new int[3] { 20, 21, 22 };//开行区段5
                trainDepartureSection[5] = new int[6] { 17, 18, 19, 20, 21, 22 };//开行区段6
                //初始化上层解x并满足停站率约束
                for (int i = 0; i < popsize; i++)
                {
                    chromosomes[i].x = new int[trainDepartureSection.GetLength(0)][];
                    for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
                    {
                        chromosomes[i].x[j] = new int[trainDepartureSection[j].Length];
                        chromosomes[i].x[j][0] = 1;//始发站停车
                        chromosomes[i].x[j][trainDepartureSection[j].Length - 1] = 1;//终到站停车
                        for (int k = 1; k < trainDepartureSection[j].Length - 1; k++)
                        {
                            chromosomes[i].x[j][k] = rand.Next(2);
                        }
                        int istrue = 0;//停站次数
                        List<int> listIndexPassing = new List<int>();//不停站站点下标集合
                        for (int k = 0; k < chromosomes[i].x[j].Length; k++)
                        {
                            if (chromosomes[i].x[j][k] == 1)
                            {
                                istrue++;
                            }
                            else
                            {
                                listIndexPassing.Add(k);
                            }
                        }
                        double _beta = istrue * 1.0 / chromosomes[i].x[j].Length;
                        while (_beta < beta)
                        {
                            chromosomes[i].x[j][listIndexPassing[0]] = 1;
                            listIndexPassing.RemoveAt(0);
                            istrue++;
                            _beta = istrue * 1.0 / chromosomes[i].x[j].Length;
                        }
                    }
                    //chromosomes[i].f = new double[f_num];
                    //chromosomes[i].f[0] = F1Object(chromosomes[i]);
                    //chromosomes[i].f[1] = F2Object(chromosomes[i]);
                }
            }
    
            /// <summary>
            /// 非支配排序
            /// </summary>
            /// <param name="chromosome">父代种群</param>
            internal void NonDominationSort(Chromosome[] chromosome)
            {
                f_sort = new Chromosome[popsize][];
                List<Chromosome> tempList = new List<Chromosome>();//临时存储同一层粒子个体
                List<int> tempS = new List<int>();//临时存储被粒子支配的个体集合
                                                  //计算种群中每个个体被支配个数n和被该个体支配的解集合S
                int less;//解劣于粒子chromosome[i]的个体数目
                int equal;//解无差别于粒子chromosome[i]的个体数目
                int greater;//解优于粒子chromosome[i]的个体数目
                for (int i = 0; i < popsize; i++)
                {
                    for (int j = 0; j < popsize; j++)
                    {
                        less = 0;
                        equal = 0;
                        greater = 0;
                        for (int k = 0; k < f_num; k++)
                        {
                            if (k == 0)//k=0表示铁路运输企业的净收益函数
                            {
                                if (chromosome[i].f[k] > chromosome[j].f[k])
                                    less += 1;
                                else if (chromosome[i].f[k] == chromosome[j].f[k])
                                    equal += 1;
                                else
                                    greater += 1;
                            }
                            else
                            {
                                if (chromosome[i].f[k] < chromosome[j].f[k])
                                    less += 1;
                                else if (chromosome[i].f[k] == chromosome[j].f[k])
                                    equal += 1;
                                else
                                    greater += 1;
                            }
                        }
                        if (less == 0 && equal != f_num)
                        {
                            chromosome[i].n += 1;
                        }
                        else if (greater == 0 && equal != f_num)
                        {
                            tempS.Add(j);
                        }
                    }
                    chromosome[i].S = new int[tempS.Count];
                    for (int j = 0; j < tempS.Count; j++)
                    {
                        chromosome[i].S[j] = tempS[j];
                    }
                    if (chromosome[i].n == 0)
                        tempList.Add(chromosome[i]);
                    tempS.Clear();
                }
                int pareto_rank = 1;//初始化Pareto等级
                //Pareto等级为1的层级
                f_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
                for (int i = 0; i < tempList.Count; i++)
                {
                    f_sort[pareto_rank - 1][i] = tempList[i];
                }
                //Pareto等级为i(i>1)的层级
                while (f_sort[pareto_rank - 1] != null)
                {
                    if (pareto_rank == popsize)//若非支配排序层级达到种群规模,则退出循环,防止死循环
                        break;
                    tempList.Clear();//清空操作,为存储下一层粒子做准备
                    for (int i = 0; i < f_sort[pareto_rank - 1].Length; i++)
                    {
                        for (int j = 0; j < f_sort[pareto_rank - 1][i].S.Length; j++)
                        {
                            chromosome[f_sort[pareto_rank - 1][i].S[j]].n -= 1;
                            if (chromosome[f_sort[pareto_rank - 1][i].S[j]].n == 0)
                            {
                                tempList.Add(chromosome[f_sort[pareto_rank - 1][i].S[j]]);
                            }
                        }
                    }
                    pareto_rank += 1;
                    if (tempList.Count > 0)
                    {
                        f_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
                        for (int j = 0; j < tempList.Count; j++)
                        {
                            f_sort[pareto_rank - 1][j] = tempList[j];
                        }
                    }
                }
            }
    
            /// <summary>
            /// 非支配排序
            /// </summary>
            /// <param name="childchromosome">子代种群</param>
            internal void ChildNonDominationSort(Chromosome[] childchromosome)
            {
                c_sort = new Chromosome[popsize][];
                int pareto_rank = 1;//初始化Pareto等级
                List<Chromosome> tempList = new List<Chromosome>();//临时存储同一层粒子个体
                List<int> tempS = new List<int>();//临时存储被粒子支配的个体集合
                //计算种群中每个个体被支配个数n和被该个体支配的解集合S
                for (int i = 0; i < popsize; i++)
                {
                    for (int j = 0; j < popsize; j++)
                    {
                        int less = 0;//解劣于粒子chromosome[i]的个体数目
                        int equal = 0;//解无差别于粒子chromosome[i]的个体数目
                        int greater = 0;//解优于粒子chromosome[i]的个体数目
                        for (int k = 0; k < f_num; k++)
                        {
                            if (k == 0)//k=0表示铁路运输企业的净收益函数
                            {
                                if (childchromosome[i].f[k] > childchromosome[j].f[k])
                                    less += 1;
                                else if (childchromosome[i].f[k] == childchromosome[j].f[k])
                                    equal += 1;
                                else
                                    greater += 1;
                            }
                            else
                            {
                                if (childchromosome[i].f[k] < childchromosome[j].f[k])
                                    less += 1;
                                else if (childchromosome[i].f[k] == childchromosome[j].f[k])
                                    equal += 1;
                                else
                                    greater += 1;
                            }
                        }
                        if (less == 0 && equal != f_num)
                        {
                            childchromosome[i].n += 1;
                        }
                        else if (greater == 0 && equal != f_num)
                        {
                            tempS.Add(j);
                        }
                    }
                    childchromosome[i].S = new int[tempS.Count];
                    for (int j = 0; j < tempS.Count; j++)
                    {
                        childchromosome[i].S[j] = tempS[j];
                    }
                    if (childchromosome[i].n == 0)
                        tempList.Add(childchromosome[i]);
                    tempS.Clear();
                }
                //Pareto等级为1的层级
                c_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
                for (int i = 0; i < tempList.Count; i++)
                {
                    c_sort[pareto_rank - 1][i] = tempList[i];
                }
                //Pareto等级为i(i>1)的层级
                while (c_sort[pareto_rank - 1] != null)
                {
                    if (pareto_rank == popsize)
                        break;
                    tempList.Clear();
                    for (int i = 0; i < c_sort[pareto_rank - 1].Length; i++)
                    {
                        if (c_sort[pareto_rank - 1][i].S.Length > 0)
                        {
                            for (int j = 0; j < c_sort[pareto_rank - 1][i].S.Length; j++)
                            {
                                childchromosome[c_sort[pareto_rank - 1][i].S[j]].n -= 1;
                                if (childchromosome[c_sort[pareto_rank - 1][i].S[j]].n == 0)
                                {
                                    tempList.Add(childchromosome[c_sort[pareto_rank - 1][i].S[j]]);
                                }
                            }
                        }
                    }
                    pareto_rank += 1;
                    if (tempList.Count > 0)
                    {
                        c_sort[pareto_rank - 1] = new Chromosome[tempList.Count];
                        for (int i = 0; i < tempList.Count; i++)
                        {
                            c_sort[pareto_rank - 1][i] = tempList[i];
                        }
                    }
                }
            }
    
            /// <summary>
            /// 拥挤度
            /// </summary>
            /// <param name="f_sort">非支配排序后的粒子集合</param>
            internal void CrowdingDistanceSort(Chromosome[][] _sort)
            {
                int rank = -1;//记录非空层级
                //计算层数及对相应层级拥挤度赋初值0--后期优化
                for (int i = 0; i < _sort.GetLength(0); i++)
                {
                    if (_sort[i] != null)
                    {
                        rank += 1;
                        for (int j = 0; j < _sort[i].Length; j++)
                        {
                            _sort[i][j].N = 0;
                        }
                    }
                    else
                        break;
                }
                //交错数组二维化
                double[,] arrayThreeDimension = new double[popsize, f_num + 2];
                for (int i = 0; i < _sort[0].Length; i++)
                {
                    arrayThreeDimension[i, 0] = i;//存储粒子对应层级--此处存储第一层级
                    arrayThreeDimension[i, 1] = _sort[0][i].f[0];//存储粒子对应的第一个目标函数值
                    arrayThreeDimension[i, 2] = _sort[0][i].f[1];//存储粒子对应的第二个目标函数值
                }
                int intTempLength = 0;
                for (int i = 1; i < rank + 1; i++)
                {
                    intTempLength = 0;
                    for (int j = 0; j < i; j++)
                    {
                        intTempLength += _sort[j].Length;
                    }
                    for (int j = 0; j < _sort[i].Length; j++)
                    {
                        arrayThreeDimension[intTempLength + j, 0] = intTempLength + j;
                        arrayThreeDimension[intTempLength + j, 1] = _sort[i][j].f[0];
                        arrayThreeDimension[intTempLength + j, 2] = _sort[i][j].f[1];
                    }
                }
                //拥挤度计算
                for (int k = 0; k < f_num; k++)
                {
                    //按照第k个目标函数升序排序
                    int arrMin;
                    for (int i = 0; i < arrayThreeDimension.GetLength(0) - 1; i++)
                    {
                        arrMin = i;
                        for (int j = i + 1; j < arrayThreeDimension.GetLength(0); j++)
                        {
                            if (arrayThreeDimension[j, k + 1] < arrayThreeDimension[arrMin, k + 1])
                            {
                                arrMin = j;
                            }
                        }
                        double douTemp1 = arrayThreeDimension[arrMin, 0],
                            douTemp2 = arrayThreeDimension[arrMin, 1],
                            douTemp3 = arrayThreeDimension[arrMin, 2];
                        arrayThreeDimension[arrMin, 0] = arrayThreeDimension[i, 0];
                        arrayThreeDimension[arrMin, 1] = arrayThreeDimension[i, 1];
                        arrayThreeDimension[arrMin, 2] = arrayThreeDimension[i, 2];
                        arrayThreeDimension[i, 0] = douTemp1;
                        arrayThreeDimension[i, 1] = douTemp2;
                        arrayThreeDimension[i, 2] = douTemp3;
                    }
                    //边界点拥挤度为无穷大
                    arrayThreeDimension[0, 3] = arrayThreeDimension[popsize - 1, 3] = double.MaxValue;
                    //计算其它各点拥挤度
                    double douMinCrowding = arrayThreeDimension[0, k + 1];
                    double douMaxCrowding = arrayThreeDimension[popsize - 1, k + 1];
                    for (int i = 1; i < popsize - 1; i++)
                    {
                        arrayThreeDimension[i, 3] += Math.Abs(arrayThreeDimension[i - 1, k + 1] - arrayThreeDimension[i + 1, k + 1]) * 1.0 / (douMaxCrowding - douMinCrowding);
                    }
                }
                //填充具有拥挤度值的_sort[][]
                for (int i = 0; i < arrayThreeDimension.GetLength(0); i++)
                {
                    intTempLength = 0;
                    for (int j = 0; j < rank + 1; j++)
                    {
                        intTempLength += _sort[j].Length;
                        if (arrayThreeDimension[i, 0] < intTempLength)
                        {
                            if (j != 0)
                            {
                                int intColumn = (int)arrayThreeDimension[i, 0] % (intTempLength - _sort[j].Length);
                                _sort[j][intColumn].N = arrayThreeDimension[i, 3];
                                break;
                            }
                            else
                            {
                                int intColumn = (int)arrayThreeDimension[i, 0];
                                _sort[j][intColumn].N = arrayThreeDimension[i, 3];
                                break;
                            }
                        }
                    }
                }
            }
    
            //遗传算子(模拟二进制交叉(Simulated Binary Crossover,SBX)、多项式变异(Polynomial Mutation)、锦标赛选择(Tournament Selection))
    
            /// <summary>
            /// 锦标赛法选择算子
            /// </summary>
            /// <param name="chromosome">上一代群体</param>
            /// <returns>从前代种群中选择出较优种群</returns>
            internal Chromosome[] TournamentSelection(Chromosome[] chromosome)
            {
                int childIndex1;//选择个体1
                int childIndex2;//选择个体2
                Chromosome[] chromoselect = new Chromosome[popsize];//选择的解个体集合
                for (int i = 0; i < popsize; i++)
                {
                    childIndex1 = rand.Next(0, chromosome.Length);
                    childIndex2 = rand.Next(0, chromosome.Length);
                    while (childIndex1 == childIndex2)
                    {
                        childIndex2 = rand.Next(0, chromosome.Length);
                    }
                    if ((chromosome[childIndex1].f[0] >= chromosome[childIndex2].f[0]) ||
                        (chromosome[childIndex1].f[1] <= chromosome[childIndex2].f[1]))
                    {
                        chromoselect[i].x = new int[trainDepartureSection.GetLength(0)][];
                        for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
                        {
                            chromoselect[i].x[j] = new int[trainDepartureSection[j].Length];
                            for (int k = 0; k < trainDepartureSection[j].Length; k++)
                            {
                                chromoselect[i].x[j][k] = chromosome[childIndex1].x[j][k];
                            }
                        }
                        chromoselect[i].f = new double[f_num];
                        chromoselect[i].f[0] = chromosome[childIndex1].f[0];
                        chromoselect[i].f[1] = chromosome[childIndex1].f[1];
                    }
                    else
                    {
                        chromoselect[i].x = new int[trainDepartureSection.GetLength(0)][];
                        for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
                        {
                            chromoselect[i].x[j] = new int[trainDepartureSection[j].Length];
                            for (int k = 0; k < trainDepartureSection[j].Length; k++)
                            {
                                chromoselect[i].x[j][k] = chromosome[childIndex2].x[j][k];
                            }
                        }
                        chromoselect[i].f = new double[f_num];
                        chromoselect[i].f[0] = chromosome[childIndex2].f[0];
                        chromoselect[i].f[1] = chromosome[childIndex2].f[1];
                    }
                }
                return chromoselect;
            }
    
            /// <summary>
            /// 交叉、变异算子
            /// </summary>
            /// <param name="preChromosome">由锦标赛选择出来的种群</param>
            internal void NewChromosomes(Chromosome[] preChromosome)
            {
                Chromosome[] tempNewChildren = new Chromosome[popsize];
                int randPL = 0;//开行区段
                int randGene = 0;//基因位
                int randParent1 = 0;//父代索引1
                int randParent2 = 0;//父代索引2
                double doueta = 2;//SBX算子中的参数η
                double dougamma;//SBX算子中的参数γ
                for (int i = 0; i < popsize; i++)
                {
                    //二进制交叉
                    randParent1 = rand.Next(0, preChromosome.Length);
                    randParent2 = rand.Next(0, preChromosome.Length);
                    while (randParent1 == randParent2)
                        randParent2 = rand.Next(0, preChromosome.Length);
                    Chromosome _child1 = new Chromosome();
                    Chromosome _child2 = new Chromosome();
                    _child1.x = new int[preChromosome[randParent1].x.GetLength(0)][];
                    _child2.x = new int[preChromosome[randParent2].x.GetLength(0)][];
                    for (int j = 0; j < preChromosome[randParent1].x.GetLength(0); j++)
                    {
                        _child1.x[j] = new int[preChromosome[randParent1].x[j].Length];
                        _child2.x[j] = new int[preChromosome[randParent1].x[j].Length];
                        for (int k = 0; k < preChromosome[randParent1].x[j].Length; k++)
                        {
                            _child1.x[j][k] = preChromosome[randParent1].x[j][k];
                            _child2.x[j][k] = preChromosome[randParent2].x[j][k];
                        }
                    }
                    _child1.f = new double[f_num];
                    _child2.f = new double[f_num];
                    _child1.f[0] = preChromosome[randParent1].f[0];
                    _child1.f[1] = preChromosome[randParent1].f[1];
                    _child2.f[0] = preChromosome[randParent2].f[0];
                    _child2.f[1] = preChromosome[randParent2].f[1];
                    int temp1 = 0;//父代1交叉基因位数值
                    int temp2 = 0;//父代2交叉基因位数值
                    double x1 = 0;//父代1基因位更新后数值
                    double x2 = 0;//父代2基因位更新后数值
                    double _rand = rand.NextDouble();
                    if (_rand < pc)
                    {
                        randPL = rand.Next(0, _child1.x.GetLength(0));
                        randGene = rand.Next(0, _child1.x[randPL].Length);
                        for (int j = randGene; j < _child1.x[randPL].Length; j++)
                        {
                            temp1 = _child1.x[randPL][j];
                            temp2 = _child2.x[randPL][j];
                            _rand = rand.NextDouble();
                            if (_rand < 0.5)
                            {
                                dougamma = Math.Pow(2 * _rand, 1.0 / (doueta + 1));
                            }
                            else
                            {
                                dougamma = Math.Pow(1.0 / (2 * (1 - _rand)), 1.0 / (doueta + 1));
                            }
                            x1 = 0.5 * ((1 + dougamma) * temp1 + (1 - dougamma) * temp2);
                            x2 = 0.5 * ((1 - dougamma) * temp1 + (1 + dougamma) * temp2);
                            temp1 = (int)Math.Round(x1);
                            temp2 = (int)Math.Round(x2);
                            _child1.x[randPL][j] = temp1;
                            _child2.x[randPL][j] = temp2;
                        }
    
                        //计算_child1对应函数值
                        upperSolutionIndex = 0;
                        ds[upperSolutionIndex] = new DataSet();
                        for (int j = 1; j < stationNum; j++)//客流博弈分配
                        {
                            for (int k = j + 1; k <= stationNum; k++)
                            {
                                customersAssigned(_child1, g1Customer[j - 1, k - 1],
                                    g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
                            }
                        }
                        //根据旅客分配情况确定列车开行频率
                        _child1.Frequent = new int[pLNum, trainType];
                        _child1.Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
                        //根据旅客分配情况确定上层各函数值
                        _child1.f = new double[f_num];
                        dSCustomer = ds[upperSolutionIndex];
                        _child1.f[0] =
                           F1Object(_child1);
                        _child1.f[1] =
                            F2Object(_child1);
                        //计算_child2对应函数值
                        ds[upperSolutionIndex] = new DataSet();
                        for (int j = 1; j < stationNum; j++)//客流博弈分配
                        {
                            for (int k = j + 1; k <= stationNum; k++)
                            {
                                customersAssigned(_child2, g1Customer[j - 1, k - 1],
                                    g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
                            }
                        }
                        //根据旅客分配情况确定列车开行频率
                        _child2.Frequent = new int[pLNum, trainType];
                        _child2.Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
                        //根据旅客分配情况确定上层各函数值
                        _child2.f = new double[f_num];
                        dSCustomer = ds[upperSolutionIndex];
                        _child2.f[0] =
                           F1Object(_child2);
                        _child2.f[1] =
                            F2Object(_child2);
    
                        //选取较优解
                        if (_child1.f[0] > _child2.f[0] && _child1.f[1] < _child2.f[1])
                        {
                            tempNewChildren[i] = _child1;
                        }
                        else
                        {
                            tempNewChildren[i] = _child2;
                        }
                    }
                    else
                    {
                        if (_child1.f[0] > _child2.f[0] && _child1.f[1] < _child2.f[1])
                        {
                            tempNewChildren[i] = _child1;
                        }
                        else
                        {
                            tempNewChildren[i] = _child2;
                        }
                    }
                    //变异
                    if (rand.NextDouble() < pm)
                    {
                        randPL = rand.Next(0, tempNewChildren[i].x.GetLength(0));
                        randGene = rand.Next(0, tempNewChildren[i].x[randPL].Length);
                        tempNewChildren[i].x[randPL][randGene] = 1 - tempNewChildren[i].x[randPL][randGene];
                        //计算tempNewChildren[i]对应函数值
                       upperSolutionIndex = 0;
                        ds[upperSolutionIndex] = new DataSet();
                        for (int j = 1; j < stationNum; j++)//客流博弈分配
                        {
                            for (int k = j + 1; k <= stationNum; k++)
                            {
                                customersAssigned(tempNewChildren[i], g1Customer[j - 1, k - 1],
                                    g2Customer[j - 1, k - 1], g3Customer[j - 1, k - 1], j, k);
                            }
                        }
                        //根据旅客分配情况确定列车开行频率
                        tempNewChildren[i].Frequent = new int[pLNum, trainType];
                        tempNewChildren[i].Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
                        //根据旅客分配情况确定上层各函数值
                        tempNewChildren[i].f = new double[f_num];
                        dSCustomer = ds[upperSolutionIndex];
                        tempNewChildren[i].f[0] =
                           F1Object(tempNewChildren[i]);
                        tempNewChildren[i].f[1] =
                            F2Object(tempNewChildren[i]);
    
                    }
                }
                ChildNonDominationSort(tempNewChildren);
                CrowdingDistanceSort(c_sort);
            }
    
            /// <summary>
            /// 新一代群体(精英保留策略)
            /// </summary>
            /// <param name="f_sort">父代种群</param>
            /// <param name="c_sort">子代种群</param>
            internal void Elitism(Chromosome[][] f_sort, Chromosome[][] c_sort)
            {
                Chromosome[][] _Chromosome;
                List<Chromosome> listChromosome = new List<Chromosome>();//存储精英解
                int rankf = 0;//父代层级数
                int rankc = 0;//子代层级数
                int rankmax = 0;//最大层级数
                for (int i = 0; i < f_sort.GetLength(0); i++)
                {
                    if (f_sort[i] != null)
                        rankf++;
                    else
                        break;
                }
                for (int i = 0; i < c_sort.GetLength(0); i++)
                {
                    if (c_sort[i] != null)
                        rankc++;
                    else
                        break;
                }
                if (rankf > rankc)
                {
                    rankmax = rankf;
                }
                else
                {
                    rankmax = rankc;
                }
                _Chromosome = new Chromosome[rankmax][];
                for (int i = 0; i < rankmax; i++)
                {
                    listChromosome.Clear();
                    if (f_sort[i] != null)
                    {
                        for (int j = 0; j < f_sort[i].Length; j++)
                        {
                            listChromosome.Add(f_sort[i][j]);
                        }
                    }
                    if (c_sort[i] != null)
                    {
                        for (int j = 0; j < c_sort[i].Length; j++)
                        {
                            listChromosome.Add(c_sort[i][j]);
                        }
                    }
                    _Chromosome[i] = new Chromosome[listChromosome.Count];
                    _Chromosome[i] = listChromosome.ToArray();
                }
                int currentNum = 0;//已存储解个体数目
                int remainNum = 0;//仍缺解个体数目
                int index = 0;//种群索引下标
                for (int i = 0; i < _Chromosome.GetLength(0); i++)
                {
                    if (currentNum < popsize)
                    {
                        if (_Chromosome[i].Length + currentNum <= popsize)
                        {
                            for (int j = 0; j < _Chromosome[i].Length; j++)
                            {
                                chromosomes[index++] = _Chromosome[i][j];
                            }
                            currentNum += _Chromosome[i].Length;
                        }
                        else
                        {
                            remainNum = popsize - currentNum;
                            ChromSort(_Chromosome[i]);
                            for (int j = 0; j < remainNum; j++)
                            {
                                chromosomes[index++] = _Chromosome[i][_Chromosome[i].Length - 1 - j];
                            }
                            currentNum += remainNum;
                        }
                    }
                    else
                        break;
                }
            }
    
    
            //其它方法
    
            /// <summary>
            /// 选择排序(重载)--拥挤度
            /// </summary>
            /// <param name="chromosome">解个体</param>
            void ChromSort(Chromosome[] chromosome)
            {
                int min;
                for (int i = 0; i < chromosome.Length - 1; i++)
                {
                    min = i;
                    for (int j = i + 1; j < chromosome.Length; j++)
                    {
                        if (chromosome[j].N < chromosome[min].N)
                        {
                            min = j;
                        }
                    }
                    Chromosome temp = new Chromosome();
                    temp = chromosome[min];
                    chromosome[min] = chromosome[i];
                    chromosome[i] = temp;
                }
            }
    
            /// <summary>
            /// 选择排序--非支配序
            /// </summary>
            /// <param name="chromosome">待排序同层级个体集合</param>
            /// <param name="k">指示函数,k=1代表对第一个目标函数进行排序,k=2表示对第二个目标函数进行排序</param>
            /// <returns>排序后同层级个体集合</returns>
            void ChromSort(Chromosome[] chromosome, int k)
            {
                int min;
                if (k == 1)
                {
                    for (int i = 0; i < chromosome.Length - 1; ++i)
                    {
                        min = i;
                        for (int j = i + 1; j < chromosome.Length; j++)
                        {
                            if (chromosome[j].f[k - 1] < chromosome[i].f[k - 1])
                            {
                                min = j;
                            }
                        }
                        Chromosome temp = chromosome[min];
                        chromosome[min] = chromosome[i];
                        chromosome[i] = temp;
                    }
                }
                else
                {
                    for (int i = 0; i < chromosome.Length - 1; ++i)
                    {
                        min = i;
                        for (int j = i + 1; j < chromosome.Length; j++)
                        {
                            if (chromosome[j].f[k - 1] < chromosome[i].f[k - 1])
                            {
                                min = j;
                            }
                        }
                        Chromosome temp = chromosome[min];
                        chromosome[min] = chromosome[i];
                        chromosome[i] = temp;
                    }
                }
            }
    
            internal static int stationNum = 22;//单线高速铁路客运站点数量
            internal static int trainType = 4;//列车种类--一站直达、大站停、择站停、站站停
            internal static int pLNum = 6;//开行区段数量
    
            public int[][] trainDepartureSection = new int[pLNum][];//列车开行区段
    
            double[] stationsDistance
                = new double[] { 87, 45, 31, 25, 43, 55, 105, 64, 35, 46, 49, 61, 21, 126, 163, 261, 249, 32, 91, 158, 9 };//站间距
            double cT = 500;//列车公里费用
            double cTFix = 1000;//列车固定使用费用
            //int g = 3;//客流层次
            double[,] rateTicket = new double[,]
            { { 0.9, 0.8, 0.7, 0.6 },{ 0.6, 0.5, 0.4, 0.3 },{0.4,0.3,0.2,0.1 } };//票价率
            internal double alphMax = 1.1;//最大上座率
            internal double alphMin = 0.6;//最小上座率
            internal int seatNum = 90;//列车座位数
            internal double douCustomerFluctuateRate = 1.3;//客流波动系数
    
            internal int[,] g1Customer = new int[stationNum, stationNum];//消费层次为g1的铁路旅客集合
            internal int[,] g2Customer = new int[stationNum, stationNum];//消费层次为g2的铁路旅客集合
            internal int[,] g3Customer = new int[stationNum, stationNum];//消费层次为g3的铁路旅客集合
    
            int[,] g1customerTrainSelection = new int[pLNum, trainType];//客流分配表(i,j)
            int[,] g2customerTrainSelection = new int[pLNum, trainType];
            int[,] g3customerTrainSelection = new int[pLNum, trainType];
    
            int[,] customerTrainSelection = new int[pLNum, trainType];//选择各类列车的总旅客数
    
            int[] stationCapcity = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 };//站点通过能力
            int[] sectionCapcity = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200 };//区间通过能力
    
            double beta = 0.6;//停站率
            double violationFactor = 500000;//罚因子
    
            /// <summary>
            /// 铁路净收益目标函数
            /// </summary>
            /// <param name="chromosome">解粒子</param>
            /// <returns>带惩罚值的函数值</returns>
            internal double F1Object(Chromosome chromosome)
            {
                //各费用、票价函数值
                double costT = 0;//列车公里费用
                double costTFix = 0;//列车固定使用费用
                double benefitTicket = 0;//客票收入
                double _distance;//距离
                int q;//各类列车总数
                for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
                {
                    _distance = 0;
                    q = 0;
                    for (int j = 0; j < trainType; j++)
                    {
                        q += chromosome.Frequent[i, j];
                    }
                    _distance = IJDistance(trainDepartureSection[i][0], trainDepartureSection[i][trainDepartureSection[i].Length - 1]);
                    costT += _distance * q * cT;
                    costTFix += q * cTFix;
                }
                string strTableName1 = "";//表名
                string strTableName2 = "";
                string strTableName3 = "";
                double[] _douCustomerSum = new double[3];//乘坐同一种类列车的旅客人数
                for (int i = 1; i < stationNum; i++)
                {
                    for (int j = i + 1; j <= stationNum; j++)
                    {
                        _distance = IJDistance(i, j);
                        strTableName1 = i + "-" + j + "g1Customer";
                        strTableName2 = i + "-" + j + "g2Customer";
                        strTableName3 = i + "-" + j + "g3Customer";
                        for (int k = 1; k <= trainType; k++)
                        {
                            _douCustomerSum[0] = 0;
                            _douCustomerSum[1] = 0;
                            _douCustomerSum[2] = 0;
                            for (int m = 0; m < pLNum; m++)
                            {
                                _douCustomerSum[0] += Convert.ToInt32(dSCustomer.Tables[strTableName1].Rows[m][k]);
                                _douCustomerSum[1] += Convert.ToInt32(dSCustomer.Tables[strTableName2].Rows[m][k]);
                                _douCustomerSum[2] += Convert.ToInt32(dSCustomer.Tables[strTableName3].Rows[m][k]);
                            }
                            benefitTicket += (_douCustomerSum[0] * rateTicket[0, k - 1] + _douCustomerSum[1] * rateTicket[1, k - 1] +
                                _douCustomerSum[1] * rateTicket[1, k - 1]) * _distance;
                        }
                    }
                }
                //判断解是否可行
                double violationConstraints1 = 0;//违反停站率的惩罚值
                double violationConstraints2 = 0;//违反通过能力的惩罚值
                for (int i = 0; i < chromosome.x.GetLength(0); i++)//判断解是否满足停站率约束
                {
                    int istrue = 0;//停站次数
                    for (int j = 0; j < chromosome.x[i].Length; j++)
                    {
                        if (chromosome.x[i][j] == 1)
                        {
                            istrue++;
                        }
                    }
                    double _beta = istrue * 1.0 / chromosome.x[i].Length;
                    if (_beta < beta)
                        violationConstraints1 += violationFactor * (beta - _beta) * (beta - _beta);
                    else
                        violationConstraints1 += 0;
                }
                List<int> tempListStationIndex = new List<int>();//存储站点可能所在区段下标
                for (int i = 2; i < stationNum; i++) //判断解是否满足站点通过能力约束
                {
                    tempListStationIndex.Clear();
                    for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
                    {
                        for (int k = 0; k < trainDepartureSection[j].Length; k++)
                        {
                            if (i == trainDepartureSection[j][k])
                            {
                                tempListStationIndex.Add(j);
                                break;
                            }
                        }
                    }
                    int int_qT = 0;//开行频率总数
                    for (int j = 0; j < tempListStationIndex.Count; j++)
                    {
                        for (int k = 0; k < trainType; k++)
                        {
                            int_qT += chromosome.Frequent[tempListStationIndex[j], k];
                        }
                    }
                    if (int_qT <= stationCapcity[i - 1])
                        violationConstraints2 += 0;
                    else
                        violationConstraints2 += violationFactor * (int_qT - stationCapcity[i - 1]) * (int_qT - stationCapcity[i - 1]);
                }
                List<int> tempListSectionIndex = new List<int>();//存储站间可能所在区段下标
                for (int i = 1; i < stationNum; i++)//判断解是否满足区间通过能力
                {
                    tempListStationIndex.Clear();
                    for (int j = 0; j < trainDepartureSection.GetLength(0); j++)
                    {
                        for (int k = 0; k < trainDepartureSection[j].Length - 1; k++)
                        {
                            if (i == trainDepartureSection[j][k])
                            {
                                tempListSectionIndex.Add(j);
                                break;
                            }
                        }
                    }
                    int int_qT = 0;//区间列车开行频率总和
                    for (int j = 0; j < tempListSectionIndex.Count; j++)
                    {
                        for (int k = 0; k < trainType; k++)
                        {
                            int_qT += chromosome.Frequent[tempListSectionIndex[j], k];
                        }
                    }
                    if (int_qT <= sectionCapcity[i - 1])
                        violationConstraints2 += 0;
                    else
                        violationConstraints2 += violationFactor * (int_qT - sectionCapcity[i - 1]) * (int_qT - sectionCapcity[i - 1]);
                }
                return benefitTicket - costT - costTFix - violationConstraints1 - violationConstraints2;
            }
    
            /// <summary>
            /// 列车空座位走行公里
            /// </summary>
            /// <param name="chromosome">解粒子</param>
            /// <returns>带惩罚值的函数值</returns>
            internal double F2Object(Chromosome chromosome)
            {
                double douSeatValue = 0;//上座率值
                int[] sectionStation;//开行区段站点集合
                int[] sectionCustomer;//区间客流数集合
                for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
                {
                    sectionStation = new int[trainDepartureSection[i].Length];
                    sectionCustomer = new int[trainDepartureSection[i].Length - 1];
                    for (int j = 0; j < sectionStation.Length; j++)
                    {
                        sectionStation[j] = trainDepartureSection[i][j];
                    }
                    int douValueCustomer;//区间客流总和
                    string strTableName1 = "";//表名
                    string strTableName2 = "";
                    string strTableName3 = "";
                    for (int j = 0; j < sectionCustomer.Length; j++)
                    {
                        douValueCustomer = 0;
                        for (int k = 0; k <= j; k++)
                        {
                            for (int m = j + 1; m < sectionStation.Length; m++)
                            {
                                strTableName1 = sectionStation[k].ToString() + "-" +
                               sectionStation[m].ToString() + "g1Customer";
                                strTableName2 = sectionStation[k].ToString() + "-" +
                                    sectionStation[m].ToString() + "g2Customer";
                                strTableName3 = sectionStation[k].ToString() + "-" +
                                    sectionStation[m].ToString() + "g3Customer";
                                for (int l = 0; l < trainType; l++)
                                {
                                    douValueCustomer += Convert.ToInt32(dSCustomer.Tables[strTableName1].Rows[i][l + 1]) +
                                    Convert.ToInt32(dSCustomer.Tables[strTableName2].Rows[i][l + 1]) +
                                     Convert.ToInt32(dSCustomer.Tables[strTableName3].Rows[i][l + 1]);
                                }
                            }
                        }
                        sectionCustomer[j] = douValueCustomer;
                    }
                    double douQ = 0;//区段列车开行频率总和
                    for (int j = 0; j < trainType; j++)
                    {
                        douQ += chromosome.Frequent[i, j];
                    }
                    for (int j = 0; j < sectionCustomer.Length; j++)
                    {
                        douSeatValue += IJDistance(sectionStation[j], sectionStation[j + 1]) *
                            (sectionCustomer[j] - douQ * seatNum * 1.0 * (alphMax + alphMin) / 2) *
                            (sectionCustomer[j] - douQ * seatNum * 1.0 * (alphMax + alphMin) / 2);
                    }
                }
                return douSeatValue;
            }
    
            /// <summary>
            /// 站间距
            /// </summary>
            /// <param name="startPoint">起始站点</param>
            /// <param name="endPoint">终到站点</param>
            /// <returns>距离</returns>
            internal double IJDistance(int startPoint, int endPoint)
            {
                double _distance = 0;
                for (int i = startPoint - 1; i < endPoint - 1; i++)
                {
                    _distance += stationsDistance[i];
                }
                return _distance;
            }
    
    
    
    
    
    
    
    
    
    
            internal List<Chromosome> iterValue = new List<Chromosome>();//输出对象
            public struct Particles  //定义粒子的结构体
            {
                public int x;//粒子当前位置(选择的列车种类)
                public double fitness;//粒子的当前位置适应值
            }
    
            //全局变量定义
            static int popsize1;//消费水平层次为1的群体规模
            static int popsize2;//消费水平层次为2的群体规模
            static int popsize3;//消费水平层次为3的群体规模
    
            Particles[] g1Particles;//消费水平层次为1的客流个体集合
            Particles[] g2Particles;//消费水平层次为2的客流个体集合
            Particles[] g3Particles;//消费水平层次为3的客流个体集合
    
            int[] gbest1;//消费层次为1的客流局势
            int[] gbest2;//消费层次为2的客流局势
            int[] gbest3;//消费层次为3的客流局势
    
            double gbestfitness1;//消费水平层次为1的赢得函数值
            double gbestfitness2;//消费水平层次为2的赢得函数值
            double gbestfitness3;//消费水平层次为3的赢得函数值
    
            LinkExcel _linkExcel = new LinkExcel();//表读取对象
            internal int upperSolutionIndex = 0;//上层解粒子下标索引
            DataTable dt = new DataTable();//数据表
            internal DataSet[] ds;//数据集
                                  //string _strDataPath = "客流数据.xlsx";//数据所在相对位置
    
            //下层客流博弈分配全局变量
            double w1 = 200, w2 = 100, w3 = 50;//各消费层次客流时间价值系数
            double lamda11 = 0.1, lamda12 = 0.9;//消费层次等级为1的客流的权重系数
            double lamda21 = 0.5, lamda22 = 0.5;//消费层次等级为2的客流的权重系数
            double lamda31 = 0.9, lamda32 = 0.1;//消费层次等级为3的客流的权重系数
                                                //double violationM = 50000;//惩罚函数值
            double velocity = 250;//列车速度值
            double timeAverage = 4;//在站停留平均时间
            int[] bigStation = new int[] { 1, 5, 22 };//客流量较大站点集合
            double[,] ticketRate = new double[,] { { 0.9, 0.8, 0.7, 0.6 }, { 0.6, 0.5, 0.4, 0.3 }, { 0.4, 0.3, 0.2, 0.1 } };//票价率
    
            //方法定义
            int sectionIndex = 0;//客流博弈所在开行区段下标
            List<int> sectionListIndexSets = new List<int>();//始发、终到站均含于相同开行区段的开行区段下标集合
            List<int> strategySets = new List<int>();//策略集
    
            /// <summary>
            /// OD客流选择列车出行博弈方法
            /// </summary>
            /// <param name="xchromosome">上层解粒子</param>
            /// <param name="g1CustomerNum">消费层次为1的OD客流规模</param>
            /// <param name="g2CustomerNum">消费层次为2的OD客流规模</param>
            /// <param name="g3CustomerNum">消费层次为3的OD客流规模</param>
            /// <param name="startStation">O点</param>
            /// <param name="endStation">D点</param>
            internal void customersAssigned(Chromosome xchromosome, int g1CustomerNum, int g2CustomerNum,
                int g3CustomerNum, int startStation, int endStation)
            {
                sectionIndex = 0;//开行区段索引赋初值
                sectionListIndexSets.Clear();//清空开行区段索引集合
                strategySets.Clear();//清空策略集
                for (int i = 0; i < xchromosome.x.GetLength(0); i++)//填充均包含O、D的开行区段下标集合
                {
                    if (trainDepartureSection[i][0] <= startStation &&
                        trainDepartureSection[i][xchromosome.x[i].Length - 1] >= endStation)
                    {
                        sectionListIndexSets.Add(i);
                    }
                }
                //随机选择一个同时包含起始、终点站的列车开行区段
                sectionIndex = sectionListIndexSets[rand.Next(sectionListIndexSets.Count)];
                //填充策略集StrategySets
                //--一站直达
                if (startStation == trainDepartureSection[sectionIndex][0] &&
                     endStation == trainDepartureSection[sectionIndex][trainDepartureSection[sectionIndex].Length - 1])
                {
                    strategySets.Add(1);
                }
                //--大站停
                int isAllbigStation = 0;//指标--指示OD客流是否可以乘坐大站停列车完成出现
                for (int i = 0; i < bigStation.Length; i++)
                {
                    if (startStation == bigStation[i])
                    {
                        isAllbigStation += 1;
                        continue;
                    }
                    if (endStation == bigStation[i])
                    {
                        isAllbigStation += 1;
                        break;
                    }
                }
                if (isAllbigStation == 2)
                {
                    strategySets.Add(2);
                }
                //--择站停
                int startStationIndex = 0;//客流出发站的站点在x解集中对应的下标
                int endStationIndex = 0;//客流终到站的站点在x解集中对应的下标
                for (int i = 0; i < trainDepartureSection[sectionIndex].Length; i++)
                {
                    if (trainDepartureSection[sectionIndex][i] == startStation)
                    {
                        startStationIndex = i;
                        continue;
                    }
                    if (trainDepartureSection[sectionIndex][i] == endStation)
                    {
                        endStationIndex = i;
                        break;
                    }
                }
                if (xchromosome.x[sectionIndex][startStationIndex] == 1 && xchromosome.x[sectionIndex][endStationIndex] == 1)
                    strategySets.Add(3);
                //--站站停:对OD(始发站为startStation,终点站为endStation)来说,站站停列车为必备策略
                strategySets.Add(4);
    
    
                //客流列车分配初始化
                popsize1 = g1CustomerNum;//初始化各消费层次客流规模
                popsize2 = g2CustomerNum;
                popsize3 = g3CustomerNum;
    
                g1Particles = new Particles[popsize1];//创建各消费层次客流集合
                g2Particles = new Particles[popsize2];
                g3Particles = new Particles[popsize3];
    
                gbest1 = new int[popsize1];//创建各消费层次客流局势
                gbest2 = new int[popsize2];
                gbest3 = new int[popsize3];
    
    
                //分情况初始化各消费层次客流出行列车选择
                if (strategySets.Count == 1)
                {
                    //消费层次为1的客流初始化
                    g1Particles[0].x = strategySets[0];
                    gbest1[0] = g1Particles[0].x;
                    g1Particles[0].fitness = SatisficationValue(g1Particles[0].x, 1, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize1; i++)
                    {
                        g1Particles[i].x = g1Particles[0].x;
                        g1Particles[i].fitness = g1Particles[0].fitness;
                        gbest1[i] = g1Particles[i].x;
                    }
                    //消费层次为2的客流初始化
                    g2Particles[0].x = strategySets[0];
                    gbest2[0] = g2Particles[0].x;
                    g2Particles[0].fitness = SatisficationValue(g2Particles[0].x, 2, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize2; i++)
                    {
                        g2Particles[i].x = g2Particles[0].x;
                        g2Particles[i].fitness = g2Particles[0].fitness;
                        gbest2[i] = g2Particles[i].x;
                    }
                    //消费层次为3的客流初始化
                    g3Particles[0].x = strategySets[0];
                    gbest3[0] = g3Particles[0].x;
                    g3Particles[0].fitness = SatisficationValue(g3Particles[0].x, 3, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize3; i++)
                    {
                        g3Particles[i].x = g3Particles[0].x;
                        g3Particles[i].fitness = g3Particles[0].fitness;
                        gbest3[i] = g3Particles[i].x;
                    }
                }
                else
                {
                    //消费层次为1的客流初始化
                    double douValue = 0;
                    for (int i = 0; i < popsize1; i++)
                    {
                        g1Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g1Particles[i].fitness = SatisficationValue(g1Particles[i].x, 1, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest1[i] = g1Particles[i].x;
                        douValue += g1Particles[i].fitness;
                    }
                    //消费层次为2的客流初始化
                    douValue = 0;
                    for (int i = 0; i < popsize2; i++)
                    {
                        g2Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g2Particles[i].fitness = SatisficationValue(g2Particles[i].x, 2, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest2[i] = g2Particles[i].x;
                        douValue += g2Particles[i].fitness;
                    }
                    //消费层次为3的客流初始化
                    douValue = 0;
                    for (int i = 0; i < popsize3; i++)
                    {
                        g3Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g3Particles[i].fitness = SatisficationValue(g3Particles[i].x, 3, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest3[i] = g3Particles[i].x;
                        douValue += g3Particles[i].fitness;
                    }
                }
    
                //算法开始迭代
                RunIteration(g1Particles, 1, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
                RunIteration(g2Particles, 2, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
                RunIteration(g3Particles, 3, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
            }
    
            /// <summary>
            /// 铁路旅客满意度评价函数
            /// </summary>
            /// <param name="_trainType">列车种类</param>
            /// <param name="_costLevel">消费层次</param>
            /// <param name="_sectionIndex">博弈区段下标</param>
            /// <param name="_startStationIndex">O点对应数组下标</param>
            /// <param name="_endStationIndex">D点对应数组下标</param>
            /// <param name="_oStation">O点</param>
            /// <param name="_dStation">D点</param>
            /// <param name="_xchromosome">上层解个体</param>
            /// <returns>满意度值</returns>
            double SatisficationValue(int _trainType, int _costLevel, int _sectionIndex, int _startStationIndex,
               int _endStationIndex, int _oStation, int _dStation, Chromosome _xchromosome)
            {
                double ticketSatiVal = 0;//票价满意度
                double timeSatiVal = 0;//时间满意度
                double distance = IJDistance(_oStation, _dStation);//OD距离
                                                                               //若为一站直达列车
                if (_trainType == 1)
                {
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * 1.0 * distance / velocity;
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * 1.0 * distance / velocity;
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * 1.0 * distance / velocity;
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为大站停列车
                else if (_trainType == 2)
                {
                    int middleStop = 0;
                    for (int i = 0; i < bigStation.Length; i++)
                    {
                        if (_oStation < bigStation[i] && bigStation[i] < _dStation)
                        {
                            middleStop += 1;
                        }
                    }
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为择站停列车
                else if (_trainType == 3)
                {
                    int middleStop = 0;
                    for (int i = _startStationIndex + 1; i < _endStationIndex; i++)
                    {
                        if (_xchromosome.x[_sectionIndex][i] == 1)
                        {
                            middleStop += 1;
                        }
                    }
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为站站停列车
                else
                {
                    int middleStop = 0;
                    if (_xchromosome.x[_sectionIndex].Length == 2)
                        middleStop = 0;
                    else
                        middleStop = _endStationIndex - _startStationIndex - 1;
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
            }
    
            /// <summary>
            /// QPSO程序迭代器
            /// </summary>
            /// <param name="_particles">粒子种群</param>
            /// <param name="_costLevel">消费层次</param>
            /// <param name="_strategySets">可选策略集</param>
            /// <param name="_sectionIndex">开行区段索引下标</param>
            /// <param name="_startStationIndex">O点对应数组下标</param>
            /// <param name="_endStationIndex">D点对应数组下标</param>
            /// <param name="_oStation">O点</param>
            /// <param name="_dStation">D点</param>
            /// <param name="_xchromosome">上层解个体</param>
            void RunIteration(Particles[] _particles, int _costLevel, List<int> _strategySets,
                int _sectionIndex, int _startStationIndex, int _endStationIndex, int _oStation,
                int _dStation, Chromosome _xchromosome)
            {
                //字段
                double a;//QPSO迭代式中的收缩-扩张系数值
                double douMax;//群体最大值
                int douMaxIndex;//群体最大值下标
                double douGest;//客流个体的较优策略--QPSO迭代式中的局部吸引子
                double douMBest;//QPSO迭代式中的平均最好位置
                double u;//QPSO迭代式中的随机变量,服从U(0,1)
                double b;//QPSO迭代式中的特征长度
                double v;//QPSO迭代式中的Log值
                double z;//迭代结果小数部分
    
                //循环迭代
                double[] douBestStrategy = new double[_strategySets.Count];//各个策略对应赢得函数值
                double douValueStrategy = double.MaxValue;//最优策略函数值
                int douIndexStrategy = -1;//最优策略
                for (int i = 0; i < douBestStrategy.Length; i++)//寻找最优策略及其下标
                {
                    douBestStrategy[i] = SatisficationValue(_strategySets[i], _costLevel,
                        _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                    if (douBestStrategy[i] < douValueStrategy)
                    {
                        douValueStrategy = douBestStrategy[i];
                        douIndexStrategy = i;
                    }
                }
                int t = 0;
                while (t <= int.MaxValue)//循环迭代,寻找纳什均衡策略
                {
                    a = (1.0 - 0.5) * (int.MaxValue - t) / int.MaxValue + 0.5;//收缩-扩张系数值
                    douMax = _particles[0].fitness;
                    douMaxIndex = 0;
                    //寻找适应度值最差粒子
                    for (int i = 1; i < _particles.Length; i++)
                    {
                        if (_particles[i].fitness > douMax)
                        {
                            douMax = _particles[i].fitness;
                            douMaxIndex = i;
                        }
                    }
                    //迭代公式
                    douGest = 0;
                    douMBest = 0;
                    if (_costLevel == 1)
                    {
                        douGest = gbest1[douMaxIndex];
                    }
                    else if (_costLevel == 2)
                    {
                        douGest = gbest2[douMaxIndex];
                    }
                    else
                    {
                        douGest = gbest3[douMaxIndex];
                    }
                    for (int i = 0; i < _particles.Length; i++)
                    {
                        douMBest += _particles[i].x;
                    }
                    douMBest = douMBest * 1.0 / _particles.Length;
                    u = rand.NextDouble();
                    b = 2 * a * Math.Abs(douMBest - _particles[douMaxIndex].x);
                    v = Math.Log(1.0 / u);
                    z = ((douGest + (b / 2) * v) * 1.0) % Math.Floor(douGest + (b / 2) * v);
                    //更新粒子位置
                    if (z > rand.NextDouble())
                        _particles[douMaxIndex].x = (int)Math.Floor(douGest + b * v);
                    else
                        _particles[douMaxIndex].x = (int)Math.Floor(douGest - b * v);
                    //粒子位置限制在搜索范围内
                    bool inContainStrategySets = false;//粒子更新解是否包含在策略空间中
                                                       //若粒子更新解不在策略空间中,则在策略空间中选择较优策略
                    for (int i = 0; i < _strategySets.Count; i++)
                    {
                        if (_particles[douMaxIndex].x == _strategySets[i])
                        {
                            inContainStrategySets = true;
                            break;
                        }
                    }
                    if (inContainStrategySets == false)
                    {
                        _particles[douMaxIndex].x = _strategySets[douIndexStrategy];
                    }
                    _particles[douMaxIndex].fitness = SatisficationValue(_particles[douMaxIndex].x,
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                    if (_costLevel == 1)
                    {
                        gbestfitness1 = SatisficationValue(gbest1[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness1)
                        {
                            gbest1[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest1[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    else if (_costLevel == 2)
                    {
                        gbestfitness2 = SatisficationValue(gbest2[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness2)
                        {
                            gbest2[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest2[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    else
                    {
                        gbestfitness3 = SatisficationValue(gbest3[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness3)
                        {
                            gbest3[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest3[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    bool intNashNum = true;//判断是否实现了纳什均衡
                    if (_costLevel == 1)
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest1[i] != gbest1[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    else if (_costLevel == 2)
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest2[i] != gbest2[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest3[i] != gbest3[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    if (intNashNum == false)
                    {
                        t++;
                    }
                    else
                    {
                        break;
                    }
                }
                //写入数据集ds中
                dt = new DataTable();
                //构建表结构
                dt.Columns.Add("Factors", typeof(Int32));
                dt.Columns.Add("1", typeof(Int32));
                dt.Columns.Add("2", typeof(Int32));
                dt.Columns.Add("3", typeof(Int32));
                dt.Columns.Add("4", typeof(Int32));
                DataRow dr;
                for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
                {
                    dr = dt.NewRow();
                    dr[0] = i + 1;
                    for (int j = 1; j < dt.Columns.Count; j++)
                    {
                        dr[j] = 0;
                    }
                    dt.Rows.Add(dr);
                }
                int intColumn = 0;
                if (_costLevel == 1)
                {
                    intColumn = gbest1[0];
                }
                else if (_costLevel == 2)
                {
                    intColumn = gbest2[0];
                }
                else
                {
                    intColumn = gbest3[0];
                }
                dt.Rows[_sectionIndex][intColumn] = _particles.Length;
                ds[upperSolutionIndex].Tables.Add(dt);
                ds[upperSolutionIndex].Tables[ds[upperSolutionIndex].Tables.Count - 1].TableName =
                    _oStation.ToString() + "-" + _dStation + "g" + _costLevel.ToString() + "Customer";
            }
    
            /// <summary>
            /// 列车开行频率
            /// </summary>
            /// <returns>列车开行数量</returns>
            internal int[,] TrainRunningFrequency(DataSet _ds)
            {
                int[,] intqT = new int[NSGA_.pLNum, NSGA_Ⅱ.trainType];//列车开行频率
    
                int intMaxValue;//区间最大客流量
    
                int[] sectionStation;//开行区段站点集合
                int[] sectionCustomer;//乘坐某一类列车的各区间客流数集合
                for (int i = 0; i < trainDepartureSection.GetLength(0); i++)
                {
                    intMaxValue = 0;
                    sectionStation = new int[trainDepartureSection[i].Length];
                    sectionCustomer = new int[trainDepartureSection[i].Length - 1];
                    for (int j = 0; j < sectionStation.Length; j++)
                    {
                        sectionStation[j] = trainDepartureSection[i][j];
                    }
    
                    for (int m = 0; m < intqT.GetLength(1); m++)
                    {
                        int douValueCustomer;//区间客流总和
                        string strTableName1 = "";//表名
                        string strTableName2 = "";
                        string strTableName3 = "";
                        for (int j = 0; j < sectionCustomer.Length; j++)
                        {
                            douValueCustomer = 0;
                            for (int k = 0; k <= j; k++)
                            {
                                for (int l = j + 1; l < sectionStation.Length; l++)
                                {
                                    strTableName1 = sectionStation[k].ToString() + "-" +
                                   sectionStation[l].ToString() + "g1Customer";
                                    strTableName2 = sectionStation[k].ToString() + "-" +
                                        sectionStation[l].ToString() + "g2Customer";
                                    strTableName3 = sectionStation[k].ToString() + "-" +
                                        sectionStation[l].ToString() + "g3Customer";
                                    for (int p = 0; p < intqT.GetLength(0); p++)
                                    {
                                        douValueCustomer += Convert.ToInt32(_ds.Tables[strTableName1].Rows[p][m + 1]) +
                                        Convert.ToInt32(_ds.Tables[strTableName2].Rows[p][m + 1]) +
                                         Convert.ToInt32(_ds.Tables[strTableName3].Rows[p][m + 1]);
                                    }
                                }
                            }
                            sectionCustomer[j] = douValueCustomer;
                        }
                        intMaxValue = sectionCustomer[0];
                        for (int j = 1; j < sectionCustomer.Length; j++)
                        {
                            if (sectionCustomer[j] > intMaxValue)
                            {
                                intMaxValue = sectionCustomer[j];
                            }
                        }
                        intqT[i, m] = Convert.ToInt32(Math.Floor(intMaxValue * douCustomerFluctuateRate / (seatNum * (alphMax + alphMin) / 2)));
                    }
                }
                return intqT;
            }
        }
    

    3.编写求解下层非合作博弈的QPSO算法,各算子针对模型设计

     public class LowerCustomerAssigned
        {
            internal List<Chromosome> iterValue = new List<Chromosome>();//输出对象
            public struct Particles  //定义粒子的结构体
            {
                public int x;//粒子当前位置(选择的列车种类)
                public double fitness;//粒子的当前位置适应值
            }
    
            //全局变量定义
            static int popsize1;//消费水平层次为1的群体规模
            static int popsize2;//消费水平层次为2的群体规模
            static int popsize3;//消费水平层次为3的群体规模
    
            Particles[] g1Particles;//消费水平层次为1的客流个体集合
            Particles[] g2Particles;//消费水平层次为2的客流个体集合
            Particles[] g3Particles;//消费水平层次为3的客流个体集合
    
            int[] gbest1;//消费层次为1的客流局势
            int[] gbest2;//消费层次为2的客流局势
            int[] gbest3;//消费层次为3的客流局势
    
            double gbestfitness1;//消费水平层次为1的赢得函数值
            double gbestfitness2;//消费水平层次为2的赢得函数值
            double gbestfitness3;//消费水平层次为3的赢得函数值
    
            Random rand = new Random();//随机数产生器       
    
            LinkExcel _linkExcel = new LinkExcel();//表读取对象
            internal int upperSolutionIndex = 0;//上层解粒子下标索引
            DataTable dt = new DataTable();//数据表
            internal DataSet[] ds;//数据集
            //string _strDataPath = "客流数据.xlsx";//数据所在相对位置
    
            //下层客流博弈分配全局变量
            double w1 = 200, w2 = 100, w3 = 50;//各消费层次客流时间价值系数
            double lamda11 = 0.1, lamda12 = 0.9;//消费层次等级为1的客流的权重系数
            double lamda21 = 0.5, lamda22 = 0.5;//消费层次等级为2的客流的权重系数
            double lamda31 = 0.9, lamda32 = 0.1;//消费层次等级为3的客流的权重系数
            //double violationM = 50000;//惩罚函数值
            double velocity = 250;//列车速度值
            double timeAverage = 4;//在站停留平均时间
            int[] bigStation = new int[] { 1, 5, 22 };//客流量较大站点集合
            double[,] ticketRate = new double[,] { { 0.9, 0.8, 0.7, 0.6 }, { 0.6, 0.5, 0.4, 0.3 }, { 0.4, 0.3, 0.2, 0.1 } };//票价率
            internal NSGA_Ⅱ upperObject = new NSGA_();//上层对象
    
            //方法定义
            int sectionIndex = 0;//客流博弈所在开行区段下标
            List<int> sectionListIndexSets = new List<int>();//始发、终到站均含于相同开行区段的开行区段下标集合
            List<int> strategySets = new List<int>();//策略集
    
    
            /// <summary>
            /// OD客流选择列车出行博弈方法
            /// </summary>
            /// <param name="xchromosome">上层解粒子</param>
            /// <param name="g1CustomerNum">消费层次为1的OD客流规模</param>
            /// <param name="g2CustomerNum">消费层次为2的OD客流规模</param>
            /// <param name="g3CustomerNum">消费层次为3的OD客流规模</param>
            /// <param name="startStation">O点</param>
            /// <param name="endStation">D点</param>
            internal void customersAssigned(Chromosome xchromosome, int g1CustomerNum, int g2CustomerNum,
                int g3CustomerNum, int startStation, int endStation)
            {
                sectionIndex = 0;//开行区段索引赋初值
                sectionListIndexSets.Clear();//清空开行区段索引集合
                strategySets.Clear();//清空策略集
                for (int i = 0; i < xchromosome.x.GetLength(0); i++)//填充均包含O、D的开行区段下标集合
                {
                    if (upperObject.trainDepartureSection[i][0] <= startStation &&
                        upperObject.trainDepartureSection[i][xchromosome.x[i].Length - 1] >= endStation)
                    {
                        sectionListIndexSets.Add(i);
                    }
                }
                //随机选择一个同时包含起始、终点站的列车开行区段
                sectionIndex = sectionListIndexSets[rand.Next(sectionListIndexSets.Count)];
                //填充策略集StrategySets
                //--一站直达
                if (startStation == upperObject.trainDepartureSection[sectionIndex][0] &&
                     endStation == upperObject.trainDepartureSection[sectionIndex][upperObject.trainDepartureSection[sectionIndex].Length - 1])
                {
                    strategySets.Add(1);
                }
                //--大站停
                int isAllbigStation = 0;//指标--指示OD客流是否可以乘坐大站停列车完成出现
                for (int i = 0; i < bigStation.Length; i++)
                {
                    if (startStation == bigStation[i])
                    {
                        isAllbigStation += 1;
                        continue;
                    }
                    if (endStation == bigStation[i])
                    {
                        isAllbigStation += 1;
                        break;
                    }
                }
                if (isAllbigStation == 2)
                {
                    strategySets.Add(2);
                }
                //--择站停
                int startStationIndex = 0;//客流出发站的站点在x解集中对应的下标
                int endStationIndex = 0;//客流终到站的站点在x解集中对应的下标
                for (int i = 0; i < upperObject.trainDepartureSection[sectionIndex].Length; i++)
                {
                    if (upperObject.trainDepartureSection[sectionIndex][i] == startStation)
                    {
                        startStationIndex = i;
                        continue;
                    }
                    if (upperObject.trainDepartureSection[sectionIndex][i] == endStation)
                    {
                        endStationIndex = i;
                        break;
                    }
                }
                if (xchromosome.x[sectionIndex][startStationIndex] == 1 && xchromosome.x[sectionIndex][endStationIndex] == 1)
                    strategySets.Add(3);
                //--站站停:对OD(始发站为startStation,终点站为endStation)来说,站站停列车为必备策略
                strategySets.Add(4);
    
    
                //客流列车分配初始化
                popsize1 = g1CustomerNum;//初始化各消费层次客流规模
                popsize2 = g2CustomerNum;
                popsize3 = g3CustomerNum;
    
                g1Particles = new Particles[popsize1];//创建各消费层次客流集合
                g2Particles = new Particles[popsize2];
                g3Particles = new Particles[popsize3];
    
                gbest1 = new int[popsize1];//创建各消费层次客流局势
                gbest2 = new int[popsize2];
                gbest3 = new int[popsize3];
    
    
                //分情况初始化各消费层次客流出行列车选择
                if (strategySets.Count == 1)
                {
                    //消费层次为1的客流初始化
                    g1Particles[0].x = strategySets[0];
                    gbest1[0] = g1Particles[0].x;
                    g1Particles[0].fitness = SatisficationValue(g1Particles[0].x, 1, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize1; i++)
                    {
                        g1Particles[i].x = g1Particles[0].x;
                        g1Particles[i].fitness = g1Particles[0].fitness;
                        gbest1[i] = g1Particles[i].x;
                    }
                    //消费层次为2的客流初始化
                    g2Particles[0].x = strategySets[0];
                    gbest2[0] = g2Particles[0].x;
                    g2Particles[0].fitness = SatisficationValue(g2Particles[0].x, 2, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize2; i++)
                    {
                        g2Particles[i].x = g2Particles[0].x;
                        g2Particles[i].fitness = g2Particles[0].fitness;
                        gbest2[i] = g2Particles[i].x;
                    }
                    //消费层次为3的客流初始化
                    g3Particles[0].x = strategySets[0];
                    gbest3[0] = g3Particles[0].x;
                    g3Particles[0].fitness = SatisficationValue(g3Particles[0].x, 3, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                    for (int i = 1; i < popsize3; i++)
                    {
                        g3Particles[i].x = g3Particles[0].x;
                        g3Particles[i].fitness = g3Particles[0].fitness;
                        gbest3[i] = g3Particles[i].x;
                    }
                }
                else
                {
                    //消费层次为1的客流初始化
                    double douValue = 0;
                    for (int i = 0; i < popsize1; i++)
                    {
                        g1Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g1Particles[i].fitness = SatisficationValue(g1Particles[i].x, 1, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest1[i] = g1Particles[i].x;
                        douValue += g1Particles[i].fitness;
                    }
                    //消费层次为2的客流初始化
                    douValue = 0;
                    for (int i = 0; i < popsize2; i++)
                    {
                        g2Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g2Particles[i].fitness = SatisficationValue(g2Particles[i].x, 2, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest2[i] = g2Particles[i].x;
                        douValue += g2Particles[i].fitness;
                    }
                    //消费层次为3的客流初始化
                    douValue = 0;
                    for (int i = 0; i < popsize3; i++)
                    {
                        g3Particles[i].x = strategySets[rand.Next(strategySets.Count)];
                        g3Particles[i].fitness = SatisficationValue(g3Particles[i].x, 3, sectionIndex, startStationIndex,
                            endStationIndex, startStation, endStation, xchromosome);
                        gbest3[i] = g3Particles[i].x;
                        douValue += g3Particles[i].fitness;
                    }
                }
    
                //算法开始迭代
                RunIteration(g1Particles, 1, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
                RunIteration(g2Particles, 2, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
                RunIteration(g3Particles, 3, strategySets, sectionIndex, startStationIndex, endStationIndex,
                    startStation, endStation, xchromosome);
            }
    
    
            /// <summary>
            /// 铁路旅客满意度评价函数
            /// </summary>
            /// <param name="_trainType">列车种类</param>
            /// <param name="_costLevel">消费层次</param>
            /// <param name="_sectionIndex">博弈区段下标</param>
            /// <param name="_startStationIndex">O点对应数组下标</param>
            /// <param name="_endStationIndex">D点对应数组下标</param>
            /// <param name="_oStation">O点</param>
            /// <param name="_dStation">D点</param>
            /// <param name="_xchromosome">上层解个体</param>
            /// <returns>满意度值</returns>
            double SatisficationValue(int _trainType, int _costLevel, int _sectionIndex, int _startStationIndex,
               int _endStationIndex, int _oStation, int _dStation, Chromosome _xchromosome)
            {
                double ticketSatiVal = 0;//票价满意度
                double timeSatiVal = 0;//时间满意度
                double distance = upperObject.IJDistance(_oStation, _dStation);//OD距离
                //若为一站直达列车
                if (_trainType == 1)
                {
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * 1.0 * distance / velocity;
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * 1.0 * distance / velocity;
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * 1.0 * distance / velocity;
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为大站停列车
                else if (_trainType == 2)
                {
                    int middleStop = 0;
                    for (int i = 0; i < bigStation.Length; i++)
                    {
                        if (_oStation < bigStation[i] && bigStation[i] < _dStation)
                        {
                            middleStop += 1;
                        }
                    }
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为择站停列车
                else if (_trainType == 3)
                {
                    int middleStop = 0;
                    for (int i = _startStationIndex + 1; i < _endStationIndex; i++)
                    {
                        if (_xchromosome.x[_sectionIndex][i] == 1)
                        {
                            middleStop += 1;
                        }
                    }
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
                //若为站站停列车
                else
                {
                    int middleStop = 0;
                    if (_xchromosome.x[_sectionIndex].Length == 2)
                        middleStop = 0;
                    else
                        middleStop = _endStationIndex - _startStationIndex - 1;
                    ticketSatiVal = ticketRate[_costLevel - 1, _trainType - 1] * distance;
                    if (_costLevel == 1)
                    {
                        timeSatiVal = w1 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda11 * ticketSatiVal + lamda12 * timeSatiVal;
                    }
                    else if (_costLevel == 2)
                    {
                        timeSatiVal = w2 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda21 * ticketSatiVal + lamda22 * timeSatiVal;
                    }
                    else
                    {
                        timeSatiVal = w3 * (1.0 * distance / velocity + timeAverage * middleStop);
                        return lamda31 * ticketSatiVal + lamda32 * timeSatiVal;
                    }
                }
            }
    
    
            /// <summary>
            /// QPSO程序迭代器
            /// </summary>
            /// <param name="_particles">粒子种群</param>
            /// <param name="_costLevel">消费层次</param>
            /// <param name="_strategySets">可选策略集</param>
            /// <param name="_sectionIndex">开行区段索引下标</param>
            /// <param name="_startStationIndex">O点对应数组下标</param>
            /// <param name="_endStationIndex">D点对应数组下标</param>
            /// <param name="_oStation">O点</param>
            /// <param name="_dStation">D点</param>
            /// <param name="_xchromosome">上层解个体</param>
            void RunIteration(Particles[] _particles, int _costLevel, List<int> _strategySets,
                int _sectionIndex, int _startStationIndex, int _endStationIndex, int _oStation,
                int _dStation, Chromosome _xchromosome)
            {
                //字段
                double a;//QPSO迭代式中的收缩-扩张系数值
                double douMax;//群体最大值
                int douMaxIndex;//群体最大值下标
                double douGest;//客流个体的较优策略--QPSO迭代式中的局部吸引子
                double douMBest;//QPSO迭代式中的平均最好位置
                double u;//QPSO迭代式中的随机变量,服从U(0,1)
                double b;//QPSO迭代式中的特征长度
                double v;//QPSO迭代式中的Log值
                double z;//迭代结果小数部分
    
                //循环迭代
                double[] douBestStrategy = new double[_strategySets.Count];//各个策略对应赢得函数值
                double douValueStrategy = double.MaxValue;//最优策略函数值
                int douIndexStrategy = -1;//最优策略
                for (int i = 0; i < douBestStrategy.Length; i++)//寻找最优策略及其下标
                {
                    douBestStrategy[i] = SatisficationValue(_strategySets[i], _costLevel,
                        _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                    if (douBestStrategy[i] < douValueStrategy)
                    {
                        douValueStrategy = douBestStrategy[i];
                        douIndexStrategy = i;
                    }
                }
                int t = 0;
                while (t <= int.MaxValue)//循环迭代,寻找纳什均衡策略
                {
                    a = (1.0 - 0.5) * (int.MaxValue - t) / int.MaxValue + 0.5;//收缩-扩张系数值
                    douMax = _particles[0].fitness;
                    douMaxIndex = 0;
                    //寻找适应度值最差粒子
                    for (int i = 1; i < _particles.Length; i++)
                    {
                        if (_particles[i].fitness > douMax)
                        {
                            douMax = _particles[i].fitness;
                            douMaxIndex = i;
                        }
                    }
                    //迭代公式
                    douGest = 0;
                    douMBest = 0;
                    if (_costLevel == 1)
                    {
                        douGest = gbest1[douMaxIndex];
                    }
                    else if (_costLevel == 2)
                    {
                        douGest = gbest2[douMaxIndex];
                    }
                    else
                    {
                        douGest = gbest3[douMaxIndex];
                    }
                    for (int i = 0; i < _particles.Length; i++)
                    {
                        douMBest += _particles[i].x;
                    }
                    douMBest = douMBest * 1.0 / _particles.Length;
                    u = rand.NextDouble();
                    b = 2 * a * Math.Abs(douMBest - _particles[douMaxIndex].x);
                    v = Math.Log(1.0 / u);
                    z = ((douGest + (b / 2) * v) * 1.0) % Math.Floor(douGest + (b / 2) * v);
                    //更新粒子位置
                    if (z > rand.NextDouble())
                        _particles[douMaxIndex].x = (int)Math.Floor(douGest + b * v);
                    else
                        _particles[douMaxIndex].x = (int)Math.Floor(douGest - b * v);
                    //粒子位置限制在搜索范围内
                    bool inContainStrategySets = false;//粒子更新解是否包含在策略空间中
                                                       //若粒子更新解不在策略空间中,则在策略空间中选择较优策略
                    for (int i = 0; i < _strategySets.Count; i++)
                    {
                        if (_particles[douMaxIndex].x == _strategySets[i])
                        {
                            inContainStrategySets = true;
                            break;
                        }
                    }
                    if (inContainStrategySets == false)
                    {
                        _particles[douMaxIndex].x = _strategySets[douIndexStrategy];
                    }
                    _particles[douMaxIndex].fitness = SatisficationValue(_particles[douMaxIndex].x,
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                    if (_costLevel == 1)
                    {
                        gbestfitness1 = SatisficationValue(gbest1[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness1)
                        {
                            gbest1[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest1[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    else if (_costLevel == 2)
                    {
                        gbestfitness2 = SatisficationValue(gbest2[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness2)
                        {
                            gbest2[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest2[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    else
                    {
                        gbestfitness3 = SatisficationValue(gbest3[douMaxIndex],
                        _costLevel, _sectionIndex, _startStationIndex, _endStationIndex, _oStation,
                        _dStation, _xchromosome);
                        if (_particles[douMaxIndex].fitness < gbestfitness3)
                        {
                            gbest3[douMaxIndex] = _particles[douMaxIndex].x;
                        }
                        else
                        {
                            gbest3[douMaxIndex] = _strategySets[douIndexStrategy];
                        }
                    }
                    bool intNashNum = true;//判断是否实现了纳什均衡
                    if (_costLevel == 1)
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest1[i] != gbest1[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    else if (_costLevel == 2)
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest2[i] != gbest2[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        for (int i = 1; i < _particles.Length; i++)
                        {
                            if (gbest3[i] != gbest3[0])
                            {
                                intNashNum = false;
                                break;
                            }
                        }
                    }
                    if (intNashNum == false)
                    {
                        t++;
                    }
                    else
                    {
                        break;
                    }
                }
                //写入数据集ds中
                dt = new DataTable();
                //构建表结构
                dt.Columns.Add("Factors", typeof(Int32));
                dt.Columns.Add("1", typeof(Int32));
                dt.Columns.Add("2", typeof(Int32));
                dt.Columns.Add("3", typeof(Int32));
                dt.Columns.Add("4", typeof(Int32));
                DataRow dr;
                for (int i = 0; i < upperObject.trainDepartureSection.GetLength(0); i++)
                {
                    dr = dt.NewRow();
                    dr[0] = i + 1;
                    for (int j = 1; j < dt.Columns.Count; j++)
                    {
                        dr[j] = 0;
                    }
                    dt.Rows.Add(dr);
                }
                int intColumn = 0;
                if (_costLevel == 1)
                {
                    intColumn = gbest1[0];
                }
                else if (_costLevel == 2)
                {
                    intColumn = gbest2[0];
                }
                else
                {
                    intColumn = gbest3[0];
                }
                dt.Rows[_sectionIndex][intColumn] = _particles.Length;
                ds[upperSolutionIndex].Tables.Add(dt);
                ds[upperSolutionIndex].Tables[ds[upperSolutionIndex].Tables.Count - 1].TableName =
                    _oStation.ToString() + "-" + _dStation + "g" + _costLevel.ToString() + "Customer";
            }
    
    
            /// <summary>
            /// 双层规划算法迭代
            /// </summary>
            public void BiLevelAlgorithmRunning()
            {
                //下层数据集个数--数量与种群规模一致
                ds = new DataSet[upperObject.chromosomes.Length];
                //上层解粒子索引
                upperSolutionIndex = 0;
                //上层解集初始化
                upperObject.UpperInitation();
    
    
    
    
    
    
    
                //针对每一个上层解,求下层客流分配纳什均衡解及上层函数
                for (int i = 0; i < upperObject.chromosomes.Length; i++)
                {
                    upperSolutionIndex = i;//记录当前上层解粒子索引
                    ds[upperSolutionIndex] = new DataSet();
                    for (int j = 1; j < NSGA_Ⅱ.stationNum; j++)//客流博弈分配
                    {
                        for (int k = j + 1; k <= NSGA_Ⅱ.stationNum; k++)
                        {
                            customersAssigned(upperObject.chromosomes[upperSolutionIndex], upperObject.g1Customer[j - 1, k - 1],
                                upperObject.g2Customer[j - 1, k - 1], upperObject.g3Customer[j - 1, k - 1], j, k);
                        }
                    }
                    //根据旅客分配情况确定列车开行频率
                    upperObject.chromosomes[upperSolutionIndex].Frequent = new int[NSGA_.pLNum, NSGA_Ⅱ.trainType];
                    upperObject.chromosomes[upperSolutionIndex].Frequent = TrainRunningFrequency(ds[upperSolutionIndex]);
                    //根据旅客分配情况确定上层各函数值
                    upperObject.chromosomes[upperSolutionIndex].f = new double[NSGA_.f_num];
                    upperObject.dSCustomer = ds[upperSolutionIndex];
                    upperObject.chromosomes[upperSolutionIndex].f[0] =
                        upperObject.F1Object(upperObject.chromosomes[upperSolutionIndex]);
                    upperObject.chromosomes[upperSolutionIndex].f[1] =
                        upperObject.F2Object(upperObject.chromosomes[upperSolutionIndex]);
                }
                //非支配排序算子
                upperObject.NonDominationSort(upperObject.chromosomes);
                //拥挤度算子
                upperObject.CrowdingDistanceSort(upperObject.f_sort);
                //锦标赛选择算子
                Chromosome[] chro = new Chromosome[upperObject.chromosomes.Length];
                chro = upperObject.TournamentSelection(upperObject.chromosomes);
                //交叉、变异算子
                upperObject.NewChromosomes(chro);
                //下一代种群形成
                upperObject.Elitism(upperObject.f_sort, upperObject.c_sort);
    
    
    
    
    
    
    
                double d = 0;
                //_linkExcel.DSToExcel(_strDataPath, ds);
            }
    
            /// <summary>
            /// 列车开行频率
            /// </summary>
            /// <returns>列车开行数量</returns>
           internal int[,] TrainRunningFrequency(DataSet _ds)
            {
                int[,] intqT = new int[NSGA_.pLNum, NSGA_Ⅱ.trainType];//列车开行频率
    
                int intMaxValue;//区间最大客流量
    
                int[] sectionStation;//开行区段站点集合
                int[] sectionCustomer;//乘坐某一类列车的各区间客流数集合
                for (int i = 0; i < upperObject.trainDepartureSection.GetLength(0); i++)
                {
                    intMaxValue = 0;
                    sectionStation = new int[upperObject.trainDepartureSection[i].Length];
                    sectionCustomer = new int[upperObject.trainDepartureSection[i].Length - 1];
                    for (int j = 0; j < sectionStation.Length; j++)
                    {
                        sectionStation[j] = upperObject.trainDepartureSection[i][j];
                    }
    
                    for (int m = 0; m < intqT.GetLength(1); m++)
                    {
                        int douValueCustomer;//区间客流总和
                        string strTableName1 = "";//表名
                        string strTableName2 = "";
                        string strTableName3 = "";
                        for (int j = 0; j < sectionCustomer.Length; j++)
                        {
                            douValueCustomer = 0;
                            for (int k = 0; k <= j; k++)
                            {
                                for (int l = j + 1; l < sectionStation.Length; l++)
                                {
                                    strTableName1 = sectionStation[k].ToString() + "-" +
                                   sectionStation[l].ToString() + "g1Customer";
                                    strTableName2 = sectionStation[k].ToString() + "-" +
                                        sectionStation[l].ToString() + "g2Customer";
                                    strTableName3 = sectionStation[k].ToString() + "-" +
                                        sectionStation[l].ToString() + "g3Customer";
                                    for (int p = 0; p < intqT.GetLength(0); p++)
                                    {
                                        douValueCustomer += Convert.ToInt32(_ds.Tables[strTableName1].Rows[p][m + 1]) +
                                        Convert.ToInt32(_ds.Tables[strTableName2].Rows[p][m + 1]) +
                                         Convert.ToInt32(_ds.Tables[strTableName3].Rows[p][m + 1]);
                                    }
                                }
                            }
                            sectionCustomer[j] = douValueCustomer;
                        }
                        intMaxValue = sectionCustomer[0];
                        for (int j = 1; j < sectionCustomer.Length; j++)
                        {
                            if (sectionCustomer[j] > intMaxValue)
                            {
                                intMaxValue = sectionCustomer[j];
                            }
                        }
                        intqT[i, m] = Convert.ToInt32(Math.Floor(intMaxValue * upperObject.douCustomerFluctuateRate / (upperObject.seatNum * (upperObject.alphMax + upperObject.alphMin) / 2)));
                    }
                }
                return intqT;
            }
        }
    

    3.运行程序

    private void Form1_Load(object sender, EventArgs e)
            {
                this.Text = "QPSO(Test)";
                this.Icon = new Icon(@"E:\VS2017\Icon\1.ico");
    
                QPSO_Test qPSO_Test = new QPSO_Test();
                qPSO_Test.RunAlgorithm();
    
                double[] value = qPSO_Test.Value();
                double[] gvalue = qPSO_Test.GValue();
    
                chart1.ChartAreas["ChartArea1"].Name = "MyChartArea";
                chart1.ChartAreas["MyChartArea"].AxisX.Interval = 4;
                
    
                chart1.Series[0].ChartArea = "MyChartArea";
                chart1.Series[0].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.Line;
                chart1.Series[0].Name = "每次运行结果";
    
                chart1.Series.Add("MSeries");
                chart1.Series["MSeries"].ChartArea = "MyChartArea";
                chart1.Series["MSeries"].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.FastPoint;
                chart1.Series["MSeries"].Color = Color.Red;
                chart1.Series["MSeries"].Name = "种群迭代结果";
                chart1.Series[1].YAxisType = System.Windows.Forms.DataVisualization.Charting.AxisType.Secondary;
    
                chart1.ChartAreas[0].AxisY2.MajorGrid.Enabled = false;
                chart1.ChartAreas[0].AxisY.MajorGrid.Enabled = false;
                chart1.ChartAreas[0].AxisX.MajorGrid.Enabled = false;
    
                chart1.Titles.Add("量子粒子群测试");
                chart1.Titles[0].Alignment = ContentAlignment.TopCenter;
                chart1.Titles[0].Font = new Font(new FontFamily("Arial"), 12, FontStyle.Bold);
    
                chart1.ChartAreas["MyChartArea"].AxisY2.Title = "第50次运行时种群迭代最佳适应值";
                chart1.ChartAreas["MyChartArea"].AxisY.Title = "每次运行种群最佳适应值";
                chart1.ChartAreas["MyChartArea"].AxisX.Title = "迭代次数";
    
                for (int i = 0; i < 50; i++)
                {
                    chart1.Series[0].Points.AddXY(i + 1, value[i]);
                    chart1.Series[1].Points.AddXY(i + 1, gvalue[i]);
                }
            }
    
    展开全文
  • 基于双层规划理论的移动应用商店利润分成研究,郝建韬,赵蔚,为了提高移动应用商店的盈利能力,对移动应用的供应链条做出分析,并通过双层规划理论建立移动应用的供应链的模型,上层为移动应
  • 针对现有动态火力分配模型未考虑不确定因素及复杂约束的问题,引入不确定规划理论,建立了基于模糊机会约束双层规划的动态火力分配模型.首先,以最大化效费比和尽早拦截分别...

空空如也

空空如也

1 2 3 4 5 6
收藏数 102
精华内容 40
关键字:

双层规划模型