BZOJ 1449 JSOI2009 球队收益 费用流

题目大意：给定$n$支球队，第$i$支球队已经赢了$win_i$场，输了$lose_i$场，接下来还有$m$场比赛，每个球队最终的收益为$C_i*x_i^2+D_i*y_i^2$，其中$x_i$为最终的胜场，$y_i$为最终的负场
求最小化收益

考虑一只球队，其收益与在接下来的比赛中的胜场数关系为：
赢$0$场 $C_i*win_i^2+D_i*(d_i+lose_i)^2$
赢$1$场 $C_i*(win_i+1)^2+D_i*(d_i+lose_i-1)^2$
赢$2$场 $C_i*(win_i+2)^2+D_i*(d_i+lose_i-2)^2$
…
赢$d_i$场 $C_i*(win_i+d_i)^2+D_i*lose_i^2$

差分后可得：
赢第$1$场 $C_i*(2*win_i+1)-D_i*[2*(d_i+lose_i)-1]$
赢第$2$场 $C_i*(2*win_i+3)-D_i*[2*(d_i+lose_i)-3]$
…
赢第$d_i$场 $C_i*[2*win_i+(2*d_i-1)]-D_i*[2*(d_i+lose_i)-(2*d_i-1)]$

容易发现差分后单调递增，故收益是关于胜场数的一个下凸函数，可以拆边做

于是我们将每支球队和每场比赛都变成一个点，建图跑费用流

源点向第$i$个点连$d_i$条边，流量为$1$，第$j$条边的费用为$C_i*[2*win_i+(2*j-1)]-D_i*[2*(d_i+lose_i)-(2*j-1)]$
每场比赛的双方向这场比赛连一条流量为$1$费用为$0$的边
每场比赛向汇点连一条流量为$1$费用为$0$的边

最小费用+$\sum_{i=1}^n[C_i*win_i^2+D_i*(d_i+lose_i)^2]$就是答案

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 6060
#define S 0
#define T (M-1)
#define INF 0x3f3f3f3f
using namespace std;
int n,m,ans;
int win[M],lose[M],C[M],D[M],d[M];
namespace Min_Cost_Max_Flow{
    struct abcd{
        int to,flow,cost,next;
    }table[1001001];
    int head[M],tot=1;
    void Add(int x,int y,int f,int c)
    {
        table[++tot].to=y;
        table[tot].flow=f;
        table[tot].cost=c;
        table[tot].next=head[x];
        head[x]=tot;
    }
    void Link(int x,int y,int f,int c)
    {
        Add(x,y,f,c);
        Add(y,x,0,-c);
    }
    bool Edmonds_Karp()
    {
        static int q[65540],cost[M],flow[M],from[M];
        static unsigned short r,h;
        static bool v[M];
        int i;
        memset(cost,0x3f,sizeof cost);
        cost[S]=0;flow[S]=INF;q[++r]=S;
        while(r!=h)
        {
            int x=q[++h];v[x]=false;
            for(i=head[x];i;i=table[i].next)
                if(table[i].flow&&cost[table[i].to]>cost[x]+table[i].cost)
                {
                    cost[table[i].to]=cost[x]+table[i].cost;
                    flow[table[i].to]=min(flow[x],table[i].flow);
                    from[table[i].to]=i;
                    if(!v[table[i].to])
                        v[table[i].to]=true,q[++r]=table[i].to;
                }
        }
        if(cost[T]==0x3f3f3f3f) return false;
        ans+=cost[T]*flow[T];
        for(i=from[T];i;i=from[table[i^1].to])
            table[i].flow-=flow[T],table[i^1].flow+=flow[T];
        return true;
    }
}
int main()
{
    using namespace Min_Cost_Max_Flow;
    int i,j,x,y;
    cin>>n>>m;
    for(i=1;i<=n;i++)
        scanf("%d%d%d%d",&win[i],&lose[i],&C[i],&D[i]);
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        Link(x,n+i,1,0);
        Link(y,n+i,1,0);
        Link(n+i,T,1,0);
        d[x]++;d[y]++;
    }
    for(i=1;i<=n;i++)
    {
        ans+=C[i]*win[i]*win[i]+D[i]*(d[i]+lose[i])*(d[i]+lose[i]);
        for(j=1;j<=d[i];j++)
            Link(S,i,1, C[i]*(2*win[i]+j*2-1)-D[i]*(2*(d[i]+lose[i])-j*2+1) );
    }
    while( Edmonds_Karp() );
    cout<<ans<<endl;
    return 0;
}