洛谷 P5960 【模板】差分约束算法 SPFA/Bellman-Ford

m m m 个不等式,有 n n n 个未知数,求任意一组解。

每个不等式形如: x c − x c ′ ≤ y x_c-x_{c'}\le y xcxcy

洛谷 P5960 【模板】差分约束算法 SPFA/Bellman-Ford_第1张图片

思路:每个差分约束可以转变为 x c ≤ x c ′ + y x_c\le x_{c'}+y xcxc+y 这个形式类似于单源最短路径中的三角不等式 d [ y ] ≤ d [ x ] + z d[y]\le d[x]+z d[y]d[x]+z ,因此令 c , c ′ c,c' c,c 为结点的编号, c ′ c' c c c c 连一条距离为 y y y 的有向边,然后令 d [ 0 ] = 0 d[0]=0 d[0]=0 并向每一个点连一条边,跑单源最短路径,若存在负环,则无解,有解时为 d d d 各元素的值。

判负环:用 Bellman-Ford 或队列优化后的 Bellman-Ford (SFPA),最坏时间复杂度: O ( n m ) O(nm) O(nm)

#include
#include
#include
#include
#define MAXN 5010
#define MAXM 10010
#define INF 0x3f3f3f3f
using namespace std;
int head[MAXN],vis[MAXN],d[MAXN],n,m,tot;
int cnt[MAXN];
struct Edge{
    int v,w,nxt;
}edge[MAXM];
void addedge(int u,int v,int w){
    edge[tot].v=v;edge[tot].w=w;
    edge[tot].nxt=head[u];head[u]=tot++;
}
bool spfa(int s){
    queue<int> q;
    memset(d,INF,sizeof(d));
    d[s]=0;vis[s]=1;
    q.push(s);
    while(!q.empty()){
        int u=q.front();q.pop();
        vis[u]=0; // vis 实质上是该结点是否在队列中的标志
        // 出队列时清除标志,也就是说,同一个结点有可能访问多次
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].v;
            if(d[v]>d[u]+edge[i].w){
                d[v]=d[u]+edge[i].w; // 先进行d松弛
                if(!vis[v]){  // 再判断目标结点是否已经在队列中
                    vis[v]=1;cnt[v]++; // 入队列时标志为1
                    if(cnt[v]==n)return false;
                    q.push(v);
                }
            }
        }
    }
    return true;
}
int main(){
#ifdef WINE
    freopen("data.in","r",stdin);
#endif
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        addedge(0,i,0);
    for(int i=1;i<=m;i++){
        int u,v,w;
        scanf("%d%d%d",&v,&u,&w);
        addedge(u,v,w);
    }
    if(!spfa(0))printf("NO\n");
    else
        for(int i=1;i<=n;i++)
            printf("%d ",d[i]);
    return 0;
}

洛谷 P5960 【模板】差分约束算法 SPFA/Bellman-Ford_第2张图片

你可能感兴趣的:(最短路,差分约束)