bzoj：4152 [AMPPZ2014]The Captain

最新推荐文章于 2019-01-20 11:10:19 发布

01232012

最新推荐文章于 2019-01-20 11:10:19 发布

阅读量133

点赞数

CC 4.0 BY-SA版权

分类专栏：图论复习题一（最短路（&&变形）：（dijkstra、SPF 文章标签：最短路

本文链接：https://blog.youkuaiyun.com/qq_42369449/article/details/82824761

图论复习题一（最短路（&&变形）：（dijkstra、SPF 专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了最短路径算法的实现，特别是Dijkstra算法在解决特定问题中的应用。通过对比SPFA算法，强调了Dijkstra算法在处理无负权边情况下的优势。文章详细介绍了算法的具体步骤，包括节点排序、边的建立以及最短路径的计算，并提供了完整的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

算法：最短路（一定要用dijkstra，“spfa选手他死了！！！（无论什么SLF/LLL优化））”

难度：NOIP----

 这是我做过的最裸的最短路，简直就是一个模板（告诉选手们spfa，它死了）！！！
 还是说一下思路吧，就是把先按照x排序，建边一定建相邻的x间；再按照y排序，相邻的y也建上边，跑最短路（dijkstra）即可。

注意：建边的时候u和v是两点的编号，不是点的横坐标！！！&&数组记得开N<<2!,2个点之间可能建了4条边

代码如下：

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <algorithm>
#include <deque>
#define ll long long
#define N 200005
using namespace std;
struct node
{
    int x,y,idd;
}poi[N];
struct nod
{
    int next;
    int to;
    int val;
}edge[N<<2];
struct no
{
    int po,d;
};
bool operator < (no a,no b)
{
    return a.d > b.d;
}

int head[N<<2],used[N];
int dis[N];
int cmp1(node a,node b)
{
    return a.x<b.x;
}
int cmp2(node a,node b)
{
    return a.y<b.y;
}
int cnt=1;
void init()
{
    memset(head,-1,sizeof(head));
    cnt=1;
}
void add(int u,int v,int w)
{
    edge[cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].val=w;
    head[u]=cnt++;
}
/*void spfa(int rt)
{
    memset(dis,0x3f3f3f3f,sizeof(dis));
    dis[rt]=0;
    vis[rt]=1;
    deque<int>Q;
    Q.push_back(rt);
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop_front();
        for(int i = head[u];i != -1;i=edge[i].next)
        {
            int to=edge[i].to;
            if(dis[to]>dis[u]+edge[i].val)
            {
                dis[to]=dis[u]+edge[i].val;
                if(!vis[to])
                {
                    vis[to]=1;
                    if(!Q.empty()&&dis[to]<dis[Q.front()])
                    {
                        Q.push_front(to);
                    }else
                    {
                        Q.push_back(to);
                    }
                }
            }
        }
        vis[u]=0;
    }
}*/
void diji(int rt)
{
    memset(dis,0x3f3f3f3f,sizeof(dis));
    priority_queue <no> M;
    dis[rt]=0;
    no point;
    point.d=0;
    point.po=rt;
    M.push(point);
    while(!M.empty())
    {
        no point=M.top();
        M.pop();
        int u = point.po;
        if(used[u])
        {
            continue;
        }
        used[u]=1;
        for(int i = head[u];i != -1;i = edge[i].next)
        {
            int to = edge[i].to;
            if(used[to])
            {
                continue;
            }
            if(dis[to] > edge[i].val + dis[u])
            {
                dis[to] =  edge[i].val + dis[u];
                no temp;
                temp.d = dis[to];
                temp.po = to;
                M.push(temp);
            }
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    init();
    for(int i = 1;i <= n;i++)
    {
        scanf("%d%d",&poi[i].x,&poi[i].y);
        poi[i].idd=i;
    }
    sort(poi+1,poi+1+n,cmp1);
    for(int i = 1;i < n;i++)
    {
        add(poi[i].idd,poi[i+1].idd,abs(poi[i].x-poi[i+1].x));
        add(poi[i+1].idd,poi[i].idd,abs(poi[i].x-poi[i+1].x));
    }
    sort(poi+1,poi+1+n,cmp2);
    for(int i = 1;i < n;i++)
    {
        add(poi[i].idd,poi[i+1].idd,abs(poi[i].y-poi[i+1].y));
        add(poi[i+1].idd,poi[i].idd,abs(poi[i].y-poi[i+1].y));
    }
    diji(1);
    printf("%d\n",dis[n]);
    return 0 ;
}