寒假集训 最短路（I - Heavy Transportation）dijkstra+堆优化

        今天的集训学习了最短路dijkstra的堆优化，把时间复杂度从朴素版的O（）降至了O(n*logn+m).

        首先，先上一段朴素版的代码。

void dijkstra()
{
	dist[1] = 0;
	for(int i = 0; i < n; i ++)
	{
		int t = -1;
		for(int j = 1; j <=n ; j ++)
		{
			if(!st[j] && (t == -1 || dist[t] > dist[j]))
			{
				t = j;
			}
		}
		st[t] = 1;
		for(int j = 1; j <= n ; j ++)
		{
			dist[j] = min(dist[j],dist[t] + mp[t][j]);
		}
	}
}

我们可以知道，朴素版的dij，每个循环都是走完的，但是我们知道有很多的数据，是多余的，对我们的计算是没有帮助的，所以就走了许多多余的循环。

优化方式

       一 ： 邻接表  

        这里采用链式前向星的方式进行存图，

        用结构体节省数据的空间，采用头插法，以存边的方式去构图，用数组去存边并且不断向外更新。遍历的时候最先输出的是外边的那个。

void add(int a, int b , int c)
{
	s[sum].e = b;  // 终点
	s[sum].w = c;  // 权值
	s[sum].nest = h[a];   // 第一条边的前面；
	h[a] = sum ++; // 更新第一条边的标号
}

      二 ：优先队列

            pair<int , int > -- pii    

             priority_queue<int> os; 如果没有特别定义的话，默认降序排序；// 大顶堆

            等价于priority_queue< pii, vector < pii >, less < pii > > os;

           priority_queue< pii, vector < pii >, greater < pii > > os; // 升序，小顶堆

优先队列使存入的元素按照特定的序列排序，存入队列的元素都是更新过的，第一个出队的是最大的或者最小的。所以我们在接下来的判断中，只需要判断状态量，按照我们需求的出队，并删除，减小了下次的运算量。

        使用大顶堆或者小顶堆需要根据题目具体实现。

例题 I - Heavy Transportation

 题目简介：

求到达目的地的边的各个边的最小值；

  首先，我们要保证的是，到达目的地是有解的，其次和普通的板子有点不一样的是，因为要记录的是组成整体的路的每条边的最小值。一般的板子，我们只是记录了从一个点到另一个点的最小值，但是并没有记录中间量，所有这里我们需要注意一下。

   对于这道题，我们的对于距离的初始化有所变化，首先我们定义起点为最大值，其他的定义为-1，用最大值去更新周围点。通过对题意的分析，我们所构造的图是无向图，因此在存边的时候要注意双向存边。

  为什么要把起点定义为最大？我们要求的边是最小的，定义最大的时候，在不断遍历的过程中，我们可以把边不断记录优化，并且保证是从大往小进行出队列的操作，以遍历链表的方式进行判断，所以采用大顶堆从大到小优化，可以保证数据的准确性，并且使第一步取最小值可以顺利进行。；升序的话不能保证数据的正确性。

code ：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
const int inf = 0x3f3f3f3f;
typedef long long ll;
typedef pair< int , int > pii;
int n ,m ,T ,t;
int x , y ,z;
int sum = 1;//链式 
int ans = -1;
struct ch
{
	int e, w ,nest;
}s[100100]; // 存图 
int h[100100]; // head 
bool st[100100];
int dist[100100];
void add(int a, int b , int c) 
{
	s[sum].e = b;
	s[sum].w = c;
	s[sum].nest = h[a];
	h[a] = sum ++;
}
void dij()
{
	dist[1] = inf; //从大往小更新。
	priority_queue< pii, vector < pii >, less < pii > > os; // 降序； 
	os.push(make_pair(dist[1],1)); // first 距离
	while(!os.empty())             // second 点 （push({dist[1],1})也行，但是有的地方编译过不去。
	{
		int xx = os.top().second;
		os.pop();
		if(st[xx] == 1)
		{
			continue;
		}
		st[xx] = 1;
		for(int i = h[xx]; i != -1; i = s[i].nest)
		{
			int j = s[i].e;
			if(dist[j] < min(dist[xx], s[i].w)) // 判断是否是更小的
			{
				dist[j] = min(dist[xx], s[i].w); // 更新
				os.push(make_pair(dist[j],j));	// 把符合条件的较小的数值压入；
			}
		}
	}
}	
int main()
{
	//ios::sync_with_stdio(false);
	int t;
	scanf("%d",&t);
	int k = 1;
	while(t --)
	{
		scanf("%d %d",&n,&m);
		memset(h, -1, sizeof(h)); // 链式初始化
		memset(st, 0,sizeof(st));
		memset(dist, -1, sizeof dist);
		sum = 1;
		for(int i = 1; i <= m; i ++)
		{
			scanf("%d %d %d",&x,&y,&z);
			add(y , x ,z); // 双向构图
			add(x , y ,z);
		}
		dij();
		printf("Scenario #%d:\n",k++);
		printf("%d\n\n",dist[n]);
	} 
}

  over~