精华内容
下载资源
问答
  • 2012年9月1号

     

    2012年9月1号

     

    展开全文
  • 5GNRNSA精品线路优化指导书-参数优化及保障策略部署分册_R1.8.doc5GNRNSA精品线路优化指导书-参数优化及保障策略部署分册_R1.8.doc5GNRNSA精品线路优化指导书-参数优化及保障策略部署分册_R1.8.doc5GNRNSA精品线路...
  • 华中数模竞赛原创论文 基于运筹学理论的旅游线路优化设计
  • 数学建模题目,关于旅游线路优化设计.华中竞赛题目!
  • 近期碰到一个需求,对蚂蚁群算法在公交线路上的优化处理,很长时间做算法的学习了这里做记录和分享。 对蚂蚁算法大家基本都不陌生,不知道的可以百度一下,我只简单的描述一下关键参数。和商旅问题不同,公交线路...

        近期碰到一个需求,对蚂蚁群算法在公交线路上的优化处理,很长时间做算法的学习了这里做记录和分享。

        对蚂蚁算法大家基本都不陌生,不知道的可以百度一下,我只简单的描述一下关键参数。和商旅问题不同,公交线路基本不做线路的闭环,有明确的起点和终点。我们需要做的是对信息启发因子,期望启发式因子,信息素挥发参数,还有信息素的初始化,公交线路的初始化,然后让每只蚂蚁都从起点出发,进行轮盘赌线路选择下一个站点,判断是否达到终点,更新信息素。输出可以正确到达终点的线路,最后根据线路优化方向输出最短路径,换乘次数最少路径,时间最短路径等。

      涉及的关键点是轮盘赌现在线路和更新信息素,我给出代码片段:

    	//轮盘赌选择线路
    		double probability = -1.0;//转移到下一节点的概率
    		double sum = 0.0;
    		double prob = 0.0; 
    		for(int i = 0; i < N; i++)
    		{
    			if (1 == allowed[i] && 0 != allDistance[cururentSite][i])
    			{
    				sum += antColony->Transition(cururentSite, i);
    			}
    		}
    
    		q = rand()/(double)RAND_MAX;//轮盘概率 
    		
    		for(int i = 0; i < N; i++)
    		{
    			//去掉禁忌表中已走过的节点,从剩下节点中选择最大概率的可行节点
    			if (1 == allowed[i] && 0 != allDistance[cururentSite][i])
    			{
    				prob += antColony->Transition(cururentSite, i)/sum;
    				cout << "蚂蚁选择" << cururentSite + 1 << "-"<<i + 1 <<"的概率为:" << prob*100 << "%" <<endl;
    				if (prob  >= q)
    				{
    					nextSite = i;
    					probability = prob;
    					break;
    				}
    			}
    		}
    
    
    //更新信息素
    
    	for(int i = 0; i < N; i++)
    	{
    		int row = bestTour[i];
    		int col = bestTour[i+1];
    		if(0 != col)
    		{
    			info[row][col] = (1.0 - rou) * info[row][col] + rou * (1.0 / globalBestLength);
    			info[col][row] = info[row][col];
    		}
    	}

     

    展开全文
  • 1. 线路的标题  线路的标题是通过搜索引擎搜索到您线路的最重要的部分,为您的线路取一个符合人们搜索习惯的标题是十分重要的。线路标题至少应包括主要目的地,旅游时间两 个关键词,如“木兰天池三日游”,当然也...
    1. 线路的标题
       线路的标题是通过搜索引擎搜索到您线路的最重要的部分,为您的线路取一个符合人们搜索习惯的标题是十分重要的。线路标题至少应包括主要目的地,旅游时间两 个关键词,如“木兰天池三日游”,当然也可以加上主要交通工具及出发城市等信息,如“苏州至木兰天池双飞四日游”。      
    提示:线路的标题的长度在8-12字左右为佳,切勿将所有的目的地名都呈现在标题中,降低其他关键词的密度。

       建议使用格式:城市+某景点+交通方式+时间

       如:

       优化前:

       海南蜈支洲岛双飞四天纯玩团

       优化后:

       方案1.【海南双飞四天纯玩团】赠送蜈支洲岛、全程无购物
       方案2. 海南蜈支洲岛双飞四日游【厦门出发,纯玩团】
       方案3. <海南双飞四日游> 含蜈支洲岛、纯玩无购物、全程四星酒店
       方案4. 海南蜈支洲岛双飞四日游(纯玩无购物、全程四星酒店)


    2、关键词密度的合理掌握
       合理的在你的文中添加你想要做的关键词,一般一个网页的关键词密度应占据该网页所有字符的15%以内,堆砌的关键词超过这个密度。反而会造成反效果,关键词可能的话加粗或者更换颜色,可以更好的吸引搜索引擎。

    3、避开热门关键词
       选择边缘词,现在是清明节前,在百度清明 旅游这一关键词竞争相当激烈。在逢年过节或当地特殊项目上下点功夫往往会有意想不到的效果。 也许在平时,网友搜索“xxx几日游”或“xxx旅游报价”会比较热门,但是在节日的时候,往往搜索“清明游”,“情人节旅游”等会更热门,当然对于当地 的特殊项目,如“滑雪游”、“温泉游”在某些时候也会比较热门。因此,关注旅游的热点,配合热点制作带有热点的线路标题,线路内容,线路目的地,效果会非 常不错。

    4、线路的主体内容的编写
       除了多突出您线路的关键词,譬如景点名、线路名、旅行社名等外,还要注意不要直接将word文档中的文字内容或表格内容复制到线路发布框中,这样做虽然简单,但是会将word中许多冗余的字体字号颜色代码一同生成在线路页面中,使搜索引擎爬取页面时的干扰信息增多。可以将word文档中的内容先复制到windows的记事本中,然后再从记事本复制到线路发布框,这样冗余代码就不存在了。    

    5、线路内容的更新
       线路已经被百度收录,当该线路新的信息需要更新时,切勿将原有线路删除,只需在原有的线路上编辑修改即可,这样当百度更新您的页面时,它会认为这个页面在更新,是有生命力的。发布的线路要经常更新,若线路的信息过时而得不到更新,会很难获得好的排名。
    展开全文
  • 数据结构--公交线路优化查询

    千次阅读 2020-05-02 00:03:10
    数据结构: //建立结构体 //站点 //:站点名 站点位置 (计算距离) struct site//站点 ...//线路 //: 发车时间间隔 车速 站点数 站点 struct route//路线 { int route_num;//线路号 int ticket_pr...

    在这里插入图片描述
    在这里插入图片描述
    问题分析:
    1.建立合适的图模型
    2.根据不同的优化查询调整dij
    dij算法的设计思路:
    大体思想:
    设S是被探查的结点的集合,U是G中除S外的结点集合,初始时,S={s},d(s) =0,若s到U中的结点u有边,则d(u)=边上的权值或长度(具体自己定义),如果没有边,则d(u)=∞
    a.从U中选择一个到s距离最小的顶点v,将v加入到S中,此时的距离d(v)就是s到v的最短路径
    b.以v为中间结点,重新考虑s到U中的各个结点的距离;如果通过v到U中的结点u的距离比原来不通过v的更小,则更新这个距离值,否则不更新
    c.重复a、b直到所有结点都被包含到S中
    那么如何去优化?
    主要操作是a,b,所以先对a,b两个步骤进行初始的优化:
    a:每次选择最短路径,依次遍历o(n),排序操作基本都是o(nlogn),有没有可以降到o(logn),所以可以选择最小堆minheap
    b考虑的是s到U中的各个结点,那么想想其实可能得到更新的都是s的邻接点,所以这里可以遍历邻接点。

    数据结构的选择:
    图的存储:邻接表(边数不多的情况下)
    存储节点以及节点与初始点的距离:最小堆
    最优路径np_r [1:n] np_v[1:n] //线路号 站点号

    数据定义:
    //站点

    struct site//站点 
    {
    	char name;
    	T x_position;
    	T y_position;
    }
    

    //线路

    struct route//路线 
    {   
        int route_num;//线路号  
        int ticket_price;//票价 
        int dep_ti_interval;//发车时间间隔
        int speed;//车速
        int site_num;//站点数
        site<T> *sit;//站点数组
        route()	{}
        void rout()
        {
        	sit=new site<T>[site_num+5];
    	}
    };
    

    //站点与发车站的距离

    struct po//站点
    {//记录站点的距离初始站和终点站的距离
    	map<int,pair<double,double>>mp;//加快查找速度
    }point[100];
    

    //存图链表节点

    struct chainNode 
    {
            
       int sit_num; //顶点号
       int route_num;//线路号
       double disval;//边距离 
       double timval;//边时间 
       int priceval;//边票价 
       int dep_ti_interval;//发车间隔
       bool index;//标志线路的正反
       chainNode *next;//下一个节点
    };
    

    //将信息转化成图的信息//图类(进行加边、求路径)
    //邻接表 数组+链表
    //插入操作每次插入firstNode,时间复杂度降到o(1)

    class chain 
    {
       public:
       	  chainNode* firstNode;    
    	  int listsize;  
          chain();
          ~chain();
          //存图时插入节点信息
          void insert(int v2,int rout_num,double disv,double timv,int priv,int d_i,bool index);
          int size() {return listsize; }      
    };
    class linkedGraph
    {
    	 protected:                  
          chain *aList;   //存图 
    	  int np_v[100];//记录前驱节点
    	  int np_r[100];//记录点与边所在的线路号
    	 public:
    	  linkedGraph();
    	  ~linkedGraph();
    	  //插入边
    	  void insertEdge(int v1,int v2,int rout_num,double disv,double timv,int priv,int d_i,double d_h1,double d_h2);
    	  //Dijkstra过程
    	  void dij(int s,int _dij,int t);
    	  void print(int t);
     }    
    

    预处理操作:
    预处理数据,进行存图:
    1.进行距离的计算,得出disval;
    2.进行时间的计算,得出timval;
    3.进行线路的正反向判断,并计算正反向的到达时间dep_he;

    void init(linkedGraph& li)
    {  //<100条线路
        cout<<"请输入线路的个数:"<<endl;
        int num;cin>>num;route<int>rt[100];
    	for(int i=1;i<=num;i++)
    	{
    		cout<<"请输入第"<<i<<"条线路号:"<<endl;cin>>rt[i].route_num;
    		cout<<"请输入该条线路站点的个数:"<<endl;cin>>rt[i].site_num;rt[i].rout();
    		cout<<"请输入站点名称及位置坐标:(站点名称用大写字母表示,从'A'开始命名)"<<endl; 
    		for(int j=0;j<rt[i].site_num;j++)
    		{
    			cin>>rt[i].sit[j].name;cin>>rt[i].sit[j].x_position;cin>>rt[i].sit[j].y_position;
    		}cout<<"请输入发车时间间隔及车速和票价:"<<endl;cin>>rt[i].dep_ti_interval>>rt[i].speed>>rt[i].ticket_price;
    	    double dep_he[100];double ddisval[100];double  timval[100];memset(dep_he,0,sizeof(dep_he));memset(ddisval,0,sizeof(ddisval));
    	    memset(timval,0,sizeof(timval));
    		for(int j=0;j<rt[i].site_num-1;j++)
    		{
    		    ddisval[j]=sqrt(pow((rt[i].sit[j+1].x_position-rt[i].sit[j].x_position),2)+pow((rt[i].sit[j+1].y_position-rt[i].sit[j].y_position),2));
    			timval[j]=ddisval[j]/rt[i].speed;//cout<<rt[i].sit[j].name-'A'<<" "<<timval<<" "<<rt[i].sit[j+1].name-'A'<<endl;
    			if(j==0)dep_he[j]=timval[j];else dep_he[j]=dep_he[j-1]+timval[j];
    		}point[rt[i].sit[0].name-'A'].mp[rt[i].route_num]=make_pair(0,dep_he[rt[i].site_num-2]);
    		for(int j=0;j<rt[i].site_num-1;j++)
    		{
    			li.insertEdge(rt[i].sit[j].name-'A',rt[i].sit[j+1].name-'A',rt[i].route_num,ddisval[j],timval[j],rt[i].ticket_price,rt[i].dep_ti_interval,dep_he[j],dep_he[rt[i].site_num-2]-dep_he[j]);	
    		}	
    	 } 
    }
    

    //插入或者查找时都选择了空间换时间
    dijkstra实现思路:
    //:最小堆 邻接点 标记数组
    //:最短路径 ,直接跑dij

     if(dis[now->sit_num]>dis[x]+now->disval)
    	  {
    	 dis[now->sit_num]=dis[x]+now->disval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	 q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num;  
    	}	
    

    //:最小时间 (不考虑等车)

    if(dis[now->sit_num]>dis[x]+now->timval)
    		{
    		dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	 	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    		 }
    

    //:最小时间 (考虑等车) 利用结构体struct point 记录 mp[id]=pair<double, double> 然后存点时正向1反向 0区分一下,根据中转站u的下一个点获得1/0,根据u找到point[u].mid[u.route_num].first/point[u].mid[u.route_num].second ,获取该线路车发站到中转站的时间t,然后根据该线路发车间隔dep_ti_interval和到达该站已经经过的时间dis[u],计算需要等待的时间

    +画个图举个例子:

    松弛操作:
                        if(np_r[x]==now->route_num)//同条线路不需要换乘 
    					  {	if(dis[now->sit_num]>dis[x]+now->timval)
    					    { 
    					  	 	dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		    	    q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    					    }
    					  } 
    					  else//换乘 
    					  { double t=0;
    					    if(now->index) t=point[x].mp[now->route_num].first;//正向   起点到该点的时间 
    						else  t=point[x].mp[now->route_num].second;double timei=0;
    				    	if(dis[x]<=t)  timei=t-dis[x];
    						else
    						{   
    							 timei=(now->dep_ti_interval)-((int)(dis[x]-t)%(now->dep_ti_interval)+(dis[x]-t)-(int)(dis[x]-t));
    						}
    						if(dis[now->sit_num]>dis[x]+timei+now->timval)
    	    	         	{
    	    		     	dis[now->sit_num]=dis[x]+timei+now->timval;
    						pairNode<double>pp;pp.sit_num=now->sit_num;
    				     	pp.val=dis[now->sit_num];q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    				        }
    					  
    					  }
    

    //: 最小花费 因(因为多条线路的票价相同、一个点可以属于多条路线、票价相同的不同路线也得进行计算,同一路线不许计算,
    所以根据路线在进行松弛操作时判断线路号是否相同,相同则不加票价,即加0,不同加上对应的票价。
    *标记数组flag解决两点之间多条线路问题

                     if(np_r[x]==now->route_num)
    	    	       {   
    	    	        	if(dis[now->sit_num]>dis[x])
    	    	        	{
    	    		     	dis[now->sit_num]=dis[x];pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			 	        }	
    			    	}
    			     	else
    			     	{  
    			         	if(dis[now->sit_num]>dis[x]+now->priceval)
    	    	     	    { 
    	    		     	dis[now->sit_num]=dis[x]+now->priceval;
    						 pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			         	}	
    			    	}
    

    dij完整代码:

    void dij(int s,int _dij,int t)
          {  //	output();
    	    memset(np_r,0,sizeof(np_r));memset(np_v,0,sizeof(np_v));
          	double dis[100]; minHeap<pairNode<double> >q;bool flag[100];//前去点 线路号记录 
          	while(q.size())q.pop();memset(flag,0,sizeof(flag));
    	    for(int i=0;i<100;i++) dis[i]=inf;
    	    dis[s]=0;np_v[s]=-1;np_r[s]=-1;pairNode<double>p;p.sit_num=s;p.val=0;q.push(p);
    	    while(q.size())
    	    {  
    	    	int x=q.top().sit_num;q.pop();
    	    	if(x==t)break;
    	    	if(flag[x])continue;flag[x]=1;
    	        for(chainNode *now=aList[x].firstNode;now!=NULL;now=now->next) 
    	    	{   
    			if(_dij==2)//_dij=1时   最短距离 
    	        	{  
    	    		   if(dis[now->sit_num]>dis[x]+now->disval)
    	    	     	{
    	    			dis[now->sit_num]=dis[x]+now->disval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    			q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num;  
    			    	}	
    		    	}
    				else if(_dij==3) //最小时间(不考虑等车) 
    				{
    					if(dis[now->sit_num]>dis[x]+now->timval)
    	    	     	{
    	    			dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    			q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    				   }
    				}
    				else if(_dij==4)//等车 最小时间 
    				{    
    					  if(np_r[x]==now->route_num)//同条线路不需要换乘 
    					  {	if(dis[now->sit_num]>dis[x]+now->timval)
    					    { 
    					  	 	dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		    	    q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    					    }
    					  } 
    					  else//换乘 
    					  { double t=0;
    					    if(now->index) t=point[x].mp[now->route_num].first;//正向   起点到该点的时间 
    						else  t=point[x].mp[now->route_num].second;double timei=0;
    				    	if(dis[x]<=t)  timei=t-dis[x];
    						else
    						{   timei=(now->dep_ti_interval)-((int)(dis[x]-t)%(now->dep_ti_interval)+(dis[x]-t)-(int)(dis[x]-t));
    						}
    						if(dis[now->sit_num]>dis[x]+timei+now->timval)
    	    	         	{
    	    		     	dis[now->sit_num]=dis[x]+timei+now->timval;
    						pairNode<double>pp;pp.sit_num=now->sit_num;
    				     	pp.val=dis[now->sit_num];q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    				        }
    					  
    					  }
    				}	
    				else if(_dij==5)//最小花费 
    				{   
    					if(np_r[x]==now->route_num)
    	    	       {   
    	    	        	if(dis[now->sit_num]>dis[x])
    	    	        	{
    	    		     	dis[now->sit_num]=dis[x];pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			 	        }	
    			    	}
    			     	else
    			     	{  
    			         	if(dis[now->sit_num]>dis[x]+now->priceval)
    	    	     	    { 
    	    		     	dis[now->sit_num]=dis[x]+now->priceval;
    						 pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			         	}	
    			    	}
    				}
    			
    			}
    		}  
    	  }
    

    递归输出最优路线:

    	void print(int t)
        {
         	if(np_v[t]==-1)
         	{char c=t+'A';cout<<c;return;
        	}
        	print(np_v[t]);char c=t+'A';
         	cout<<"--->"<<c<<"(线路"<<np_r[t]<<")";
        }	 
    

    主程序设计:

    int main()
    {   cout<<"                                        公交线路优化查询"<<endl;
        cout<<"                       -----------------------------------------------------"<<endl;
        cout<<"                       |                                                   |"<<endl;
        cout<<"                       |               主菜单                              |"<<endl;
    	cout<<"                       |          1.输入数据(可在过程中增加线路)           |"<<endl;
    	cout<<"                       |          2.查询最短距离路径                       |"<<endl;
    	cout<<"                       |          3.查询最少时间路径(不考虑等车)         |"<<endl;
    	cout<<"                       |          4.查询最少时间路径(考虑等车时间)       |"<<endl;
    	cout<<"                       |          5.查询最少花费路径                       |"<<endl;
    	cout<<"                       |          6.退出系统                               |"<<endl;
    	cout<<"                       -----------------------------------------------------"<<endl; 
    	int n;linkedGraph li;cout<<"请输入选择序号(如果是第一步请选择输入数据):"<<endl;freopen("innn.txt","r",stdin);
    	while(cin>>n)
    	{    
    		if(n==6) return 0;
    		else if(n==1)init(li);//输入线路信息 
    		else 
    		{   while(n<1||n>5)
    	    	{
    			    cout<<"请输入主菜单中的选择序号2-6"<<endl;cin>>n;
    			    if(n==6) return 0; if(n>=1&&n<=5)break;
    	    	}if(n==1) init(li);
    	    	else
    	    	{
    	    	cout<<"请输入起始站和终点站:"<<endl;char a,b;cin>>a>>b;int s=a-'A';int t=b-'A';
    			li.dij(s,n,t);cout<<"查询的结果路线为:";li.print(t);
    			}	
    		}cout<<endl;
    		cout<<"是否还要继续?请输入YES or N0"<<endl;char str[10];cin>>str;
    		if(str=="NO") return 0;
    		cout<<"请输入选择序号(如果是第一步请选择输入数据):"<<endl;
    	
    	}
    	
    }
    

    完整代码:

    
    #include<iostream>
    #include<cstring>
    #include<cmath>
    #include<map>
    # define inf 10000
    using namespace std;
    
    template<class T>
    struct site//站点 
    {
    	char name;
    	T x_position;
    	T y_position;
    };
    template<class T>
    struct route//路线 
    {   
        int route_num;
        int ticket_price;
        int dep_ti_interval;
        int speed;
        int site_num;
        site<T> *sit;
        route()	{}
        void rout()
        {
        	sit=new site<T>[site_num+5];
    	}
    };
    struct po
    {
    	map<int,pair<double,double> >mp;//mp[id]=pair<double,double>
    }point[100];
    struct chainNode 
    {
       //顶点号  //线路号  //边距离  //边时间  //边票价 
       int sit_num;
       int route_num;
       double disval;
       double timval;
       int priceval;
       int dep_ti_interval;
       bool index;
       chainNode *next;
       chainNode() {}
       chainNode(int _sit_num,int _route_num,double _disval,double _timval,int _priceval,int de_i,bool _index, chainNode* next)
       :sit_num(_sit_num),route_num(_route_num),disval(_disval),timval(_timval),priceval(_priceval),dep_ti_interval(de_i),index(_index)
        { this->next = next;}
    };
    class chain 
    {
       public:
       	  chainNode* firstNode;    
    	  int listsize;  
          chain();
          ~chain();
          void insert(int v2,int rout_num,double disv,double timv,int priv,int d_i,bool index);
          int size()
          {
          	return listsize;
    	  }
              
    };
    chain::chain()
    {
       firstNode = NULL;
      listsize=0;
    }
    chain::~chain()
    {
       while (firstNode != NULL)
       {
          chainNode* nextNode = firstNode->next;
          delete firstNode;
          firstNode = nextNode;
       }
    }
    void chain::insert(int v2,int rout_num,double disv,double timv,int priv,int d_i,bool index)
    {   
          firstNode = new chainNode(v2,rout_num,disv,timv,priv,d_i,index,firstNode);listsize++;
    
    }
    template<class T>
    void changeLength1D(T*& a, int oldLength, int newLength)
    {
       if (newLength < 0)
         return;
    
       T* temp = new T[newLength];            
       int number = min(oldLength, newLength); 
       copy(a, a + number, temp);
       delete [] a;                            
       a = temp;
    }
    template<class T>
    struct pairNode //pairNode<int>pairNode<int> p(val,v)
    {
       T val;int sit_num;
       bool operator>(const pairNode& a)
       {
       	return val>a.val;
       }
       bool operator<=(const pairNode&a)
       {
       	 return val<=a.val;
       }
       bool operator<(const pairNode& a)
       {
       	return val<a.val;
       }
       operator=(const pairNode &a)
       {
       	val=a.val;sit_num=a.sit_num;
       }
       
    };
    template<class T>
    class minHeap 
    {
       public:
          minHeap(int initialCapacity = 1000);
          ~minHeap() {delete [] heap;}
          bool empty() const {return heapSize == 0;}
          int size() const
              {return heapSize;}
          const T& top()
             {
                return heap[1];
             }
          void pop();
          void push(const T);
          void initialize(T *, int);
          void deactivateArray()
             {heap = NULL; arrayLength = heapSize = 0;}
          void output(ostream& out) const;
       private:
          int heapSize;       // number of elements in queue
          int arrayLength;    // queue capacity + 1
          T *heap;            // element array
    };
    
    template<class T>
    minHeap<T>::minHeap(int initialCapacity)
    {
       arrayLength = initialCapacity + 1;
       heap = new T[arrayLength];
       heapSize = 0;
    }
    
    template<class T>
    void minHeap<T>::push(const T theElement)
    {
       if (heapSize == arrayLength - 1)
       {
          changeLength1D(heap, arrayLength, 2 * arrayLength);
          arrayLength *= 2;
       }
       int currentNode = ++heapSize;
       while (currentNode != 1 && heap[currentNode / 2] > theElement)
       {
          heap[currentNode] = heap[currentNode / 2];
          currentNode /= 2;                          
       }
    
       heap[currentNode] = theElement;
    }
    
    template<class T>
    void minHeap<T>::pop()
    {
       if (heapSize == 0)   
          return;
       heap[1].~T();
       T lastElement = heap[heapSize--];
       int currentNode = 1,
           child = 2;     
       while (child <= heapSize)
       {
          if (child < heapSize && heap[child] > heap[child + 1])
             child++;
          if (lastElement <= heap[child])
             break;  
          heap[currentNode] = heap[child]; 
          currentNode = child;           
          child *= 2;
       }
       heap[currentNode] = lastElement;
    }
    
    template<class T>
    void minHeap<T>::initialize(T *theHeap, int theSize)
    {
       delete [] heap;
       heap = theHeap;
       heapSize = theSize;
       for (int root = heapSize / 2; root >= 1; root--)
       {
          T rootElement = heap[root];
          int child = 2 * root; 
          while (child <= heapSize)
          {
             if (child < heapSize && heap[child] > heap[child + 1])
                child++;
             if (rootElement <= heap[child])
                break; 
             heap[child / 2] = heap[child]; 
             child *= 2;                  
          }
          heap[child / 2] = rootElement;
       }
    }
    
    class linkedGraph
    {
    	 protected:                  
          chain *aList;   //存图 
    	  int np_v[100];
    	  int np_r[100];
          
       public:
          linkedGraph()
          {
             aList=new chain[100];
          }
          ~linkedGraph() {delete [] aList;}
    	   void insertEdge(int v1,int v2,int rout_num,double disv,double timv,int priv,int d_i,double d_h1,double d_h2)
          {     
                aList[v1].insert(v2,rout_num,disv,timv,priv,d_i,1);//正向 
    			aList[v2].insert(v1,rout_num,disv,timv,priv,d_i,0);//反向 
    			point[v2].mp[rout_num]=make_pair(d_h1,d_h2);		
          }
        /*  void output()
          {   for(int  i=0;i<=7;i++)
          {
          	  for(chainNode *now=aList[i].firstNode;now!=NULL;now=now->next) 
          	  {
          	  	cout<<now->priceval<<" ";
    			}cout<<endl;
    	  }
    	  }*/
          void dij(int s,int _dij,int t)
          {  //	output();
    	    memset(np_r,0,sizeof(np_r));memset(np_v,0,sizeof(np_v));
          	double dis[100]; minHeap<pairNode<double> >q;bool flag[100];//前去点 线路号记录 
          	while(q.size())q.pop();memset(flag,0,sizeof(flag));
    	    for(int i=0;i<100;i++) dis[i]=inf;
    	    dis[s]=0;np_v[s]=-1;np_r[s]=-1;pairNode<double>p;p.sit_num=s;p.val=0;q.push(p);
    	    while(q.size())
    	    {  
    	    	int x=q.top().sit_num;q.pop();
    	    	if(x==t)break;
    	    	if(flag[x])continue;flag[x]=1;
    	        for(chainNode *now=aList[x].firstNode;now!=NULL;now=now->next) 
    	    	{   
    			if(_dij==2)//_dij=1时   最短距离 
    	        	{  
    	    		   if(dis[now->sit_num]>dis[x]+now->disval)
    	    	     	{
    	    			dis[now->sit_num]=dis[x]+now->disval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    			q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num;  
    			    	}	
    		    	}
    				else if(_dij==3) //最小时间(不考虑等车) 
    				{
    					if(dis[now->sit_num]>dis[x]+now->timval)
    	    	     	{
    	    			dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    			q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    				   }
    				}
    				else if(_dij==4)//等车 最小时间 
    				{    
    					  if(np_r[x]==now->route_num)//同条线路不需要换乘 
    					  {	if(dis[now->sit_num]>dis[x]+now->timval)
    					    { 
    					  	 	dis[now->sit_num]=dis[x]+now->timval;pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		    	    q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    					    }
    					  } 
    					  else//换乘 
    					  { double t=0;
    					    if(now->index) t=point[x].mp[now->route_num].first;//正向   起点到该点的时间 
    						else  t=point[x].mp[now->route_num].second;double timei=0;
    				    	if(dis[x]<=t)  timei=t-dis[x];
    						else
    						{   timei=(now->dep_ti_interval)-((int)(dis[x]-t)%(now->dep_ti_interval)+(dis[x]-t)-(int)(dis[x]-t));
    						}
    						if(dis[now->sit_num]>dis[x]+timei+now->timval)
    	    	         	{
    	    		     	dis[now->sit_num]=dis[x]+timei+now->timval;
    						pairNode<double>pp;pp.sit_num=now->sit_num;
    				     	pp.val=dis[now->sit_num];q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    				        }
    					  
    					  }
    				}	
    				else if(_dij==5)//最小花费 
    				{   
    					if(np_r[x]==now->route_num)
    	    	       {   
    	    	        	if(dis[now->sit_num]>dis[x])
    	    	        	{
    	    		     	dis[now->sit_num]=dis[x];pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			 	        }	
    			    	}
    			     	else
    			     	{  
    			         	if(dis[now->sit_num]>dis[x]+now->priceval)
    	    	     	    { 
    	    		     	dis[now->sit_num]=dis[x]+now->priceval;
    						 pairNode<double>pp;pp.sit_num=now->sit_num;pp.val=dis[now->sit_num];
    	    		     	q.push(pp);np_v[now->sit_num]=x;np_r[now->sit_num]=now->route_num; 
    			         	}	
    			    	}
    				}
    			
    			}
    		}  
    	  }
    	void print(int t)
        {
         	if(np_v[t]==-1)
         	{char c=t+'A';cout<<c;return;
        	}
        	print(np_v[t]);char c=t+'A';
         	cout<<"--->"<<c<<"(线路"<<np_r[t]<<")";
        }	 
     };
    void init(linkedGraph& li)
    {  //<100条线路
        cout<<"请输入线路的个数:"<<endl;
        int num;cin>>num;route<int>rt[100];
    	for(int i=1;i<=num;i++)
    	{
    		cout<<"请输入第"<<i<<"条线路号:"<<endl;cin>>rt[i].route_num;
    		cout<<"请输入该条线路站点的个数:"<<endl;cin>>rt[i].site_num;rt[i].rout();
    		cout<<"请输入站点名称及位置坐标:(站点名称用大写字母表示,从'A'开始命名)"<<endl; 
    		for(int j=0;j<rt[i].site_num;j++)
    		{
    			cin>>rt[i].sit[j].name;cin>>rt[i].sit[j].x_position;cin>>rt[i].sit[j].y_position;
    		}cout<<"请输入发车时间间隔及车速和票价:"<<endl;cin>>rt[i].dep_ti_interval>>rt[i].speed>>rt[i].ticket_price;
    	    double dep_he[100];double ddisval[100];double  timval[100];memset(dep_he,0,sizeof(dep_he));memset(ddisval,0,sizeof(ddisval));
    	    memset(timval,0,sizeof(timval));
    		for(int j=0;j<rt[i].site_num-1;j++)
    		{
    		    ddisval[j]=sqrt(pow((rt[i].sit[j+1].x_position-rt[i].sit[j].x_position),2)+pow((rt[i].sit[j+1].y_position-rt[i].sit[j].y_position),2));
    			timval[j]=ddisval[j]/rt[i].speed;//cout<<rt[i].sit[j].name-'A'<<" "<<timval<<" "<<rt[i].sit[j+1].name-'A'<<endl;
    			if(j==0)dep_he[j]=timval[j];else dep_he[j]=dep_he[j-1]+timval[j];
    		}point[rt[i].sit[0].name-'A'].mp[rt[i].route_num]=make_pair(0,dep_he[rt[i].site_num-2]);
    		for(int j=0;j<rt[i].site_num-1;j++)
    		{
    			li.insertEdge(rt[i].sit[j].name-'A',rt[i].sit[j+1].name-'A',rt[i].route_num,ddisval[j],timval[j],rt[i].ticket_price,rt[i].dep_ti_interval,dep_he[j],dep_he[rt[i].site_num-2]-dep_he[j]);	
    		}	
    	 } 
    }
    int main()
    {   cout<<"                                        公交线路优化查询"<<endl;
        cout<<"                       -----------------------------------------------------"<<endl;
        cout<<"                       |                                                   |"<<endl;
        cout<<"                       |               主菜单                              |"<<endl;
    	cout<<"                       |          1.输入数据(可在过程中增加线路)           |"<<endl;
    	cout<<"                       |          2.查询最短距离路径                       |"<<endl;
    	cout<<"                       |          3.查询最少时间路径(不考虑等车)         |"<<endl;
    	cout<<"                       |          4.查询最少时间路径(考虑等车时间)       |"<<endl;
    	cout<<"                       |          5.查询最少花费路径                       |"<<endl;
    	cout<<"                       |          6.退出系统                               |"<<endl;
    	cout<<"                       -----------------------------------------------------"<<endl; 
    	int n;linkedGraph li;cout<<"请输入选择序号(如果是第一步请选择输入数据):"<<endl;freopen("innn.txt","r",stdin);
    	while(cin>>n)
    	{    
    		if(n==6) return 0;
    		else if(n==1)init(li);//输入线路信息 
    		else 
    		{   while(n<1||n>5)
    	    	{
    			    cout<<"请输入主菜单中的选择序号2-6"<<endl;cin>>n;
    			    if(n==6) return 0; if(n>=1&&n<=5)break;
    	    	}if(n==1) init(li);
    	    	else
    	    	{
    	    	cout<<"请输入起始站和终点站:"<<endl;char a,b;cin>>a>>b;int s=a-'A';int t=b-'A';
    			li.dij(s,n,t);cout<<"查询的结果路线为:";li.print(t);
    			}	
    		}cout<<endl;
    		cout<<"是否还要继续?请输入YES or N0"<<endl;char str[10];cin>>str;
    		if(str=="NO") return 0;
    		cout<<"请输入选择序号(如果是第一步请选择输入数据):"<<endl;
    	
    	}
    	
    }
    
    展开全文
  • 线路路径优化备份冗余之单路由器解决方案 通过双ISP (如:一条电信、一条网通)链路可实现网络路径优化 、负载均衡 及备份冗余, 以前本人一直认为Cisco 不能实现单路由器双ISP 链路的冗余备份 ,后经过多次...
  • 进入配置,配置cname 注意线路一定要默认 至此简单的配置已经完成了 又拍云优化系列 缓存控制 开启分段缓存 缓存配置,我配置了缓存全站1小时。(因博客需要经常更新文章) 性能优化 开启页面压缩 开启重定向跟随 ...
  • 于是,我们就写了一个输入为线上得分,输出为线下可能的路径组合的小程序,在线下模拟几条可能坠毁的线路坠毁的情况,尽可能保证各种情况下都能区分出坠毁的路径。 那么如何修改耗时?我们的超参数中有一个是可以...
  • 线路延迟和MDI是两个层次的概念 http://max.book118.com/html/2016/0523/43760583.shtm
  • Android性能优化系列之内存优化

    万次阅读 2017-01-21 21:00:45
    在Java中,内存的分配是由程序完成的,而内存的释放是由垃圾收集器(Garbage Collection,GC)完成的,程序员不需要通过调用函数来释放内存,但也随之带来了内存泄漏的可能,上篇博客,我介绍了 Android性能优化系列之...
  • 3C直连线路和CN2线路以及其他线路该如何选择 大家都知道市面上现在的线路比较多的有CN2,BGP线路等,但3C直连线路正在快速崛起,如果需要租用服务器,建议先要了解清楚,然后再选择适合的进行使用。那么现在备受关注...
  • 项目优化

    千次阅读 2018-10-16 20:01:30
    windows环境可以使用自带工具排查网络占用异常,打开资源管理器选择联网标签,在最下面列出了机器的所有网卡,包括虚拟网卡的线路速度和网络使用率: 上图展示出本服务器有一个网络适配器(网卡),实时占用...
  • 优化

    千次阅读 2018-01-29 17:22:56
    LTE是Long Term Evolution缩写,意思是长期演进,相对单验,是对一个单独的基站进行优化,簇是对一组连续覆盖区域基站进行优化,比如,一个簇可能有10个站或者20个站,这个是根据项目要求和市区密集度来规划的。...
  • 优化新常态> 前半生

    千次阅读 2017-08-24 15:21:39
    ORACLE 优化 新常态
  • 该软件主要针对铁路工务部门日常线路养护维修工作需要而开发,软件功能主要包括线路平面优化设计和线路纵断面优化设计两大功能,其中线路平面优化设计又包括坐标法和绳正法拨距优化计算两个功能。软件中不管是平面...
  • 页面性能优化办法有哪些?

    千次阅读 多人点赞 2019-05-27 09:10:38
    引子 互联网有一项著名的8秒原则。用户在访问Web网页时,如果时间超过8秒就会感到不耐烦,如果加载需要太长时间,他们就会放弃访问。...这是本文主要要探讨的问题,然而性能优化是个综合性问题,没有标准答案,想要...
  • 优化全集

    千次阅读 2007-09-19 07:58:00
    1 电脑优化全集 一、系统优化设置 1、删除Window
  • PHP学习线路

    万次阅读 多人点赞 2018-09-19 19:33:57
    PHP学习线路图 PHP教程 PHP教程 PHP简介 PHP环境设置 PHP语法概述 PHP变量类型 PHP常量类型 PHP运算符类型 PHP 条件语句 PHP循环语句 PHP数组 PHP字符串操作 PHP Web概念 PHP的GET...
  • Matlab遗传算法公交车路线优化

    千次阅读 热门讨论 2020-05-02 11:49:20
    Matlab遗传算法公交车路线优化1 模型介绍2模型分析2.1整体设计2.2要点分析3结果展示 ...本文以线路长度和线路非直线系数为优化模型的约束条件[14]。 1)线路长度 线路长度过短会导致车辆运行效率低且运行速度低...
  • 排队论及排队系统优化

    万次阅读 多人点赞 2017-08-14 23:29:25
    纲要 排队现象与排队系统; 排队模型与系统参数; 排队系统时间参数分布规律; 排队系统的生灭过程与状态...这个新发明带来了一个新问题,即通话线路与电话用户呼叫的数量关系应如何妥善解决,这个问题久久未能解决。 1
  • 家庭网络优化

    千次阅读 2020-03-05 16:09:06
    家庭环境中网络可以优化吗?需要怎么做呢? 科普---典型的网络拓扑 科普---较优的网络拓扑(家里新装修走线记得保留) 可以优化的地方 无线路由器,要千兆的,千兆的,千兆的!很多家庭的无线路由器是...
  • Android应用优化方案四

    万次阅读 2017-01-22 17:38:38
    Android应用优化方案一  点击进入  Android应用优化方案二  点击进入  Android应用优化方案三  点击进入  Android应用优化方案四
  • 循环优化与多面体模型

    千次阅读 2019-09-22 21:22:08
    循环通常是数据并行应用的最密集计算段,因此循环优化直接影响性能。当面对嵌套循环时,分配给线程的计算粒度将直接影响性能。循环转换如Fission(循环裂变)与Fusion(循环融合)的嵌套式循环可促使并行化,并提高...
  • 香港葵兴机房服务器租用的优势: 1、BGP网络 a、不断线 BGP网络有多线路备份的功能,当某一...SEO优化:理论上只要能保证用户能流畅的访问网站,对搜索引擎就没有影响。前提是要保证网站的打开速度和服务器稳定性。
  • 钢管订购及运输优化模型一、问题重述需要解决的问题二、模型假设三、符号说明四、模型的分析、建立、求解1. 模型的分析与决策变量的设置2.模型的建立1)目标函数(1)铺设总费用(2)成本和运输总费用(3)求单位钢管从钢...
  • 优化问题简单总结

    千次阅读 2020-07-27 23:16:03
    引申:无约束优化、有约束优化、等式约束、不等式约束、线性优化、非线性优化。各类问题都有特定的解决办法 1.2 优化问题基本解决办法:解析解法、数值解法 解析解法:知道目标函数的具体形式,严格按照数学公式...
  • MySQL数据库性能优化之硬件优化

    千次阅读 2013-01-05 13:54:27
    在过往与很多人的交流过程中发现,在谈到基于硬件来...我们在谈论基于硬件进行优化的时候,不能仅仅将数据库使用的硬件划分为主机和存储两部分,而是需要进一步对硬件进行更细的分解,至少也应该分解到如下范畴:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,780
精华内容 14,712
关键字:

优化线路