0x61 最短路

终于会dij了原来我以前写的也是堆优化spfa-_-!

poj3662DP 通过spfa来放缩（可怜我去年NOIP的day1t3啊）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;

struct node
{
    int x,y,d,next;
}a[];int len,last[];
void ins(int x,int y,int d)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].d=d;
    a[len].next=last[x];last[x]=len;
}

int list[];
int f[][];bool v[];
int main()
{
    int n,m,K,x,y,d;
    scanf("%d%d%d",&n,&m,&K);
    len=;memset(last,,sizeof(last));
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&d);
        ins(x,y,d);ins(y,x,d);
    }

    int head=,tail=;list[]=;
    memset(f,,sizeof(f));f[][]=;
    memset(v,false,sizeof(v));v[]=true;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            for(int p=;p<=K;p++)
            {
                int tt=f[y][p];
                if(p!=)f[y][p]=min(f[y][p],f[x][p-]);
                f[y][p]=min(f[y][p],max(f[x][p],a[k].d));

                if(tt!=f[y][p]&&v[y]==false)
                {
                    v[y]=true;
                    list[tail]=y;
                    tail++;if(tail==)tail=;
                }
            }
        }
        v[x]=false;
        head++;if(head==)head=;
    }
    if(f[n][K]==f[][])printf("-1\n");
    else printf("%d\n",f[n][K]);
    return ;
}

poj3662

最优贸易 正反dij分别求最小和最大，然后mx[x]-mn[x]就好（怎么这个专题净勾起我的伤心事啊，初一的某模拟赛就是没还原v数组100变没分啊啊啊）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;

struct node{int x,y,next;}a[],e[];
int alen,elen,alast[],elast[];
void ains(int x,int y)
{
    alen++;
    a[alen].x=x;a[alen].y=y;
    a[alen].next=alast[x];alast[x]=alen;
}
void eins(int x,int y)
{
    elen++;
    e[elen].x=x;e[elen].y=y;
    e[elen].next=elast[x];elast[x]=elen;
}

struct dij
{
    int k,id;
    dij(){}
    dij(int K,int ID){k=K;id=ID;}
    friend bool operator>(dij d1,dij d2){return d1.k>d2.k;}
    friend bool operator<(dij d1,dij d2){return d1.k<d2.k;}
};
priority_queue<dij,vector<dij>,greater<dij> >aq;
priority_queue<dij>eq;
int mn[],mx[];bool v[],inq[];

int w[];
int main()
{
    int n,m,x,y,op;
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++)scanf("%d",&w[i]);
    alen=;memset(alast,,sizeof(alast));
    elen=;memset(elast,,sizeof(elast));
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&op);
        if(op==)
            ains(x,y), eins(y,x);
        else
            ains(x,y),ains(y,x), eins(x,y),eins(y,x);
    }

    memset(v,false,sizeof(v));
    memset(inq,false,sizeof(inq));inq[]=true;
    mn[]=w[]; aq.push(dij(w[],));
    while(!aq.empty())
    {
        dij tno=aq.top();aq.pop();
        if(v[tno.id]==true)continue;
        v[tno.id]=true;

        int x=tno.id;
        for(int k=alast[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(inq[y]==false)
                inq[y]=true, mn[y]=w[y], aq.push(dij(mn[y],y));
            if(mn[y]>tno.k)
            {
                mn[y]=tno.k;
                aq.push(dij(mn[y],y));
            }
        }
    }

    memset(v,false,sizeof(v));
    memset(inq,false,sizeof(inq));inq[]=true;
    mx[n]=w[n], eq.push(dij(w[n],n));
    while(!eq.empty())
    {
        dij tno=eq.top();eq.pop();
        if(v[tno.id]==true)continue;
        v[tno.id]=true;

        int x=tno.id;
        for(int k=elast[x];k;k=e[k].next)
        {
            int y=e[k].y;
            if(inq[y]==false)
                inq[y]=true, mx[y]=w[y], eq.push(dij(mx[y],y));
            if(mx[y]<tno.k)
            {
                mx[y]=tno.k;
                eq.push(dij(mx[y],y));
            }
        }
    }

    int ans=;
    for(int i=;i<=n;i++)
        ans=max(ans,mx[i]-mn[i]);
    printf("%d\n",ans);
    /*
    for(int i=1;i<=n;i++)printf("%d ",mx[i]);
    printf("\n");
    for(int i=1;i<=n;i++)printf("%d ",mn[i]);
    printf("\n");*/
    return ;
}

