[JSOI2009]球队收益 / 球队预算【费用流】

题目链接

---

  先说一下我一开始错了有一段时间的做法为什么是错的：

错误做法：

  我们可以看到每个点i基础有胜利次，有失败次，可以发现一点，无论是胜利次数增多还是失败次数增多，总的花费一定是增多的，若初始为，则胜利一次会变成，而失败一次呢，则会变成，所以他们一定是增加的。于是，我们可以说费用流的根据贪心选最短路的策略，那么一定是会先去选择最小的边。

  所以，将每个点拆成胜点、负点，一次u、v打比赛，则一定有一方胜，有一方败，所以不妨胜连败，败连胜，然后又只有一场比赛，所以对其限流就可以了。

  但是这样的做法，是有本质上的错误的（虽然看着很对，而且还讨论半天），因为关于胜负的两个函数，他们是通过和两个集体限制的，所以他们是各自单调，但是合成并不绝对单调，所以这样的贪心策略存在问题。

正确做法：

  于是，如果可以限制其中一个，或者将这个式子改成绝对单调，我们就依然可以解决这个问题，于是，题目中给出，如果失败，就有一定是开销少的那个，所以不妨假设一开始所有的比赛，u、v均失败了，好了，这时候我们要从u、v中选择一个为胜利者，这时候计算这个贡献。

  因为一开始都失败了，所以要更新，那么对于初始的贡献就是，现在有一个队伍胜场更多了，败场更少了，于是现在的贡献就是，这时候新多出来的贡献就是，众所周知，单调递增，单调递减，所以该式子单调递增（至少也是单调不减）。

  于是，根据这样的性质，我们可以建对应的图直接跑费用流了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define pii pair<int, int>
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 6e3 + 7, maxM = 1e4 + 7;
int N, M;
namespace Graph
{
    int head[maxN], cnt;
    struct Eddge
    {
        int nex, u, v; ll flow, cost;
        Eddge(int a=-1, int b=0, int c=0, ll d=0, ll f=0):nex(a), u(b), v(c), flow(d), cost(f) {}
    } edge[maxM];
    inline void addEddge(int u, int v, int f, int w)
    {
        edge[cnt] = Eddge(head[u], u, v, f, w);
        head[u] = cnt++;
    }
    inline void _add(int u, int v, int f, int w) { addEddge(u, v, f, w); addEddge(v, u, 0, -w); }
    inline void init() { cnt = 0; }
};
using namespace Graph;
struct MaxFlow_MinCost
{
    int pre[maxN], S, T, node; ll Flow[maxN], dist[maxN];
    inline int New_node() { node++; head[node] = -1; return node; }
    queue<int> Q;
    bool inque[maxN];
    inline bool spfa()
    {
        for(int i=0; i<=node; i++) { pre[i] = -1; dist[i] = INF; inque[i] = false; }
        while(!Q.empty()) Q.pop();
        Q.push(S); dist[S] = 0; inque[S] = true; Flow[S] = INF;
        while(!Q.empty())
        {
            int u = Q.front(); Q.pop(); inque[u] = false;
            ll f, w;
            for(int i=head[u], v; ~i; i=edge[i].nex)
            {
                v = edge[i].v; f = edge[i].flow; w = edge[i].cost;
                if(f && dist[v] > dist[u] + w)
                {
                    dist[v] = dist[u] + w;
                    Flow[v] = min(Flow[u], f);
                    pre[v] = i;
                    if(!inque[v])
                    {
                        inque[v] = true;
                        Q.push(v);
                    }
                }
            }
        }
        return ~pre[T];
    }
    inline ll EK()
    {
        ll sum_Cost = 0;
        while(spfa())
        {
            int now = T, las = pre[now];
            while(now ^ S)
            {
                edge[las].flow -= Flow[T];
                edge[las ^ 1].flow += Flow[T];
                now = edge[las].u;
                las = pre[now];
            }
            sum_Cost += dist[T] * Flow[T];
        }
        return sum_Cost;
    }
} MF;
const int maxP = 5e3 + 7;
int a[maxP], b[maxP], C[maxP], D[maxP];
pii game[1005];
int fight[maxP] = {0}, ss[maxP] = {0}, tt[maxP] = {0}, sp[maxP] = {0};
int main()
{
    scanf("%d%d", &N, &M);
    ll ans = 0, tmp;
    for(int i=1; i<=N; i++) scanf("%d%d%d%d", &a[i], &b[i], &C[i], &D[i]);
    for(int i=1; i<=M; i++)
    {
        scanf("%d%d", &game[i].first, &game[i].second);
        fight[game[i].first]++;
        fight[game[i].second]++;
        b[game[i].first]++;
        b[game[i].second]++;
    }
    for(int i=1; i<=N; i++) ans += C[i] * a[i] * a[i] + D[i] * b[i] * b[i];
    MF.S = 0;
    MF.T = N + 1;
    MF.node = N + 1;
    for(int i=0; i<=MF.node; i++) head[i] = -1;
    for(int i=1; i<=N; i++)
    {
        if(!fight[i]) continue;
        for(int j=1; j<=fight[i]; j++)
        {
            _add(i, MF.T, 1, C[i] * (2 * a[i] + 1) + D[i] * (1 - 2 * b[i]));
            a[i]++;
            b[i]--;
        }
    }
    for(int i=1, u, v; i<=M; i++)
    {
        u = game[i].first; v = game[i].second;
        MF.New_node();
        _add(MF.S, MF.node, 1, 0);
        _add(MF.node, u, 1, 0);
        _add(MF.node, v, 1, 0);
    }
    tmp = MF.EK();
    ans += tmp;
    printf("%lld\n", ans);
    return 0;
}