zoukankan      html  css  js  c++  java
  • [ACdream 1211 Reactor Cooling]无源无汇有上下界的可行流

    题意:无源无汇有上下界的可行流 模型

    思路:首先将所有边的容量设为上界减去下界,然后对一个点i,设i的所有入边的下界和为to[i],所有出边的下界和为from[i],令它们的差为dif[i]=to[i]-from[i],根据流量平衡原理,让出边和入边的下界相抵消,如果dif[i]>0,说明入边把出边的下界抵消了,还剩下dif[i]的流量必须要流过来(否则不满足入边的下界条件),这时从源点向i连一条容量为dif[i]的边来表示即可,如果dif[i]<0,同理应该从i向汇点连一条容量为-dif[i]的边。最后对新建好的图跑一遍最大流,如果源点的所有出边都满流了说明原图有可行流,可行解为每条边在新图的流量加上它的下界。

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    #pragma comment(linker, "/STACK:10240000")
    #include <map>
    #include <set>
    #include <cmath>
    #include <ctime>
    #include <deque>
    #include <queue>
    #include <stack>
    #include <vector>
    #include <cstdio>
    #include <string>
    #include <cstdlib>
    #include <cstring>
    #include <iostream>
    #include <algorithm>
    
    using namespace std;
    
    #define X                   first
    #define Y                   second
    #define pb                  push_back
    #define mp                  make_pair
    #define all(a)              (a).begin(), (a).end()
    #define fillchar(a, x)      memset(a, x, sizeof(a))
    #define fillarray(a, b)     memcpy(a, b, sizeof(a))
    
    typedef long long ll;
    typedef pair<int, int> pii;
    typedef unsigned long long ull;
    
    #ifndef ONLINE_JUDGE
    namespace Debug {
    void RI(vector<int>&a,int n){a.resize(n);for(int i=0;i<n;i++)scanf("%d",&a[i]);}
    void RI(){}void RI(int&X){scanf("%d",&X);}template<typename...R>
    void RI(int&f,R&...r){RI(f);RI(r...);}void RI(int*p,int*q){int d=p<q?1:-1;
    while(p!=q){scanf("%d",p);p+=d;}}void print(){cout<<endl;}template<typename T>
    void print(const T t){cout<<t<<endl;}template<typename F,typename...R>
    void print(const F f,const R...r){cout<<f<<", ";print(r...);}template<typename T>
    void print(T*p, T*q){int d=p<q?1:-1;while(p!=q){cout<<*p<<", ";p+=d;}cout<<endl;}
    }
    #endif // ONLINE_JUDGE
    
    template<typename T>bool umax(T&a, const T&b){return b<=a?false:(a=b,true);}
    template<typename T>bool umin(T&a, const T&b){return b>=a?false:(a=b,true);}
    
    const double PI = acos(-1.0);
    const int INF = 0x3f3f3f3f;
    const double EPS = 1e-14;
    
    /* -------------------------------------------------------------------------------- */
    
    const int maxn = 2e2 + 7;
    
    struct Dinic {
    private:
        //const static int maxn = 1e3 + 7;
        struct Edge {
            int from, to, cap, least;
            Edge(int u, int v, int w, int l): from(u), to(v), cap(w), least(l) {}
        };
        int s, t;
        vector<Edge> edges;
        vector<int> G[maxn];
        bool vis[maxn];
        int d[maxn], cur[maxn];
    
        bool bfs() {
            memset(vis, 0, sizeof(vis));
            queue<int> Q;
            Q.push(s);
            d[s] = 0;
            vis[s] = true;
            while (!Q.empty()) {
                int x = Q.front(); Q.pop();
                for (int i = 0; i < G[x].size(); i ++) {
                    Edge &e = edges[G[x][i]];
                    if (!vis[e.to] && e.cap) {
                        vis[e.to] = true;
                        d[e.to] = d[x] + 1;
                        Q.push(e.to);
                    }
                }
            }
            return vis[t];
        }
        int dfs(int x, int a) {
            if (x == t || a == 0) return a;
            int flow = 0, f;
            for (int &i = cur[x]; i < G[x].size(); i ++) {
                Edge &e = edges[G[x][i]];
                if (d[x] + 1 == d[e.to] && (f = dfs(e.to, min(a, e.cap))) > 0) {
                    e.cap -= f;
                    edges[G[x][i] ^ 1].cap += f;
                    flow += f;
                    a -= f;
                    if (a == 0) break;
                }
            }
            return flow;
        }
    
    public:
        void clear() {
            for (int i = 0; i < maxn; i ++) G[i].clear();
            edges.clear();
            memset(d, 0, sizeof(d));
        }
        void add(int from, int to, int cap, int least) {
            edges.push_back(Edge(from, to, cap, least));
            edges.push_back(Edge(to, from, 0, least));
            int m = edges.size();
            G[from].push_back(m - 2);
            G[to].push_back(m - 1);
        }
    
        int solve(int s, int t) {
            this->s = s; this->t = t;
            int flow = 0;
            while (bfs()) {
                memset(cur, 0, sizeof(cur));
                flow += dfs(s, 1e9);
            }
            return flow;
        }
    
        void out(int m) {
            for (int i = 0; i < m; i ++) {
                printf("%d
    ", edges[i << 1].least + edges[i << 1 | 1].cap);
            }
        }
    };
    Dinic solver;
    int tob[maxn], fromb[maxn];
    
    int main() {
    #ifndef ONLINE_JUDGE
        freopen("in.txt", "r", stdin);
        //freopen("out.txt", "w", stdout);
    #endif // ONLINE_JUDGE
        int n, m;
        while (cin >> n >> m) {
            solver.clear();
            fillchar(tob, 0);
            fillchar(fromb, 0);
            for (int i = 0; i < m; i ++) {
                int u, v, b, c;
                scanf("%d%d%d%d", &u, &v, &b, &c);
                solver.add(u, v, c - b, b);
                tob[v] += b;
                fromb[u] += b;
            }
            int total = 0;
            for (int i = 1; i <= n; i ++) {
                int dif = tob[i] - fromb[i];
                if (dif > 0) solver.add(0, i, dif, 0);
                if (dif < 0) solver.add(i, n + 1, - dif, 0);
                total += abs(dif);
            }
            if (solver.solve(0, n + 1) != total / 2) puts("NO");
            else {
                puts("YES");
                solver.out(m);
            }
        }
        return 0;
    }
    
  • 相关阅读:
    IOE是软件时代或是“买计算机”时代的产物;而云计算时代,则是“买计算”的时代。从本质上来说,“去IOE”是一个企业从传统企业向互联网企业转型的标志。
    物联网听起来像是一个和互联网不同的网,"万物互联"又把"网"给弄丢了,正向我们扑面而来的是"万物互联网"。
    移动互联网真正带来的影响,是使人们的大部分时间都消耗在在线社会上了。
    中国剩余定理
    HDU-1013九余数定理
    HDU--1213并查集
    HDU--1232畅通工程
    并查集
    简单的快速幂取模
    线段树
  • 原文地址:https://www.cnblogs.com/jklongint/p/4759173.html
Copyright © 2011-2022 走看看