POJ 1364 / HDU 3666 【差分约束-SPFA】

POJ 1364

题解：最短路式子：d[v]<=d[u]+w

式子1：sum[a+b+1]−sum[a]>c      —      sum[a]<=sum[a+b+1]−c−1       —      (a+b+1,a) −c−1

式子2：sum[a+b+1]−sum[a]<c      —      sum[a+b+1]<=sum[a]+c−1       —      (a,a+b+1)  c−1

注意：先移项，移项完后再处理没有等于的情况。

附加式：sum[0]<=sum[i]+0  —— (i,0) 0 连通所有点

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

const int N=105;
const int INF=0x3f3f3f3f;
int n,m,cnt;
int head[N],d[N],Time[N];
bool vis[N];

struct edge{
    int to,next,w;
}edge[N<<1];

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

void init(){
    cnt=0;
    memset(Time,0,sizeof(Time));
    memset(head,-1,sizeof(head));
}

bool SPFA(int st){
    for(int i=0;i<N;i++) d[i]=INF;
    memset(vis,false,sizeof(vis));
    queue <int> Q;
    Q.push(st);
    d[st]=0;
    vis[st]=true;
    Time[st]=1;
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next){
            int v=edge[i].to;
            if(d[v]>d[u]+edge[i].w){
                d[v]=d[u]+edge[i].w;
                if(!vis[v]){
                    Q.push(v);
                    vis[v]=true;
                    Time[v]++;
                    if(Time[v]>n) return false;
                }
            }
        }
    }
    return true;
}

int main(){
    while(scanf("%d",&n)!=EOF&&n){
        init();
        scanf("%d",&m);
        // 约束：s[0]<=s[i]+0
        for(int i=1;i<=n;i++) add(i,0,0);// 保证所有点连通 
        char op[10];
        for(int i=1;i<=m;i++){
            int a,b,c;
            scanf("%d%d%s%d",&a,&b,&op,&c);
            if(op[0]=='g') add(a+b,a-1,-c-1);
            else add(a-1,a+b,c-1);
        }
        if(SPFA(0)) printf("lamentable kingdom
");
        else printf("successful conspiracy
");
    }
    return 0;
}

HDU 3666

题解：由题意得：L<=c[i][j]∗a[i]/b[j]<=U 两边除以c[i][j]c[i][j]    —    L/c[i][j]<=a[i]/b[j]<=U/c[i][j]，先两边取对数，得到log(L/c[i][j])<=log(a[i])−log(b[j])<=log(U/c[i][j])，推导出两个式子：

式子1：log(a[i])<=log(U/c[i][j])+log(b[j])

式子2：log(b[j])<=log(a[i])−log(L/c[i][j])

注意：log取double型，n个a和m个b连接，保证了图的连通性，不需要新建边。数据范围注意，有n∗m个点和2∗n∗m条边。注意剪枝

如果有起点，终点的约束，起点d[]距离就赋值为0，其余赋值为无穷。而对于没有起点，终点的约束，全部d[]距离都赋值为无穷。spfa算法，把所有点一开始都入队，这样每个点都遍历到了，就能保证不会有负环由于图的不连通而不被找到。差分约束能把所有约束条件转换成边求最短路，判断负环来解决问题。

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

const int N=400+10;
int n,m,cnt;
const double INF=1e12;
double l,r,c[N][N],d[N*2];
int head[N*2],Time[N*2];
bool vis[N*2];

struct e{
    int to,next;
    double w;
}edge[N*N*2]; // 有反向边

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

void init(){
    cnt=0;
    memset(Time,0,sizeof(Time));
    memset(head,-1,sizeof(head));
}

bool SPFA(int s)
{
    for(int i=0;i<2*N;i++) d[i]=INF;
    memset(vis,0, sizeof(vis));
    queue<int> q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    Time[s]=1;
    while(q.size())
    {
        int u = q.front();q.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            double w=edge[i].w;
            if(d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                    if(++Time[v]>sqrt(n+m))return false;
                }
            }
        }
    }
    return true;
}


int main(){
    while(scanf("%d%d%lf%lf",&n,&m,&l,&r)!=EOF){
        init();
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
            {
                scanf("%lf",&c[i][j]);
                add(j+n,i,log(r/c[i][j]));
                add(i,j+n,log(c[i][j]/l));
            }
        if(SPFA(1)) cout<<"YES"<<endl; // 从连通的顶点开始
        else cout<<"NO"<<endl;
    }
    return 0;
}