最优贸易

bzoj2200 这题卡spfa（然而用酸辣粉和啦(fan)啦(you)啦(hua)这两个玄学优化可以过）

正解呢是topsort+dij，因为把正边看成联通块，负边其实构成的是一个DAG图，所以拓扑排序时顺便把环dij一次

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;

struct node
{
    int x,y,d,next;
}a[];int len,last[];
void ins(int x,int y,int d)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].d=d;
    a[len].next=last[x];last[x]=len;
}
int fa[];
int findfa(int x)
{
    if(fa[x]==x)return x;
    fa[x]=findfa(fa[x]);return fa[x];
}

int d[];
struct dij
{
    int k,id;
    dij(){}
    dij(int K,int ID){k=K;id=ID;}
    friend bool operator>(dij d1,dij d2){return d1.k>d2.k;}
    friend bool operator<(dij d1,dij d2){return d1.k<d2.k;}
}; bool v[];
priority_queue<dij,vector<dij>,greater<dij> >q;
void dijkstra(int st,int k)
{
    if(d[st]<=k)return ;
    d[st]=k;q.push(dij(d[st],st));
    memset(v,false,sizeof(v));
    while(!q.empty())
    {
        dij tno=q.top();q.pop();
        if(v[tno.id]==true)continue;
        v[tno.id]=true;

        int x=tno.id;
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(d[y]>d[x]+a[k].d)
            {
                d[y]=d[x]+a[k].d;
                q.push(dij(d[y],y));
            }
        }
    }
}

//----------------合并成联通块+dijkstra处理正环---------------------

struct enode
{
    int fx,fy,x,y,d,next;
}e[];int elen,elast[];
void eins(int fx,int fy,int x,int y,int d)
{
    elen++;
    e[elen].fx=fx;e[elen].fy=fy;
    e[elen].x=x;e[elen].y=y;e[elen].d=d;
    e[elen].next=elast[fx];elast[fx]=elen;
}
int du[],n,S;
int top,sta[];
void topsort()
{
    top=;sta[++top]=;
    eins(,findfa(S),,S,),du[findfa(S)]++;
    for(int i=;i<=n;i++)
        if(findfa(i)==i&&du[i]==&&i!=findfa(S))
            sta[++top]=i;
    while(top!=)
    {
        int fx=sta[top];top--;
        for(int k=elast[fx];k;k=e[k].next)
        {
            du[e[k].fy]--;
            if(du[e[k].fy]==)sta[++top]=e[k].fy;
        }
    }
    while(top!=)
    {
        int fx=sta[top];top--;
        for(int k=elast[fx];k;k=e[k].next)
        {
            dijkstra(e[k].y,d[e[k].x]+e[k].d);
            du[e[k].fy]--;
            if(du[e[k].fy]==)sta[++top]=e[k].fy;
        }
    }
}

//--------------topsort-------------------- 

int main()
{
    int R,P,x,y,dd;
    scanf("%d%d%d%d",&n,&R,&P,&S);
    len=;memset(last,,sizeof(last));
    for(int i=;i<=n;i++)fa[i]=i;
    for(int i=;i<=R;i++)
    {
        scanf("%d%d%d",&x,&y,&dd);
        ins(x,y,dd);ins(y,x,dd);

        int fx=findfa(x),fy=findfa(y);
        fa[fx]=fy;
    }

    memset(du,,sizeof(du));
    for(int i=;i<=P;i++)
    {
        scanf("%d%d%d",&x,&y,&dd);
        int fx=findfa(x),fy=findfa(y);
        eins(fx,fy,x,y,dd);
        du[fy]++;
    }
    memset(d,,sizeof(d));d[]=;
    topsort();

    for(int i=;i<=n;i++)
        if(d[i]==d[n+])printf("NO PATH\n");
        else printf("%d\n",d[i]);
    return ;
}

