POJ 2396 Budget (有源汇有上下界的可行流)

POJ 2396 Budget

链接:http://poj.org/problem?id=2396

题意:给定一个M*N的矩阵,给定每行每列的和,以及其中一些值的限定条件,问能否构成一个可行的矩阵。

思路:

添加一个源点,向每行连边,每条边的上下界都为该行的和;添加一个汇点,每列向汇点连边,边的上下界都为该列的和。然后每行向每列连边,边的上下界一开始为(0,INF),之后通过一些限定条件更新。

现在问题成了求一个有源汇有上下界的可行流。只需要再添加一个超级源点,一个超级汇点,并且将原图的汇点向源点连边,求一个可行流即可。

细节:这道题目的构图比较麻烦。

/*
ID: [email protected]
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define INF (1 << 30)
#define LINF (1LL << 60)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define eps 1e-6
#define debug puts("===============")
#define pb push_back
#define mkp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define POSIN(x,y) (0 <= (x) && (x) < n && 0 <= (y) && (y) < m)
typedef long long ll;
typedef unsigned long long ULL;
const int maxn = 2000;
const int maxm = 2000000;
struct node {
    int v;    // vertex
    int cap;    // capacity
    int flow;   // current flow in this arc
    int nxt;
} e[maxm * 2];
int g[maxn], cnt;
int st, ed, n, N, M, S, T;
int id[maxm];
void add(int u, int v, int c, int k) {
    e[++cnt].v = v;
    e[cnt].cap = c;
    e[cnt].flow = 0;
    e[cnt].nxt = g[u];
    g[u] = cnt;
    id[k] = cnt;

    e[++cnt].v = u;
    e[cnt].cap = 0;
    e[cnt].flow = 0;
    e[cnt].nxt = g[v];
    g[v] = cnt;
    id[0] = 0;
}
int sum1, sum2;
int low[maxm], up[maxm], tot[maxn];
bool flag;
bool set_edge(int i, int j, char* str, int c) {
    int x = (i - 1) * N + j;
    if (str[0] == '=') {
        if (low[x] <= c && c <= up[x]) low[x] = up[x] = c;
        else return false;
    }
    else if (str[0] == '<') {
        if (low[x] < c) up[x] = min(up[x], c - 1);
        else return false;
    }
    else if (str[0] == '>') {
        if (up[x] > c) low[x] = max(low[x], c + 1);
        else return false;
    }
    return true;
}
int sum;
void init() {
    memset(g, 0, sizeof(int) * (M + N + 10));
    memset(tot, 0, sizeof(int) * (M + N + 10));
    cnt = 1;
    st = M + N + 2, ed = M + N + 3;
    S = 0, T = M + N + 1;
    int u, v, c;
    sum1 = sum2 = 0;
    for (int i = 1; i <= M; i++) {
        scanf("%d", &c);
        tot[S] -= c;
        tot[i] += c;
        sum1 += c;
    }
    for (int i = 1; i <= N; i++) {
        scanf("%d", &c);
        tot[T] += c;
        tot[i + M] -= c;
        sum2 += c;
    }
    flag = true;
    if (sum1 != sum2) flag = false;
    int k;
    scanf("%d", &k);
    memset(low, 0, sizeof(int) * (M * N + 10));
    fill(up, up + sizeof(int) * (M * N + 10), INF);
    char str[10];
    while(k--) {
        scanf("%d%d%s%d", &u, &v, str, &c);
        if (flag) {
            int rst, red, cst, ced;
            if (u == 0) rst = 1, red = M;
            else rst = red = u;
            if (v == 0) cst = 1, ced = N;
            else cst = ced = v;
            for (int i = rst; i <= red; i++) {
                for (int j = cst; j <= ced; j++) {
                    if (!set_edge(i, j, str, c)) {
                        flag = false;
                        goto FK;
                    }
                }
            }
            FK:;
        }
    }
    if (!flag) return ;
    add(T, S, INF, 0);
    for (int i = 1; i <= M; i++) {
        for (int j = 1; j <= N; j++) {
            int x = (i - 1) * N + j;
            tot[i] -= low[x];
            tot[j + M] += low[x];
            add(i, j + M, up[x] - low[x], x);
        }
    }
    sum = 0;
    for (int i = 0; i <= M + N + 1; i++) {
        if (tot[i] > 0) add(st, i, tot[i], 0), sum += tot[i];
        if (tot[i] < 0) add(i, ed, -tot[i], 0);
    }
    n = ed + 3;
}
int dist[maxn], numbs[maxn], q[maxn];
void rev_bfs() {
    int font = 0, rear = 1;
    for (int i = 0; i <= n; i++) { //n为总点数
        dist[i] = maxn;
        numbs[i] = 0;
    }
    q[font] = ed;
    dist[ed] = 0;
    numbs[0] = 1;
    while(font != rear) {
        int u = q[font++];
        for (int i = g[u]; i; i = e[i].nxt) {
            if (e[i ^ 1].cap == 0 || dist[e[i].v] < maxn) continue;
            dist[e[i].v] = dist[u] + 1;
            ++numbs[dist[e[i].v]];
            q[rear++] = e[i].v;
        }
    }
}
int maxflow() {
    rev_bfs();
    int u, totalflow = 0;
    int curg[maxn], revpath[maxn];
    for(int i = 0; i <= n; ++i) curg[i] = g[i];
    u = st;
    while(dist[st] < n) {
        if(u == ed) {   // find an augmenting path
            int augflow = INF;
            for(int i = st; i != ed; i = e[curg[i]].v)
                augflow = min(augflow, e[curg[i]].cap);
            for(int i = st; i != ed; i = e[curg[i]].v) {
                e[curg[i]].cap -= augflow;
                e[curg[i] ^ 1].cap += augflow;
                e[curg[i]].flow += augflow;
                e[curg[i] ^ 1].flow -= augflow;
            }
            totalflow += augflow;
            u = st;
        }
        int i;
        for(i = curg[u]; i; i = e[i].nxt)
            if(e[i].cap > 0 && dist[u] == dist[e[i].v] + 1) break;
        if(i) {   // find an admissible arc, then Advance
            curg[u] = i;
            revpath[e[i].v] = i ^ 1;
            u = e[i].v;
        } else {    // no admissible arc, then relabel this vertex
            if(0 == (--numbs[dist[u]])) break;    // GAP cut, Important!
            curg[u] = g[u];
            int mindist = n;
            for(int j = g[u]; j; j = e[j].nxt)
                if(e[j].cap > 0) mindist = min(mindist, dist[e[j].v]);
            dist[u] = mindist + 1;
            ++numbs[dist[u]];
            if(u != st)
                u = e[revpath[u]].v;    // Backtrack
        }
    }
    return totalflow;
}
int main () {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &M, &N);
        init();
        if (!flag) puts("IMPOSSIBLE");
        else {
            int dd = maxflow();
            if (dd != sum) {
                puts("IMPOSSIBLE");
                continue;
            }
            for (int i = 1; i <= M; i++) {
                for (int j = 1; j <= N; j++) {
                    int x = (i - 1) * N + j;
                    printf("%d%c", low[x] + e[id[x]].flow, j == N ? '\n' : ' ');
                }
            }
        }
        if (T) puts("");
    }
    return 0;
}
时间: 2024-10-14 10:57:31

POJ 2396 Budget (有源汇有上下界的可行流)的相关文章

poj 2396 Budget 边容量有上下界的最大流

题意: 给一个矩阵的每行和及每列和,在给一些行列或点的限制条件.求一个满足的矩阵. 分析: 转化为有上下界的网络流,注意等于也是一种上下界关系,然后用dinic算法. 代码: //poj 2396 //sep9 #include <iostream> #include <queue> #include <algorithm> using namespace std; const int maxN=210; const int maxM=40; const int max

ZOJ 3229 Shoot the Bullet(有源汇有上下界的最大流)

ZOJ 3229 Shoot the Bullet 链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3229 题意:一个屌丝给m个女神拍照,计划拍照n天,每一天屌丝最多给C个女神拍照,每天拍照数不能超过D张,而且给每个女神 i 拍照有数量限制[Li,Ri],对于每个女神n天的拍照总和不能超过Gi,如果有解求屌丝最多能拍多少张照,并求每天给对应女神拍多少张照:否则输出-1. 思路: 有源汇有上下界的最大流 1. 在原先

zoj 3229 有源汇有上下界的最大流模板题

/*坑啊,pe的程序在zoj上原来是wa. 题目大意:一个屌丝给m个女神拍照.计划拍照n天,每一天屌丝最多个C个女神拍照,每天拍照数不能超过D张,并且给每一个女神i拍照有数量限制[Li,Ri], 对于每一个女神n天的拍照总和不能超过Gi,假设有解求屌丝最多能拍多少张照,并求每天给相应女神拍多少张照:否则输出-1. 解题思路:增设一源点st,汇点sd.st到第i天连一条上界为Di下界为0的边,每一个女神到汇点连一条下界为Gi上界为oo的边,对于每一天,当天到第i个女孩连一条[Li.Ri]的边. 建

[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

Flow construction SGU - 176 有源汇有上下界最小流 二分法和回流法

/** 题目:Flow construction SGU - 176 链接:https://vjudge.net/problem/SGU-176 题意: 有源汇有上下界的最小流. 给定n个点,m个管道.每个管道给出u,v,z,c.u表示起点,v表示终点,z表示容量,如果c==1,那么表示还有下界为z. 如果c==0,表示没有下界. 求从1到n的最小流. 思路: 第一种做法: 转化为无源汇求超级源S到超级汇T的最大流flow1(此时从s出发的流和为flow1),然后讲t到s的边删掉(可以使流量等于

ZOJ3229 Shoot the Bullet(有源汇的上下界最大流)

#pragma warning(disable:4996) #include <iostream> #include <cstring> #include <string> #include <vector> #include <cstdio> #include <algorithm> #include <cmath> #include <queue> #include <map> #include

loj #117. 有源汇有上下界最小流

题目链接 有源汇有上下界最小流,->上下界网络流 注意细节,边数组也要算上后加到SS,TT边. 1 #include<cstdio> 2 #include<algorithm> 3 #include<cmath> 4 #include<cstring> 5 #include<iostream> 6 7 using namespace std; 8 9 const int N = 150010; 10 const int INF = 1e9;

有源汇带上下界最小流

LOj 模板 思路我就不多说了吧,和有源汇带上下界最大流一样,只不过这次是初流-残流网络最大流.关键这个模板题写的过程无限T一组,让我很绝望.在网上搜罗了很多代码,发现我有些地方可以优化. (1)跑dinic的时候可以使用当前弧优化 (2)在dinic过程中,如果rest已经等于0了,直接返回.不要不管他,感觉没什么影响,其实有的数据会卡死的(千万在边权更新之后再返回). #include<iostream> #include<cstdio> #include<cstring

ZOJ 2314 带上下界的可行流

对于无源汇问题,方法有两种. 1 从边的角度来处理. 新建超级源汇, 对于每一条有下界的边,x->y, 建立有向边 超级源->y ,容量为x->y下界,建立有向边 x-> 超级汇,容量为x->y下界.建立有向边 x->y,容量为x->y的上界减下界. 2 从点的角度来处理. 新建超级源汇,对于每个点流进的下界和为 in, 流出此点的下界和为out.如果in > out. 建立有向边 超级源->i,容量为in-out.反之,建立有向边 i->超级汇