CSP 201712 - 4 【行车路线】

---

一、问题描述

　　小明和小芳出去乡村玩，小明负责开车，小芳来导航.
　　小芳将可能的道路分为大道和小道。大道比较好走，每走1公里小明会增加1的疲劳度。小道不好走，如果连续走小道，小明的疲劳值会快速增加，连续走s公里小明会增加s2的疲劳度。
　　例如：有5个路口，1号路口到2号路口为小道，2号路口到3号路口为小道，3号路口到4号路口为大道，4号路口到5号路口为小道，相邻路口之间的距离都是2公里。如果小明从1号路口到5号路口，则总疲劳值为(2+2)2+2+22=16+2+4=22。
　　现在小芳拿到了地图，请帮助她规划一个开车的路线，使得按这个路线开车小明的疲劳度最小。
输入格式
　　输入的第一行包含两个整数n, m，分别表示路口的数量和道路的数量。路口由1至n编号，小明需要开车从1号路口到n号路口。
　　接下来m行描述道路，每行包含四个整数t, a, b, c，表示一条类型为t，连接a与b两个路口，长度为c公里的双向道路。其中t为0表示大道，t为1表示小道。保证1号路口和n号路口是连通的。
　　
输出格式

输出一个整数，表示最优路线下小明的疲劳度。
　　
样例输入
6 7
1 1 2 3
1 2 3 2
0 1 3 30
0 3 4 20
0 4 5 30
1 3 5 6
1 5 6 1

样例输出

76

样例说明

从1走小道到2，再走小道到3，疲劳度为52=25；然后从3走大道经过4到达5，疲劳度为20+30=50；最后从5走小道到6，疲劳度为1。总共为76。

二、实现代码

#include<iostream>
#include<queue>
#define INF 1e18
using namespace std;
int n,m,head[505], path[505];
long long  dis[505],big_small[505];//dis[i]一定是最小的，无论是从哪条路走过来的，big_small用来记录i顶点是怎么过来的（大路为0，小路为前面的小路之和） 
bool vis[505];
struct Edge{
	bool type;//1小道 
	int to , next;
	long long weight;
}edge[200010];
struct node {
    int id;
	long long dis; //id表示点的编号  dis为在加入优先队列时的dis[id] 
    node(int id = 0, long long dis = 0) : id(id), dis(dis) {} //构造函数
	bool operator < (const node &x) const { //重载运算符 ,优先级最大的在前面，所以比较时，距离要最小 
        return dis > x.dis; //小根堆  注意  这里用>时  最后堆顶为最小的  和sort的comp相反 
    } 
};
priority_queue <node> q;
void dij(){
	long long tmpdis;
	int  i ,v, pos;
	dis[1] = 0;
	node tmp;
	q.push(node(1,0));
	while(!q.empty()){
		tmp = q.top(); q.pop();
		v = tmp.id;
		if(vis[v]) continue;
		vis[v] = true;
		for(pos=head[v];pos;pos=edge[pos].next){
			i=edge[pos].to;
			if(vis[i]) continue;
			if(edge[pos].type){
				if(!big_small[v]){//如果v是从大路过来的 
					tmpdis = edge[pos].weight * edge[pos].weight;
					if(dis[i] > dis[v] + tmpdis){
						dis[i] = dis[v] + tmpdis;
						big_small[i] = edge[pos].weight;
						q.push(node(i,dis[i]));
						path[i] = v;
					}
				}
				else{
					tmpdis =  (big_small[v] + edge[pos].weight)*(big_small[v] + edge[pos].weight) - big_small[v] * big_small[v];
					if(dis[i] > tmpdis + dis[v]){
						dis[i] = tmpdis + dis[v];
						big_small[i] = big_small[v] + edge[pos].weight;
						q.push(node(i,dis[i]));
						path[i] = v;
					}
				}
			}
			else{
				if(dis[i] >= dis[v] + edge[pos].weight){
					dis[i] = dis[v] + edge[pos].weight;
					big_small[i] = 0;
					q.push(node(i,dis[i]));
					path[i] = v;
				}
			}
		}
	}
}
int main()
{
	cin >>n >>m; 
	int cnt = 0;
//	memset(small,INF,sizeof(small));
//	memset(big,INF,sizeof(big));
//	memset(dis,INF,sizeof(dis));
	for(int i = 1; i <= n; i++){
		dis[i] = INF;
		vis[i] = false;
		big_small[i] = 0;
	}
	int x,y,wei,type;
	for(int i = 1;i <= m;i++){
		cin >> type >> x >>y >>wei;
		edge[++cnt].to = y;
		edge[cnt].type = type;
		edge[cnt].weight = wei;
		edge[cnt].next = head[x];
		head[x] = cnt;
		edge[++cnt].to = x;
		edge[cnt].type = type;
		edge[cnt].weight = wei;
		edge[cnt].next = head[y];
		head[y] = cnt;
	}
	dij();
	cout << "\n最优路径为（倒序）：" << n <<" "; 
	int i = path[n];
	while(i){
		cout << i << " ";
		i = path[i];
	}
	cout << endl;
	cout << "\n从出发点到各个点的最小疲劳值为："; 
	for(i = 1;i <= n;i++) cout << dis[i] << " ";
	//cout << dis[n] << endl;
}

总结

利用链式前向星（邻接表）存图，type变量表示某条路为小道或大道（true为小道，false为大道），weight为路的疲劳值，to表示该顶点的邻接点，next表示该顶点关联的另外一个边所在的位置。建立数组dis，用来存储到每个顶点的最小疲劳值，数组big_small用来记录到某个顶点是经过的是小道还是大道（大路为0，小路为前面走过的路径中小路的疲惫值之和）。

将起点的dis和big_small设为0，然后利用dijsktra算法：

从顶点v出发，遍历它的邻接点i。若该邻接点若已经访问过，则跳过；

否则，若（v,i）为大道，则判断dis[i]是否大于dis[v]+(v,i)，若大于则更新，并令big_small[i]=0；

若（v,i）为小道，先判断经过顶点v是经过的是大道还是小道（即判断big_small[v]是否为0），若是从大道过来的，则判断dis[i]是否大于dis[v]+(v,i) *(v,i)，若大于则更新dis[i]，并令big_small[i]=（v，i）；若是从小道过来的，则判断dis[i]是否大于dis[v]+(big_small[v]+(v,i)) * (big_small[v]+(v,i)) - big_small[v] * big_small[v]，其中后面的部分为从v到i的疲惫值减去到达v的疲惫值（即v到i的增量），若大于则更新dis[i]，并令big_small[i]= big_small[v]+(v,i)。

然后利用优先队列在dis数组中找到最小的值。重复执行，直到顶点都被访问。