51Nod 1499 图（最小割+边在割的一边有收益建图）

1499 图
基准时间限制：2 秒 空间限制：262144 KB 分值: 80 难度：5级算法题
给一个无向图，你要将这些点分成A、B两个集合，使得满足A的导出子图是一个完全图，而B的导出子图是一个没有边的图。
但是事实上你不一定能够做到，所以你允许有错误。我们定义一个完美值为：
1.如果A中两点有边相连，则增加|i-j|的完美值。
2.如果B中两点无边相连，则增加|i-j|的完美值。
（i,j是这两个点的编号）
那么，我们让完美值最大就可以了。
N <= 1000, M <= 200000
Input
N, M 表示点数和边数
M行，
u,v表示一条无向边。
（不会有重边和自环）
Output
一个数，表示最大的完美值。
Input示例
5 5
1 2
1 3
1 4
1 5
2 3
Output示例
11
DFFXTZ (题目提供者)

解题思路

　　和HihoCoder 1252比较像，只不过那题是考虑点，这题是考虑边。
　　考虑一对点u, v，如果它们的关系有三种情况，都在A集合，都在B集合，一个在A一个在B。那么我们就可以考虑利用最小割从这三者中进行决策。由于要求最大收益，所以我们考虑无法得到的分数，让这个分数最小。设源点为s，汇点为t，连接s->u和s->v，容量为如果这条边在A集合的收益，连接u->v，容量为$|u-v|$，连接u->t和v->t，容量为这条边在B集合的收益。对于v,u同理。再对起点终点相同的边合并一下就是最终的建图。这样我们用最小割得到的就是考虑每条边三种情况的最小花费，答案就是总收益减去最小花费。由于每队点我们都两个方向考虑了两次，所以答案最后要处以 2 <script type="math/tex" id="MathJax-Element-2">2</script>。

AC代码

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
#define INF 0x3f3f3f3f
#define LL long long
#define mem(a,b) memset((a),(b),sizeof(a))

const int MAXV=1000+3;

struct Edge
{
    int to, cap, rev;
    Edge(int t, int c, int r):to(t), cap(c), rev(r){}
};

int V, E;
vector<Edge> G[MAXV];//图的邻接表表示
int level[MAXV];//顶点到原点的距离标号
int iter[MAXV];//当前弧，在其之前的边已经没有用了

//有向图中增加一条从from到to的容量为cap的边
void add_edge1(int from, int to, int cap)
{
    G[from].push_back(Edge(to, cap, G[to].size()));
    G[to].push_back(Edge(from, 0, G[from].size()-1));
}

void add_edge2(int from, int to, int cap)
{
    G[from].push_back(Edge(to, cap, G[to].size()));
    G[to].push_back(Edge(from, cap, G[from].size()-1));
}

//通过bfs计算从源点出发的距离标号
void bfs(int s)
{
    for(int i=0;i<V;++i)
        level[i]=-1;
    queue<int> que;
    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=0;i<G[u].size();++i)
        {
            Edge &e=G[u][i];
            if(e.cap>0 && level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                que.push(e.to);
            }
        }
    }
}

//通过dfs寻找增广路
int dfs(int u, int t, int f)
{
    if(u==t)
        return f;
    for(int &i=iter[u];i<G[u].size();++i)
    {
        Edge &e=G[u][i];
        if(e.cap>0 && level[u]<level[e.to])
        {
            int d=dfs(e.to, t, min(f, e.cap));
            if(d>0)
            {
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

//求解从s到t的最大流
int dinic(int s, int t)
{
    int flow=0;
    while(true)
    {
        bfs(s);
        if(level[t]<0)
            return flow;
        for(int i=0;i<V;++i)
            iter[i]=0;
        int f;
        while((f=dfs(s, t, INF))>0)
            flow+=f;
    }
}

bool maze[MAXV][MAXV];
int tot[2][MAXV];

int main()
{
    scanf("%d%d", &V, &E);
    for(int i=0;i<E;++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        --u;
        --v;
        maze[u][v]=maze[v][u]=true;
    }
    int sum=0;
    for(int i=0;i<V;++i)
        for(int j=i+1;j<V;++j)
        {
            add_edge1(i, j, (j-i));
            tot[maze[i][j]][i]+=j-i;
            tot[maze[i][j]][j]+=j-i;
            sum+=(j-i)<<1;
        }
    int s=V, t=V+1;
    for(int i=0;i<V;++i)
    {
        add_edge1(s, i, tot[0][i]);
        add_edge1(i, t, tot[1][i]);
    }
    V+=2;
    printf("%d\n", (sum-dinic(s, t))>>1);

    return 0;
}