bzoj2200

poj1734 floyd求最小环，考虑对于一个环，把它拆分成前k-1个点和第k个点，当floyd完k-1次，得到的就是利用前k-1个点相互到达的最短路，此时再加上第k个点构成环，保证不重复，同时，取最大的点和取其他点，效果是一样的。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;

int a[][],mp[][];
int len,as[],pos[][];
void getpath(int i,int j)
{
    if(pos[i][j]==)return ;
    getpath(i,pos[i][j]);
    as[++len]=pos[i][j];
    getpath(pos[i][j],j);
}

int main()
{
    freopen("TRIP.in","r",stdin);
    freopen("TRIP.out","w",stdout);
    int n,m,x,y,d;
    scanf("%d%d",&n,&m);
    memset(mp,,sizeof(mp));
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&d);
        mp[x][y]=min(mp[x][y],d);
        mp[y][x]=min(mp[y][x],d);
    }
    memcpy(a,mp,sizeof(mp));

    int ans=mp[][];
    memset(pos,,sizeof(pos));
    for(int k=;k<=n;k++)
    {
        for(int i=;i<k;i++)
            for(int j=i+;j<k;j++)
            {
                if((long long)mp[i][j]+a[i][k]+a[k][j]<ans)
                {
                    ans=mp[i][j]+a[i][k]+a[k][j];
                    len=;
                    as[++len]=i;
                    getpath(i,j);
                    as[++len]=j;
                    as[++len]=k;
                }
            }

        for(int i=;i<=n;i++) if(i!=k)
            for(int j=;j<=n;j++) if(j!=k&&j!=i)
                if(mp[i][j]>mp[i][k]+mp[k][j])
                {
                    mp[i][j]=mp[i][k]+mp[k][j];
                    pos[i][j]=k;
                }
    }
    if(ans==mp[][])printf("No solution.\n");
    else
    {
        for(int i=;i<len;i++)printf("%d ",as[i]);
        printf("%d\n",as[len]);
    }

    return ;
}

poj1734

poj3613 神仙题

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;

struct line{int d,x,y;}li[];
int n,ls[];
struct Matrix{int mp[][];}A,ans;
Matrix calc(Matrix a,Matrix b)
{
    Matrix c;
    memset(c.mp,,sizeof(c.mp));
    for(int i=;i<=n;i++)
        for(int j=;j<=n;j++)
            for(int k=;k<=n;k++)
                c.mp[i][j]=min(c.mp[i][j],a.mp[i][k]+b.mp[k][j]);
    return c;
}
int main()
{
    int m,P,S,E;
    scanf("%d%d%d%d",&P,&m,&S,&E);
    n=;
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&li[i].d,&li[i].x,&li[i].y);
        ls[++n]=li[i].x;
        ls[++n]=li[i].y;
    }
    sort(ls+,ls+n+);
    n=unique(ls+,ls+n+)-ls-;
    for(int i=;i<=m;i++)
    {
        li[i].x=lower_bound(ls+,ls+n+,li[i].x)-ls;
        li[i].y=lower_bound(ls+,ls+n+,li[i].y)-ls;
    }
    S=lower_bound(ls+,ls+n+,S)-ls;
    E=lower_bound(ls+,ls+n+,E)-ls;
    //LSH

    memset(A.mp,,sizeof(A.mp));
    for(int i=;i<=m;i++)
    {
        int x=li[i].x,y=li[i].y;
        A.mp[x][y]=min(A.mp[x][y],li[i].d);
        A.mp[y][x]=min(A.mp[y][x],li[i].d);
    }
    memcpy(ans.mp,A.mp,sizeof(A.mp));
    P--;
    while(P!=)
    {
         if(P%==)ans=calc(ans,A);
        A=calc(A,A);P/=;
    }
    printf("%d\n",ans.mp[S][E]);
    return ;
}

poj3613