Dijkstra+Heap+前向星存图

转载 2012年03月30日 10:50:42
/*
    dijkstra + heap,时间复杂度: O((n + e)log(n)).
    对于稠密图来说,仍然是dij+heap快,而且越稠密越快!
    用前向星来存图,空间复杂度为: O(m).
    更新时间: 2011.09.22
*/
#include <iostream>
#include <cstring>
#include <cmath>
#include <climits>
#include <algorithm>
#include <cstdio>
using namespace std;


typedef long long int64;
#define mem(a, b) memset(a, b, sizeof(a))
#define Sqr(x) ((x) * (x))
template <class T>
inline T Max(T a, T b) { if (a < b) a = b; return a; }
template <class T>
inline T Min(T a, T b) { if (a > b) a = b; return a; }
template <class T>
inline void Swap(T & a, T & b) { T dt = a; a = b; b = dt; }


const int maxn = 50005;
const int maxm = 50005 << 1; // 无向图.
const double EPS = 1e-10;
const int64 INF = (1LL << 60) + (1LL << 61);


struct EDGE
{
    int a, b, c;
    int next;
};


int n, m, ds, dt; // n个点,m条边,s为原点,t为终点。
EDGE edge[maxm]; // 前向星.
int edge_num;
int first[maxn]; // 记录该点的第一条边在edge[]的下标.
bool visited[maxn]; // 判断该点的最短路是否已经求出来了.
int64 ans;


struct Heap
{ // 如果速度慢,就不要用struct,直接作为一般参数和函数.
    int heapsize;
    int heap_v[maxn]; // heap_v[i]为堆中第i个位置所存的图中的结点.
int heap_map[maxn]; // heap_map[i]表示图中的点i在堆中的位置.
int64 heap_w[maxn]; // heap_w[i]为堆中第i个位置所存的为dist[heap_v[i]].
    void heap_swap(int i, int j)
    {
        Swap(heap_w[i], heap_w[j]);
        heap_map[heap_v[i]] = j;
        heap_map[heap_v[j]] = i;
        Swap(heap_v[i], heap_v[j]);
    }
    void heap_up(int i)
    {
        while (i != 1)
        {
            if (heap_w[i] < heap_w[i >> 1])
            {
                heap_swap(i, i >> 1);
                i >>= 1;
            }
            else break;
        }
    }
    void heap_down(int i)
    { // 注: 在dijkstra+heap没用到该函数.
        while ((i << 1) <= heapsize)
        {
            i <<= 1;
            if (i + 1 <= heapsize && heap_w[i + 1] < heap_w[i]) i++;
            if (heap_w[i] < heap_w[i >> 1])
            {
                heap_swap(i, i >> 1);
            }
            else break;
        }
    }
    void Delmin(void)
    {
        heap_swap(1, heapsize);
        heapsize--;
        heap_down(1);
    }
};


Heap hp;


void Init(void)
{
    int i, j, k;
    ans = 0; edge_num = 0;
    mem(visited, 0);
    fill(first, first + maxn, -1);
    visited[ds] = 1;


    for (i = 1; i <= n; i++)
    {
        hp.heap_v[i] = i;
        hp.heap_map[i] = i;
        hp.heap_w[i] = INF;
    }
    hp.heap_w[ds] = 0; hp.heapsize = n;
    hp.heap_up(hp.heap_map[ds]);
}


void AddEdge(int a, int b, int c)
{
    edge[edge_num].a = a, edge[edge_num].b = b, edge[edge_num].c = c;
    edge[edge_num].next = first[a], first[a] = edge_num++;
}


void Dijkstra_heap(void)
{ // hp.heap_w[hp.heap_w[i]] 相当于 dist[i].
    int i, j, k;
    int t;
    int64 temp;
    for (t = 1; t < n; t++)
    {
        i = hp.heap_v[1];
        temp = hp.heap_w[1]; // temp 相当于dist[i].
        hp.Delmin();
        visited[i] = 1;
        if (visited[dt]) break; // 说明dist[dt]已经求出.
        for (k = first[i]; k != -1; k = edge[k].next)
        {
            j = edge[k].b;
            if (!visited[j] && temp + edge[k].c < hp.heap_w[hp.heap_map[j]])
            {
                hp.heap_w[hp.heap_map[j]] = temp + edge[k].c;
                hp.heap_up(hp.heap_map[j]);
            }
        }
    }
}


