【BZOJ-4289】Tax 最短路 + 技巧建图

4289: PA2012 Tax

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 168 Solved: 69
[Submit][Status][Discuss]

Description

给出一个N个点M条边的无向图，经过一个点的代价是进入和离开这个点的两条边的边权的较大值，求从起点1到点N的最小代价。起点的代价是离开起点的边的边权，终点的代价是进入终点的边的边权

N<=100000

M<=200000

Input

Output

Sample Input

4 5
1 2 5
1 3 2
2 3 1
2 4 4
3 4 8

Sample Output

HINT

Source

Solution

比较有技巧的建图

首先考虑暴力点的建图：

把每条无向边拆成两条有向边.把每条边看成一个点,对于两条边a->b,b->c

在这两条边之间连有向边,边权为这两条边的权值的较大值.

新建源点S,汇点T, S向所有从1连出去的边连边,所有指向n的边向T连边. 求S->T的最短路即可.

这样的复杂度会达到$O(m^{2})$

考虑优化一下，有个类似网络流中补流思想的方法：

考虑利用差值来建边.

依然把每条边x-y拆成x->y,y->x.

枚举每个中转点x. 将x的出边按权值排序,x的每条入边向对应的出边连该边权值的边,x的每条出边向第一个比它大的出边连两边权差值的边,x的每条出边向第一个比它小的出边连权值为0的边. 新建源汇S,T S向每条1的出边连权值为该边边权的边.每条n的入边向T连该边权值的边.

跑S->T的最短路即可.

这样的复杂度是$O(mlogm)$就可以AC

顺带提一句，用Dijkstra效率很快

Code

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<queue>

using namespace std;

void Freopen() {freopen("travel.in","r",stdin); freopen("travel.out","w",stdout);}

#define Pa pair<long long,int>

inline int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

#define MAXN 200010

#define INF 1LL<<60

int N,M;

struct EdgeNode{int next,to,val;}edge[MAXN<<],road[MAXN<<];

int head[MAXN],cnt=,first[MAXN<<],tot=;

inline void AddEdge(int u,int v,int w) {cnt++; edge[cnt].next=head[u]; head[u]=cnt; edge[cnt].to=v; edge[cnt].val=w;}

inline void InsertEdge(int u,int v,int w) {AddEdge(u,v,w); AddEdge(v,u,w);}

inline void AddRoad(int u,int v,int w) {tot++; road[tot].next=first[u]; first[u]=tot; road[tot].to=v; road[tot].val=w;}

inline bool cmp(int x,int y) {return edge[x].val<edge[y].val;}

priority_queue<Pa,vector<Pa>,greater<Pa> >q;

int S,T;

long long dis[MAXN<<];

void Dijkstra()

{

    for (int i=S; i<=T; i++) dis[i]=INF;

    q.push(make_pair(,S)); dis[S]=;

    while (!q.empty())

        {

            int now=q.top().second;

            long long Dis=q.top().first;

            q.pop();

            if (Dis>dis[now]) continue;

            for (int i=first[now]; i; i=road[i].next)

                if (dis[now]+road[i].val<dis[road[i].to])

                    dis[road[i].to]=dis[now]+road[i].val,

                    q.push(make_pair(dis[road[i].to],road[i].to));

        }

}

int st[MAXN<<],tp;

void BuildGraph()

{

    S=,T=*(M+);

    for (int i=; i<=N; i++)

        {

            tp=;

            for (int j=head[i]; j; j=edge[j].next)

                st[++tp]=j;

            sort(st+,st+tp+,cmp);

            for (int j=; j<=tp; j++)

                {

                    int now=st[j],suc=st[j+];

                    if (edge[now].to==N) AddRoad(now,T,edge[now].val);

                    if (i==) AddRoad(S,now,edge[now].val);

                    AddRoad(now^,now,edge[now].val);

                    if (j<tp) AddRoad(now,suc,edge[suc].val-edge[now].val),AddRoad(suc,now,);

                }

        }

}

int main()

{

//  Freopen();

    N=read(),M=read();

    for (int x,y,z,i=; i<=M; i++) x=read(),y=read(),z=read(),InsertEdge(x,y,z);

    BuildGraph();

    Dijkstra();

    printf("%lld\n",dis[T]);

    return ;

}

小压一波常数，成功跑到rank2..想怒压300ms到rank1时，失误反而慢了300ms....23333

Orz现场裸跑最短路80分的梁哥....

貌似还有一种类似于DP的方法？