2017 01 05 校内网络流小测

鉴于这几日大家都有学习网络流知识，LincHpin大爷决定考一考我们网络流，然后，我就爆零了，233……

T1 Seal

想了好久，也不知道怎么建图，然后心态就崩了，就刷BZOJ去了……

考场上写的随机化和错误贪心都被大爷卡了，T_T，Orz YYH,YZY,GZZ三位AK大佬。

首先，以一个恶魔为中心，形成一个直角的充要条件是，在左右相邻格子中选一个，在上下相邻格子中选一个。

然后发现，对于那些水晶格，同为奇数行的总是不会同时被选，同为偶数行的也不会同时被选（此指被选中流向同一个恶魔格子）。就是说，水晶格可以按照所在行（或者列，随便啦）的奇偶进行黑白染色，每个恶魔总是需要匹配一个黑水晶和一个白水晶。

所以把黑水晶放在左侧，每个和源点之间有容量为1的边；白水晶放在右侧，每个和汇点之间也有容量为1的边。中间是恶魔点，每个恶魔拆成两个点，分别和相邻的黑、白水晶相连，中间是容量为1的边。跑最大流就行了。

#include <cstdio>

inline int nextChar(void) {
    const int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return *hd++;
}
 
inline int nextInt(void) {
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

int n, m;

bool g[55][55];

inline bool next(void)
{
    char c = nextChar();
    
    while (c != '.' && c != 'X')
        c = nextChar();
        
    return c == '.';
}

const int siz = 500005;
const int inf = 1000000007;

int tot;
int s, t;
int hd[siz];
int to[siz];
int fl[siz];
int nt[siz];

inline void add(int u, int v, int f)
{
    nt[tot] = hd[u]; to[tot] = v; fl[tot] = f; hd[u] = tot++;
    nt[tot] = hd[v]; to[tot] = u; fl[tot] = 0; hd[v] = tot++;
}

int dep[siz];

inline bool bfs(void)
{
    static int que[siz], head, tail;
    
    for (int i = s; i <= t; ++i)dep[i] = 0;
    
    dep[que[head = 0] = s] = tail = 1;
    
    while (head != tail)
    {
        int u = que[head++], v;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (!dep[v = to[i]] && fl[i])
                dep[que[tail++] = v] = dep[u] + 1;
    }
    
    return dep[t];
}

int cur[siz];

inline int min(int a, int b)
{
    return a < b ? a : b;
}

int dfs(int u, int f)
{
    if (u == t || !f)
        return f;
        
    int used = 0, flow, v;
    
    for (int i = cur[u]; ~i; i = nt[i])
        if (dep[v = to[i]] == dep[u] + 1 && fl[i])
        {
            flow = dfs(v, min(fl[i], f - used));
            
            used += flow;
            fl[i] -= flow;
            fl[i^1] += flow;
            
            if (used == f)
                return f;
            
            if (fl[i])
                cur[u] = i;
        }
        
    if (!used)
        dep[u] = 0;
    
    return used;
}

inline int maxFlow(void)
{
    int maxFlow = 0, newFlow;
    
    while (bfs())
    {
        for (int i = s; i <= t; ++i)
            cur[i] = hd[i];
            
        while (newFlow = dfs(s, inf))
            maxFlow += newFlow;
    }
    
    return maxFlow;
}

inline int pos(int x, int y)
{
    return m * (x - 1) + y;
}

const int mv[4][2] = 
{
    {0, +1},
    {0, -1},
    {-1, 0},
    {+1, 0}
};

signed main(void)
{
    freopen("Seal.in", "r", stdin);
    freopen("Seal.out", "w", stdout);
    
    n = nextInt();
    m = nextInt();
    
    
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            g[i][j] = next();
            
    s = 0, t = n * m * 2 + 1;
            
    for (int i = s; i <= t; ++i)
        hd[i] = -1;
    
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            if (g[i][j])
            {
                if ((i + j) & 1)
                {
                    if (i & 1)
                        add(s, pos(i, j), 1);
                    else
                        add(pos(i, j), t, 1);
                }
                else
                {
                    for (int k = 0; k < 4; ++k)
                    {
                        int x = i + mv[k][0];
                        int y = j + mv[k][1];
                        
                        if (x < 1 || x > n)
                            continue;
                        if (y < 1 || y > m)
                            continue;
                        if (!g[x][y])
                            continue;
                            
                        if (x & 1)
                            add(pos(x, y), pos(i, j), 1);
                        else
                            add(pos(i, j) + n*m, pos(x, y), 1);
                            
                        add(pos(i, j), pos(i, j) + n*m, 1);
                    }
                }
            }
            
    printf("%d
", maxFlow());
            
    return fclose(stdin), fclose(stdout), 0;
}

T2 Repair

 依旧不会做，然后听LH大爷讲题解，讲完就怀疑自己智商了……

有点像是可行流问题（本来就是可行流好嘛），只是需要分类讨论一下。

对于一条边，如果一开始流量$F$大于$C$，即$F gt C$，那么有如下情况：

如果最后流量$X$大于$F$，即$X gt F gt C$，那么有$fare=X-F+X-C$，如果设$K=F-C$，有$fare=K+2(X-F)$.

如果最后流量$X$在$F$和$C$之间，即$F gt X gt C$，那么有$fare=F-X+X-C=K$.

如果最后流量$X$小于$C$，即$F gt C gt X$，那么有$fare=F-X=K+C-X$.

不难总结出对于这类边的建新边方式：

先将$K$直接统计到答案之中，然后从$u$向$v$连容量为$INF$的边，费用为$2$，从$v$向$u$连容量为$F-C$的边，费用为$0$，从$v$向$u$连容量为$C$的边，费用为$1$。

对于一条边，如果一开始流量$F$小于$C$，即$F lt C$，那么有如下情况：

如果最后流量$X$大于$C$，即$X gt C gt F$，那么有$fare=X-C+X-F$。

如果最后流量$X$在$C$和$F$之间，即$C gt X gt F$，那么有$fare=X-F$。

如果最后流量$X$小于$F$，即$C gt F gt X$，那么有$fare=F-X$。

不难总结出对这类边的建新边方式：

从$u$向$v$连容量为$C-F$的边，费用为$1$，从$u$向$v$连容量为$INF$的边，费用为$2$，从$v$向$u$连容量为$F$的边，费用为$1$。

最后为了满足流量守恒，设立新的源汇点，源点向流入量多的点连边，流出量多的点向汇点连边，原汇点向原源点连无穷的边，跑最小费用最大流即可。

#include <cstdio>

inline int nextChar(void) {
    const int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return *hd++;
}
 
inline int nextInt(void) {
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

const int siz = 5000005;
const int inf = 1000000007;

int n, m;
int answer;
int del[siz];

int tot;
int s, t;
int hd[siz];
int to[siz];
int fl[siz];
int vl[siz];
int nt[siz];

inline void add(int u, int v, int f, int w)
{
//    printf("add %d %d %d %d
", u, v, f, w);
    nt[tot] = hd[u]; to[tot] = v; fl[tot] = f; vl[tot] = +w; hd[u] = tot++;
    nt[tot] = hd[v]; to[tot] = u; fl[tot] = 0; vl[tot] = -w; hd[v] = tot++;
}

int dep[siz];

inline bool bfs(void)
{
    static int que[siz], head, tail;
    
    for (int i = s; i <= t; ++i)dep[i] = 0;
    
    dep[que[head = 0] = s] = tail = 1;
    
    while (head != tail)
    {
        int u = que[head++], v;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (!dep[v = to[i]] && fl[i] && !vl[i])
                dep[que[tail++] = v] = dep[u] + 1;
    }
    
    return dep[t];
}

int cur[siz];

inline int min(int a, int b)
{
    return a < b ? a : b;
}

int dfs(int u, int f)
{
    if (u == t || !f)
        return f;
        
    int used = 0, flow, v;
    
    for (int i = hd[u]; ~i; i = nt[i])
        if (dep[v = to[i]] == dep[u] + 1 && fl[i] && !vl[i])
        {
            flow = dfs(v, min(fl[i], f - used));
            
            used += flow;
            fl[i] -= flow;
            fl[i^1] += flow;
            
            if (used == f)
                return f;
                
            if (fl[i])
                cur[u] = i;
        }
        
    if (!used)
        dep[u] = 0;
    
    return used;
}

inline void maxFlow(void)
{
    while (bfs())
        while (dfs(s, inf));
}

int dis[siz];
int pre[siz];

inline bool spfa(void)
{
    static int que[siz];
    static int inq[siz];
    static int head, tail;
    
    for (int i = s; i <= t; ++i)
        inq[i] = 0, dis[i] = inf;
        
    head = 0, tail = 0;
    que[tail++] = s;
    pre[s] = -1;
    dis[s] = 0;
    
    while (head != tail)
    {
        int u = que[head++], v; inq[u] = 0;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (dis[v = to[i]] > dis[u] + vl[i] && fl[i])
            {
                dis[v] = dis[u] + vl[i], pre[v] = i ^ 1;
                if (!inq[v])
                    inq[que[tail++] = v] = 1;
            }
    }
    
    return dis[t] < inf;
}

inline void minCost(void)
{
    while (spfa())
    {
        int flow = inf;
        
        for (int i = pre[t]; ~i; i = pre[to[i]])
            if (fl[i ^ 1] < flow)flow = fl[i ^ 1];
            
        for (int i = pre[t]; ~i; i = pre[to[i]])
            fl[i] += flow, fl[i ^ 1] -= flow;
            
        answer += dis[t] * flow;
    }
}

signed main(void)
{
    freopen("Repair.in", "r", stdin);
    freopen("Repair.out", "w", stdout);
    
    n = nextInt();
    m = nextInt();
    
    s = 0, t = n + 1;
    
    for (int i = s; i <= t; ++i)
        hd[i] = -1;
    
    for (int i = 1; i <= m; ++i)
    {
        int u = nextInt();
        int v = nextInt();
        int c = nextInt();
        int f = nextInt();
        
        del[u] += f;
        del[v] -= f;
        
        if (f <= c)
        {
            add(u, v, c - f, 1);
            add(u, v, inf, 2);
            add(v, u, f, 1);
        }
        else
        {
            answer += f - c;
            add(u, v, inf, 2);
            add(v, u, f - c, 0);
            add(v, u, c, 1);
        }
    }
    
    add(n, 1, inf, 0);
    
    for (int i = 1; i <= n; ++i)
        if (del[i] < 0)
            add(s, i, -del[i], 0);
        else if (del[i] > 0)
            add(i, t, del[i], 0);
            
    maxFlow();
    
    minCost();
    
    printf("%d
", answer);
    
    return fclose(stdin), fclose(stdout), 0;
}

T3 Flow

依旧不会，看到$G(f)$函数就是mengbi的。

GZZ神犇说，MCMF中每次增广出来的路径，就是$C(f)$关于$F(f)$函数中的一段一次函数…… $OTZ GZZ$

然后，分步跑出来每一段的函数，求函数上距离(maxFlow,0)点的最近距离即可，我怎么这么蠢，23333

#include <cstdio>

template <class T>
inline T min(T a, T b)
{
    return a < b ? a : b;
}

template <class T>
T gcd(T a, T b)
{
    return b ? gcd(b, a % b) : a;
}

template <class T>
inline T sqr(T x)
{
    return x * x;
}

#define int long long

inline int nextChar(void) {
    const int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return *hd++;
}
 
inline int nextInt(void) {
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

const int siz = 500005;
const int inf = 1000000007;

int n, m;

int tot;
int s, t;
int hd[siz];
int nt[siz];
int fl[siz];
int vl[siz];
int to[siz];

inline void add(int u, int v, int f, int w)
{
    nt[tot] = hd[u]; to[tot] = v; vl[tot] = +w; fl[tot] = f; hd[u] = tot++;
    nt[tot] = hd[v]; to[tot] = u; vl[tot] = -w; fl[tot] = 0; hd[v] = tot++;
}

int dep[siz];

inline bool bfs(void)
{
    static int que[siz], head, tail;
    
    for (int i = 1; i <= n; ++i)dep[i] = 0;
    
    dep[que[head = 0] = s] = tail = 1;
    
    while (head != tail)
    {
        int u = que[head++], v;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (!dep[v = to[i]] && fl[i])
                dep[que[tail++] = v] = dep[u] + 1;
    }
    
    return dep[t];
}

int cur[siz];

int dfs(int u, int f)
{
    if (u == t || !f)
        return f;
        
    int used = 0, flow, v;
    
    for (int i = cur[u]; ~i; i = nt[i])
        if (dep[v = to[i]] == dep[u] + 1 && fl[i])
        {
            flow = dfs(v, min(fl[i], f - used));
            
            used += flow;
            fl[i] -= flow;
            fl[i^1] += flow;
            
            if (used == f)
                return f;
            
            if (fl[i])
                cur[u] = i;
        }
        
    if (!used)
        dep[u] = 0;
    
    return used;
}

inline int Dinic(void)
{
    int maxFlow = 0, newFlow;
    
    while (bfs())
    {
        for (int i = 1; i <= n; ++i)
            cur[i] = hd[i];
            
        while (newFlow = dfs(s, inf))
            maxFlow += newFlow;
    }
    
    return maxFlow;
}

int dis[siz];
int pre[siz];

inline bool spfa(void)
{
    static int que[siz];
    static int inq[siz];
    static int head, tail;
    
    for (int i = 1; i <= n; ++i)
        dis[i] = inf, inq[i] = 0;
        
    head = 0, tail = 0;
    que[tail++] = s;
    pre[s] = -1;
    dis[s] = 0;
    inq[s] = 1;
    
    while (head != tail)
    {
        int u = que[head++], v; inq[u] = 0;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (fl[i] && dis[v = to[i]] > dis[u] + vl[i])
            {
                dis[v] = dis[u] + vl[i], pre[v] = i ^ 1;
                if (!inq[v])inq[que[tail++] = v] = 1;
            }
    }
    
    return dis[t] < inf;
}

signed main(void)
{
    freopen("Flow.in", "r", stdin);
    freopen("Flow.out", "w", stdout);
    
    n = nextInt();
    m = nextInt();
    s = nextInt();
    t = nextInt();
    
    for (int i = 1; i <= n; ++i)
        hd[i] = -1;
        
    for (int i = 1; i <= m; ++i)
    {
        int x = nextInt();
        int y = nextInt();
        int u = nextInt();
        int c = nextInt();
        add(x, y, u, c);
    }
    
    int maxFlow = Dinic();
    
    for (int i = 0; i < tot; i += 2)
        fl[i] += fl[i ^ 1], fl[i ^ 1] = 0;
    
    int C = 0, F = maxFlow;
    
    while (spfa())
    {
        int w = dis[t];
        
        int flow = inf;
        
        for (int i = pre[t]; ~i; i = pre[to[i]])
            if (fl[i ^ 1] < flow)
                flow = fl[i ^ 1];
                
        if (F - w * C >= flow * (sqr(w) + 1)) 
        {
            for (int i = pre[t]; ~i; i = pre[to[i]])
                fl[i] += flow, fl[i ^ 1] -= flow;
                
            F -= flow, C += flow * dis[t];
        }
        else
        {
            if (F > w * C)
            {
                int r = sqr(w * F + C);
                int d = sqr(w) + 1;
                int g = gcd(r, d);
                printf("%lld/%lld
", r / g, d / g);
            }
            else
                printf("%lld/%lld
", sqr(C) + sqr(F), 1LL);
            
            goto end;
        }
    }
    
    printf("%lld/%lld
", sqr(C) + sqr(F), 1LL);
    
end:return fclose(stdin), fclose(stdout), 0;
}

@Author: YouSiki