UVA 11478 bf+差分约束系统+二分逼近

Halum

You are given a directed graph G(V, E) with a set of vertices and edges. Each edge (i, j) that connects some vertex i to vertex j has an integer cost associated with that edge. Define the operation Halum(v, d) to operate on a vertex v using an integer d as follows: subtract d from the cost of all edges that enter v and add d to the cost of every edge that leaves v. As an example of that operation, consider graph G that has three vertices named (1, 2, 3) and two edges. Edge (1, 2) has cost -1, and edge (2,3) has cost 1. The operation Halum(2, −3) operates on edges entering and leaving vertex 2. Thus, edge (1, 2) gets cost -1-(-3)=2 and the edge (2, 3) gets cost 1 + (-3) = -2. Your goal is to apply the Halum function to a graph, potentially repeatedly, until every edge in the graph has at least a certain cost that is greater than zero. You have to maximize this cost.

Input

Two space-separated integers per case: V (V ≤ 500) and E (E ≤ 2700). E lines follow. Each line represents a directed edge using three space-separated integers (u, v, d). Absolute value of cost can be at most 10000.

Output

If the problem is solvable, then print the maximum possible value. If there is no such solution print ‘No Solution’. If the value can be arbitrary large print ‘Infinite’

Sample Input

2 1

1 2 10

2 1

1 2 -10

3 3

1 2 4

2 3 2

3 1 5

4 5

2 3 4

4 2 5

3 4 2

3 1 0

1 2 -1

Sample Output

Infinite

Infinite

3

1

思路:对于同一个节点，将多次操作合并，令sum(u)为u上所有节点的操作，问题转化为每条求权值均不小于x,对于a->b,操作完，它的权值为w(a,b)+sum(a)-sum(b)>=x,移项得sum(b)-sum(a)<=w(a,b)+x,得到可图个差分约束系统

差分约束系统可以用最短路径算法：对于约束条件xj-xi>=bk,新建一条边i->j,权值为bk，再加一个源点，从s出发与所有其他点相连，权值为0,再加一个源点s，从s出发与其他点相连，权值为0。在这个图上运行bf算法，则源点s到所有点i的距离就是xi的值。如果bf算法运行失败，即图中有负权环，则差分约束系统无解。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
#include <ctime>
using namespace std;

//#define EdsonLin

#ifdef EdsonLin
#define debug(...) fprintf(stderr,__VA_ARGS__)
#else
#define debug(...)
#endif // EdsonLin

typedef long long ll;
typedef double db;
const ll inf = 10010;
const int MAXN = 500;
const int MAXNN = 3e3+10;
const ll MOD = 1000000007;
const db eps = 1e-3;

struct bf{
    int n,m;
    int first[MAXN];
    struct edge{
        int st,to,next,dist;
    }e[MAXNN];
    int top;
    int d[MAXN];
    int inq[MAXN];
    int cnt[MAXN];
   /* bf(int n){
        this->n = n;
        memset(first,-1,sizeof(first));
        top = 0;
    }*/
    void init(int n){
        this->n = n;
        memset(first,-1,sizeof(first));
        top = 0;
    }
    void addege(int u,int v,int dist){
        e[top].st = u;
        e[top].to = v;
        e[top].dist = dist;
        e[top].next = first[u];
        first[u] = top++;
    }
    bool negativeCycle(){
        queue<int>Q;
        for(int i=0;i<n;i++){
            Q.push(i);
            cnt[i] = inq[i] = d[i] = 0;
        }
        inq[0] = 1;
        while(!Q.empty()){
            int u=Q.front();
            Q.pop();
            inq[u] = 0;
            for(int i=first[u];i!=-1;i=e[i].next){
                int v = e[i].to;
                if(d[v]>d[u]+e[i].dist){
                    d[v] = d[u]+e[i].dist;
                    if(!inq[v]){
                        cnt[v]++;
                        inq[v] = 1;
                        Q.push(v);
                        if(cnt[v]>n){
                            //cout<<"haha"<<endl;
                            return true;
                        }
                    }
                }
            }
        }
        return false;;
    }
} solver;


bool solve(int x){
    bool sg;
    for(int i=0;i<solver.top;i++){
        solver.e[i].dist -= x;
        //cout<<solver.e[i].dist<<endl;
    }
    sg = solver.negativeCycle();
    for(int i=0;i<solver.top;i++){
        solver.e[i].dist += x;
       // cout<<solver.e[i].dist<<endl;
    }
    return sg;
}

int main()
{

    #ifdef EdsonLin
        //freopen("1.in","r",stdin);
        //freopen("1.out","w",stdout);
        int _time_jc = clock();
    #endif // EdsonLin

    int n,m;
    while(cin>>n>>m){
        int u,v,dist;
        solver.init(n);
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&dist);
            u--;v--;
            solver.addege(u,v,dist);
        }
        if(!solve(inf)){
            cout<<"Infinite"<<endl;
            continue;
        }
        if(solve(1)){
            cout<<"No Solution"<<endl;
            continue;
        }
        int L,R,M;
        R = inf,L = 1;
        while(L<R){
            M = L+(R-L+1)/2;
            if(solve(M))R = M-1;
            else L = M;
        }
        cout<<L<<endl;

    }

    #ifdef EdsonLin
        debug("time: %d
",int(clock()-_time_jc));
    #endif // EdsonLin
    //cout << "Hello world!" << endl;
    return 0;
}