最短路的简单变式(dj贪心可扩展性、spfa的妙用)

不小心用了傻逼edge，导致粘贴代码的是全部卡死。
结果是什么呢，写的解析全部没有了，现在也没有啥心情重写了。就写概括点把。
简单来说就是：对于$Dijsktra$算法是局部贪心可扩展到全局最优。但是如果存在负权或者求最长路是不满足的，所以非法。接下来的一道题就是一道变式$Dij$，这道题是满足性质的，所以可以松弛得到最优。

题目：POJ 1797
求路径最小边可能的最大值。
对于当前最大的$min(d)$，其他的点$min$是比当前值小的，而且不可能通过后续的更新(因为取的是最小)来得到更优，也就是可以用$Dijsktra$的贪心来松弛得到最优。

const int maxn = 2000050;

#define ll long long

vector<pair<int,int> >G[3030];

int n,m;
int d[maxn];
bool vis[maxn];
priority_queue<pair<int,int>,vector<pair<int,int> > > q;

int dijkstra(int s,int t){
    memset(d,0,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0x3f3f3f3f;
    q.push(make_pair(d[s],s));
    while(!q.empty()){
        int now=q.top().second;q.pop();
        if(!vis[now]){
            vis[now]=true;
            for(int i=0;i<G[now].size();i++){
                pair<int,int>e=G[now][i];
                if(d[e.second]<min(d[now],e.first)){
                    d[e.second]=min(d[now],e.first);
                    q.push(make_pair(d[e.second],e.second));
                }
            }
        }
    }
    return d[n]==0?-1:d[n];
}

int main(){
    int T;cin>>T;
    FOR(k,1,T){
        cin>>n>>m;
        FOR(i,1,n)G[i].clear();
        FOR(i,1,m){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            G[x].push_back(make_pair(z,y));
            G[y].push_back(make_pair(z,x));
        }
        printf("Scenario #%d:\n%d\n\n",k,dijkstra(1,n));
    }
}

对于多源固定终点的题目：因为$dijsktra$实质上求的是对于单源多终点的最短路，所以我们可以通过反向建边的方式：$a$到$b$的最短路等同于$b$到$a$的最短路，这样就可以求解了。无向图自然不需要反向建图，下面一题是对于有向图的

又是一道好题：POJ - 3268
题目要求每个点到终点并返回的最短距离
这道题是对于多源固定终点的最短路求解。
正向建图求回来路径，反向建图求过去路径，用数组存储中间信息，取最大值，得到答案

#include<bits/stdc++.h>
using namespace std;

#define ll long long

const int maxn = 1010;

int n,m,t;
vector<pair<int,int> >G[2][maxn];

bool vis[maxn];
int d[2][maxn];
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > >q;

int dijkstra(int s,int mark){
    memset(vis,0,sizeof(vis));
    memset(d[mark],0x3f,sizeof(d[mark]));
    d[mark][s]=0;
    q.push(make_pair(0,s));
    while(!q.empty()){
        int now=q.top().second;q.pop();
        if(!vis[now]){
            vis[now]=true;
            for(int i=0;i<G[mark][now].size();i++){
                pair<int,int>e = G[mark][now][i];
                if(!vis[e.second]&&d[mark][e.second]>d[mark][now]+e.first){
                    d[mark][e.second]=d[mark][now]+e.first;
                    q.push(make_pair(d[mark][e.second],e.second));
                }
            }
        }
    }
}

int main(){
    cin>>n>>m>>t;
    FOR(i,1,m){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        G[0][x].push_back(make_pair(z,y));
        G[1][y].push_back(make_pair(z,x));
    }
    dijkstra(t,0);
    dijkstra(t,1);
    int ans=-1;
    FOR(i,1,n)if(i!=t){
        ans=max(ans,d[0][i]+d[1][i]);
    }
    cout<<ans<<endl;
}

这里对于$spfa$进行一步说明，$spfa$本身就是通过尽可能地去松弛得到最优解，也就是spfa不需要考虑贪心与否，只要知道松弛过后点所对应边的另一个点也应该被松弛。也就是说我们可以用$spfa$求得无环最长路
当然这里的题目并不是单单要求最长路，但是现在我们已经能够知道它能求最长路
$spfa$是不断入队松弛的，但是每个点最多被松弛$n-1$次，只有$n-1$个点最多与它有边。所以我们可以判断是否有环，通过记录入队次数。
有正、负环的时候就无法计算了，因为最长路有正环，最短路有负环，绕着环松弛会越来越优，但是不会有最终结果。当然最长路负环是没问题的，最短路正环也是，但是没必要。
PS：插一句话：$dj$算法可以处理有环但不是负环。

好题：POJ - 1860
题意就是求最长路，不过每次松弛都需要依靠前面的值去计算。计算公式：$(money-commsion)\ast rate$，去判断这个是否大于下一个点已经有的值。最后如果能够增加原来的钱输出$YES$
因为本身走一个环回来，所以只要判断是否有正环即可，$spfa$最长路再判断入队次数即可

#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
using namespace std;

#define ll long long

int n,m;

const int maxn = 510;

double rate[maxn][maxn],comm[maxn][maxn];

bool inq[maxn];queue<int>q;
int num[maxn];double d[maxn];

bool spfa(int s,double money){
    q.push(s);
    inq[s]=true;
    memset(num,0,sizeof(num));
    memset(d,0,sizeof(d));
    d[s]=money;
    while(!q.empty()){
        int now=q.front();q.pop();
        inq[now]=false;
        for(int i=1;i<=n;i++)if(i!=now){
            if(d[i]<(d[now]-comm[now][i])*rate[now][i]){
                d[i]=(d[now]-comm[now][i])*rate[now][i];
                if(!inq[i]){
                    num[i]++;
                    q.push(i);
                    if(num[i]>n-1)return true;
                    inq[i]=true;
                }
            }
        }
    }
    return false;
}

int main(){
    int s;double start;
    cin>>n>>m>>s>>start;
    FOR(i,1,m){
        int x,y;double a,b,c,d;
        scanf("%d%d%lf%lf%lf%lf",&x,&y,&a,&b,&c,&d);
        rate[x][y]=a,rate[y][x]=c;
        comm[x][y]=b,comm[y][x]=d;
    }
    if(spfa(s,start))puts("YES");
    else puts("NO");
}

正常$Dji$是对点向外更新，其实我们也可以用边更新，不过复杂度不太优秀
csu地铁的另外一道类似题，也是相邻边会相互影响，非要，相同边无费用，边不同的时候费用为1。
这道题要求我们对边进行考虑，不只是单单对点考虑。
我们考虑的方式是这样的，将$dij$中点向外更新改为边松弛，边向外跟更新。每次点会被多条连着的边更新。
不过复杂度可能会达到$O(m^2)$，所以我被卡了。
但是：这种边松弛的方式也属于一个不错的变式。【只需要$3$个点$m$条边，每次更新一条边都会遍历$\frac{m}{2}$，所以相当于卡到底了】

上来赋值保证上面5条边答案为1，第一条更新下面5条边，之后每次都会重复更新(只会修改自己颜色的答案，但是其他的都会遍历)。所以复杂度非常爆炸。但是值得学习

#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ll long long
using namespace std;

const int maxn=100000;
const int maxm=400050;

int n,m;

struct Edge{
    int from,to,dist;
    Edge(){}
    Edge(int _from,int _to,int _dist):from(_from),to(_to),dist(_dist){}
};
Edge ed[maxm];int he[maxn],ne[maxm],etop=1;
void insert(int u,int v,int w){ed[etop]=Edge(u,v,w);ne[etop]=he[u];he[u]=etop++;}

int d[maxm];
bool vis[maxm];
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > q;
ll dijkstra(int s,int t){
    int ans=0x3f3f3f3f;
    memset(vis,0,sizeof(vis));
    memset(d,0x3f,sizeof(d));
    for(int i=he[s];i;i=ne[i]){
        d[i]=1;
        q.push(make_pair(1,i));
    }
    while(!q.empty()){
        int cur = q.top().second, now = ed[cur].to;
        q.pop();
        if(!vis[cur]){
            if(now==t)ans=min(ans,d[cur]);
            vis[cur] = true;
            for(int i = he[now]; i; i = ne[i]){
                Edge& e = ed[i];
                if(d[i]>d[cur]+((ed[cur].dist==e.dist)?0:1)){
                    d[i] = d[cur]+((ed[cur].dist==e.dist)?0:1);
                    q.push(make_pair(d[i], i));
                }
            }
        }
    }
    if(ans==0x3f3f3f3f)ans=-1;
    return ans;
}

int main(){
    cin>>n>>m;
    FOR(i,1,m){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        insert(x,y,z);
        insert(y,x,z);
    }
    cout<<dijkstra(1,n)<<endl;
}