UVA 11478 bf + differential constraint system + bisection approximation

Hallum

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

Idea: For the same node, combine multiple operations, let sum(u) be the operation of all nodes on u, and the problem is that each weighted value is not less than x. For a->b, after the operation, its The weight is w(a,b)+sum(a)-sum(b)>=x, and the shift term is sum(b)-sum(a)<=w(a,b)+x, and the graph is obtained Differential Constraint System

The differential constraint system can use the shortest path algorithm: for the constraint condition xj-xi>=bk, create a new edge i->j, the weight is bk, add a source point, start from s and connect to all other points, the weight is 0, plus a source point s, starting from s and connecting to other points, the weight is 0. Running the bf algorithm on this graph, the distance from the source point s to all points i is the value of xi. If the bf algorithm fails, that is, there are negative weight loops in the graph, the differentially constrained system has no solution.

#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;
}

intmain ()
{

    #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\n",int(clock()-_time_jc));
    #endif // EdsonLin
    //cout << "Hello world!" << endl;
    return 0;
}

bf template

Reprinted in: https://www.cnblogs.com/EdsonLin/p/5524455.html

UVA 11478 bf + differential constraint system + bisection approximation

Guess you like