【bzoj 4289】PA2012 Tax （SPFA）

4289: PA2012 Tax

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 175  Solved: 71
[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

12

HINT

Source

[Submit][Status][Discuss]

【题解】【最短路】

[附学长题解：考虑利用差值来建边.依然把每条边x-y拆成x->y,y->x.枚举每个中转点x.
将x的出边按权值排序,x的每条入边向对应的出边连该边权值的边,x的每条出边向第一个比它大的出边连两边权差值的边,x的每条出边向第一个比它小的出边连权值为0的边.新建源汇S,T,S向每条1的出边连权值为该边边权的边. 每条n的入边向T连该边权值的边.跑S->T的最短路即可.这样边数是O(M)的.]

(不知道有没有人看懂，反正我没看懂)

【实际上，简单地说就是化边为点，重新建图。原图的所有关系都要保留，并且每两个点之间的边都按照有向边来建，建一条x->y和一条y->x的边。新建源点和终点S、T,新图中的每个点，是旧图中每条边存储时的序号，将原图中连向n点的边连向T，边权为原图中边的权值；从S连一条边向从1出发的边，边权为原图中边的权值；并把从每个点出发的所有边，按权值排序，每条边向比下一条边连边，权值为两边的差值，然后再反向连一条权值为0的边。新图为有向图。然后跑最短路】

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
struct hq{
    int num;
    ll val;
    bool operator<(const hq &ai)const
     {return val>ai.val;}
};
struct hp{
    int s,t,w;
}a[500010],d[5000010];
priority_queue<hq>que;
int p[100010],nxt[500010],tot=1;
int point[400010],next[5000010],tt;
int n,m,xl[200010],S,T;
ll dis[400010];
bool b[400010];
int tmp(int x,int y)
{
    return a[x].w<a[y].w;
}
inline void add(int x,int y,int v)
{
    tot++; a[tot].s=x; a[tot].t=y; a[tot].w=v; nxt[tot]=p[x]; p[x]=tot;
    tot++; a[tot].s=y; a[tot].t=x; a[tot].w=v; nxt[tot]=p[y]; p[y]=tot;
}
inline void add1(int x,int y,int v)
{
    tt++; d[tt].s=x; d[tt].t=y; d[tt].w=v; next[tt]=point[x]; point[x]=tt;
}
inline void spfa(int S)
{
    memset(dis,127/3,sizeof(dis));
    que.push((hq){S,0}); dis[S]=0; 
    while(!que.empty())
     {
        hq now=que.top(); que.pop();
        if(b[now.num]) continue;
        int u=point[now.num]; b[now.num]=true;
        while(u!=-1)
         {
            if(dis[d[u].t]>dis[now.num]+(ll)d[u].w)
             {
                dis[d[u].t]=dis[now.num]+(ll)d[u].w;
                que.push((hq){d[u].t,dis[d[u].t]});
               }
            u=next[u];
          }
     }
    return;
}
int main()
{
    int i,j;
    memset(p,-1,sizeof(p));
    memset(nxt,-1,sizeof(nxt));
    memset(next,-1,sizeof(next));
    memset(point,-1,sizeof(point));
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;++i)
     {
        int x,y,v;
        scanf("%d%d%d",&x,&y,&v);
        add(x,y,v);
     }
    S=1; T=2*(m+1);
    for(i=1;i<=n;++i)
     {
        int t=0;
        for(j=p[i];j!=-1;j=nxt[j]) xl[++t]=j;
        sort(xl+1,xl+t+1,tmp);
        for(j=1;j<=t;++j)
         {
            if(a[xl[j]].t==n) add1(xl[j],T,a[xl[j]].w);
            if(i==1) add1(S,xl[j],a[xl[j]].w);
            add1(xl[j]^1,xl[j],a[xl[j]].w);
            if(j<t)
             {
                add1(xl[j],xl[j+1],a[xl[j+1]].w-a[xl[j]].w);
                add1(xl[j+1],xl[j],0);
               }
          }
     }
    spfa(S);
    printf("%lld\n",dis[T]);
    return 0;
}