51Node 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

//正规解法
#include <bits/stdc++.h>
#define FIN freopen("input.txt","r",stdin);
#define FOUT freopen("output.txt","w+",stdout);
using namespace std;
typedef long long ll;

const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps=1e-8;
const double Pi=acos(-1.0);
const int N = 400010;

int Map[1005][1005];//邻接矩阵，保存有连边的点对
struct Node
{
    int x,y,id;
}node[N];
struct edge
{
    int to,cap,rev;//终点，容量，反向边
};
vector<edge>G[N];//图的邻接矩阵表示
bool used[N];//dfs中用到的访问标记
int level[N];//顶点到源点的距离标号
int iter[N];//当前弧，在其之前的边已经没用了
bool cmp(Node a,Node b)
{
    if(a.x==b.x)
        return a.y>b.y;
    else
        return a.x<b.x;
}
//向图中增加一条从s到t容量为cap的边
void addedge(int u,int v,int w)
{
    G[u].push_back((edge){v,w,G[v].size()});
    G[v].push_back((edge){u,w,G[u].size()-1});//如果是无向图，只要把0改成w即可
}
//通过bfs计算从源点出发的距离标号
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int> que;
    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int v=que.front();
        que.pop();
        for(int i=0;i<G[v].size();i++)
        {
            edge &e=G[v][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
//通过dfs寻找增广路径
int dfs(int v,int t,int f)
{
    if(v==t)
        return f;
    for(int &i=iter[v];i<G[v].size();i++)
    {
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<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 max_flow(int s,int t)
{
    int flow=0;
    for(;;)
    {
        bfs(s);
        if(level[t]<0)
            return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0)
            flow+=f;
    }
}
void Init()
{
    memset(Map,0,sizeof(Map));
    for(int i=0;i<N;i++)
        G[i].clear();
}
int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        Init();
        int S=0,T=n+1;
        int u,v;
        for(int i=0; i<m; i++)
        {
            scanf("%d %d",&u,&v);
            Map[u][v]=1;
            Map[v][u]=1;
        }
        int sum=0;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                sum+=abs(i-j);//求出所有点对的价值
        //printf("sum:%d\n",sum);
        for(int i=1; i<=n; i++)
        {
            for(int j=i+1; j<=n; j++)
            {
                addedge(i,j,abs(i-j));//任意点对间连一条容量为|u-v|的边
                if(Map[i][j]==1)//对于每条边(u,v)，连一条 u -> T 容量为|u-v|的边， 连一条 v -> T 容量为|u-v|的边。
                {
                    //printf("<--%d %d-->\n",i,j);
                    addedge(i,T,abs(i-j));
                    addedge(j,T,abs(i-j));
                }
                else//对于每个点对没有边(u,v)， 连一条 S -> u  容量为|u-v|的边， 连一条 S -> v 容量为|u-v|的边。
                {
                    //printf("!--%d %d--!\n",i,j);
                    addedge(S,i,abs(i-j));
                    addedge(S,j,abs(i-j));
                }
            }
        }
        int mincut=max_flow(S,T);//求最小割
        //printf("mincut:%d\n",mincut);
        printf("%d\n",(sum-mincut)/2);//最终结果
    }
}