int main(void)
{
//    freopen("Input.txt", "r", stdin);
    int i, j;
    int a, b, c;
    while (scanf("%d %d %d %d", &n, &m, &ds, &dt) != EOF)
    {
        Init();
        while (m--)
        {
            scanf("%d %d %d", &a, &b, &c);
            AddEdge(a, b, c);
//            AddEdge(b, a, c); // 无向图.
        }
        Dijkstra_heap();
        ans = hp.heap_w[hp.heap_map[dt]];
        if (ans == INF) cout << "Can't reach" << endl;
        else cout << ans << endl;
    }
    return 0;
}


Dijkstra+Heap+前向星存图

一切尽在代码中。。。。。。。。 /* dijkstra + heap,时间复杂度: O((n + e)log(n)). 对于稠密图来说,仍然是dij+heap快,而且越稠密越快!...
  • niushuai666
  • niushuai666
  • 2011年09月22日 21:30
  • 3017

前向星(存图)

#include #include using namespace std; const int maxn = 100; const int maxm = 100000; typedef...
  • wangwenhao00
  • wangwenhao00
  • 2012年09月15日 23:19
  • 1636

关于图的存储方法 (静态邻接表、前向星、边集数组)

一、邻接矩阵(不多说了)  G[u][v] 二、邻接表                   1、动态链表(指针)      一个数组表头(u)+ struct结点(v),相链,若有权值等信息再在结点里...
  • tclh123
  • tclh123
  • 2011年08月07日 17:34
  • 5091

浅谈图的前向星遍历

个人见解,如有错误,欢迎指出。 作为一个算法新手,我就从我个人的角度来讲述前向星这种算法,我看到大多数都是建立一个边集的结构体,然后在结构体内放入边指向结点,边的前驱,和边权: 例如: struct ...
  • I_am_a_winer
  • I_am_a_winer
  • 2015年02月26日 13:48
  • 636

图的存储结构三部曲 ——其一:前向星

前向星也是一种通过存储边的信息的方式存储图的数据结构。它的
  • u013573047
  • u013573047
  • 2014年04月04日 21:27
  • 1689

建图方式一 之 ”前向星“ BFS&&DFS 简单应用

耗时一晚上 ,好好研究了一下 三种建图方式de
  • u013497151
  • u013497151
  • 2014年05月22日 20:56
  • 1991

图的常用存储结构——前向星

前向星: 构造方法:将边存放在数组中,然后按照起点顺序进行排序就构造完成了。 analystS:可以存储重边 analystW:不能直接判断任意两个顶点之间是否有边 应用:边数多,并且两点之间...
  • lgdblue
  • lgdblue
  • 2014年05月01日 16:40
  • 553

图的(链式)前向星存储结构

一般来讲,图的常用存储结构有邻接矩阵,和邻接表,但我们知道邻接矩阵空间浪费太严重,邻接表不好写,今天来讲一下图的另一只常用的存储结构:前向星和链式前向星,介于上述两种存储结构之间的一种比较均衡的存储结...
  • AC_Gibson
  • AC_Gibson
  • 2015年01月11日 18:29
  • 747

hdu5273 Abandoned country 最小生成树 概率 Kruskal算法 前向星存图

有图                                                                           Abandoned country 题目大意:...
  • baisedeqingting
  • baisedeqingting
  • 2017年07月31日 17:34
  • 146

卷积神经网络(CNN)前向传播算法

http://www.cnblogs.com/pinard/p/6489633.html     在卷积神经网络(CNN)模型结构中,我们对CNN的模型结构做了总结,这里我们就在...
  • zdy0_2004
  • zdy0_2004
  • 2017年03月03日 22:34
  • 1387
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Dijkstra+Heap+前向星存图
举报原因:
原因补充:

(最多只允许输入30个字)