[BZOJ1449][JSOI2009]球队收益（费用流）

由于打完一场比赛后胜方和负方都有收益，因此直接做不好做。
可以假设$m$场比赛双方都输，然后统计收益。假设这时候第$i$对胜$w_i$场，输$l_i$场。
然后就相当于对$m$场比赛都选择一个队作为胜方，这样就使得只有胜方有收益了。
这时候如果最后第$i$个队胜了$j$场，那么第$i$个队的实际收益将是：

$$C_i\times(w_i+j)^2+D_i\times(l_i-j)^2$$
我们知道，假设 $m$场比赛双方都输时，第$i$个队的收益是 $C_i\times w_i^2+D_i\times l_i^2$。
增量为：
$$C_i\times(w_i+j)^2+D_i\times(l_i-j)^2-C_i\times w_i^2-D_i\times l_i^2$$
$$=C_i\times(2\times w_i\times j+j^2)+D_i\times(-2\times l_i\times j+j^2)$$
$$=2\times(C_i\times w_i-D_i\times l_i)\times j+(C_i+D_i)\times j^2$$
建一个费用流的模型：
$m$个点$X_1,X_2,...,X_m$表示 $m$场比赛；
$n$个点 $Y_1,Y_2,...,Y_n$表示 $n$支球队；
源点和汇点$S,T$。
建图：
（1）由 $S$向所有的$X_i$建一条容量为 $1$，费用为$0$的边，表示一场比赛只有一个胜方；
（2）对于所有的 $1\leq i\leq m$：
<1>由 $X_i$向 $Y_{a_i}$建一条容量为 $1$，费用为$0$的边。
<2>由 $X_i$向 $Y_{b_i}$建一条容量为 $1$，费用为$0$的边。
易得，这样流入 $Y_i$的流量就是第 $i$支球队在$m$次比赛中的胜场次数。
（3）由所有的 $Y_i$向 $T$建一条边，容量为$Y_i$的入度，
费用 $cost$与这条边的流量 $x$的关系式为：
$$cost=2\times(C_i\times w_i-D_i\times l_i)\times x+(C_i+D_i)\times x^2$$
关键问题在于 $cost$是 $x$的二次函数，不能直接建边。
而对于任意正整数$x$，有：
$$1+3+5+7+...+(2x-1)=x^2$$
因此如果要建一条边，使这条边的费用等于通过这条边流量的二次方，就可以：
把容量为 $c$的边拆成$c$条容量为 $1$的边，第$i$条边的单位费用为 $2i-1$。
就可以满足条件。
（3）中也可以这样拆边，设 $Y_i$的入度为 $c$，就可以：
由$Y_i$向 $T$建$c$条边，容量为 $1$，第$j$条边的单位费用为：
$$2\times(C_i\times w_i-D_i\times l_i)+(C_i+D_i)\times(2\times j-1)$$
这样就达到了目的。
时间复杂度 $O(能过)$。
代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read()
{
    int res = 0; bool bo = 0; char c;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') bo = 1; else res = c - 48;
    while ((c = getchar()) >= '0' && c <= '9')
        res = (res << 3) + (res << 1) + (c - 48);
    return bo ? ~res + 1 : res;
}
const int N = 4e5 + 5, INF = 0x3f3f3f3f;
int n, m, win[N], lose[N], C[N], D[N], A[N], B[N], ecnt = 1, nxt[N],
adj[N], go[N], cap[N], cost[N], S, T, in[N], dis[N], len,
que[N << 2], ans;
bool vis[N], orz[N];
void add_edge(int u, int v, int w, int x)
{
    nxt[++ecnt] = adj[u]; adj[u] = ecnt; go[ecnt] = v;
    cap[ecnt] = w; cost[ecnt] = x;
    nxt[++ecnt] = adj[v]; adj[v] = ecnt; go[ecnt] = u;
    cap[ecnt] = 0; cost[ecnt] = -x;
}
bool spfa()
{
    for (int i = S; i <= T; i++) dis[i] = INF, vis[i] = orz[i] = 0;
    dis[que[len = 1] = S] = 0;
    for (int i = 1; i <= len; i++)
    {
        int u = que[i]; vis[u] = 0;
        for (int e = adj[u], v; e; e = nxt[e])
            if (cap[e] && dis[u] + cost[e] < dis[v = go[e]])
            {
                dis[v] = dis[u] + cost[e];
                if (!vis[v]) vis[que[++len] = v] = 1;
            }
    }
    return dis[T] < INF;
}
int dfs(int u, int flow)
{
    if (u == T) return ans += flow * dis[T], flow;
    orz[u] = 1;
    int res = 0, delta;
    for (int e = adj[u], v; e; e = nxt[e])
        if (cap[e] && !orz[v = go[e]] && dis[u] + cost[e] == dis[v])
        {
            delta = dfs(v, min(cap[e], flow - res));
            if (delta)
            {
                cap[e] -= delta; cap[e ^ 1] += delta;
                res += delta; if (res == flow) break;
            }
        }
    return res;
}
int mcmf()
{
    ans = 0;
    while (spfa()) dfs(S, INF);
    return ans;
}
int main()
{
    n = read(); m = read();
    for (int i = 1; i <= n; i++)
        win[i] = read(), lose[i] = read(),
        C[i] = read(), D[i] = read();
    for (int i = 1; i <= m; i++)
        lose[A[i] = read()]++,
        lose[B[i] = read()]++;
    S = 1; T = n + m + 2;
    for (int i = 2; i <= m + 1; i++)
        add_edge(S, i, 1, 0);
    for (int i = 1; i <= m; i++)
        add_edge(i + 1, A[i] + m + 1, 1, 0),
        add_edge(i + 1, B[i] + m + 1, 1, 0),
        in[A[i]]++, in[B[i]]++;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= in[i]; j++)
            add_edge(i + m + 1, T, 1,
            (C[i] * win[i] - D[i] * lose[i] << 1) +
            (C[i] + D[i]) * ((j << 1) - 1));
    int sum = 0;
    for (int i = 1; i <= n; i++)
        sum += C[i] * win[i] * win[i] + D[i] * lose[i] * lose[i];
    cout << sum + mcmf() << endl;
    return 0;
}