luogu3731 新型城市化

题目链接

思路

这道题对于题意的转化很关键。
题目要求的是添上一条边,使得图中最大团的大小变大。给出的边是原图的补集,这就给我们了提示。
因为题目中说,原图中最多有两个团。所以给出的边一定形成了一个二分图。
那么最大团就是新图中的最大独立集。
那么问题就转化成了,在新图中删除一条边,使得新图中的最大独立集变大。
因为最大独立集 = 点数-最大匹配。
所以我们要让最大匹配变小。
考虑删除哪些边会让最大匹配变小。首先肯定要在跑完网络流之后是满流的。然后不能由其他的边来代替。也就是说在残余网络上跑一遍\(tarjan\),满足两段不在同一个强联通分量中的边。
所以做法也就出来了。先建图跑一遍网络流,然后在残余网络上\(tarjan\)一遍。再遍历所有边,找出那些不在两段不在同一个强连通分量中,并且满流的边。

代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<bitset>
using namespace std;
typedef long long ll;
#define change(x) x & 1 ? x + 1 : x - 1
const int M = 600010,N = 10010,INF = 1e9 + 7;
ll read() {
    ll x=0,f=1;char c=getchar();
    while(c<'0'||c>'9') {
        if(c=='-') f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9') {
        x=x*10+c-'0';
        c=getchar();
    }
    return x*f;
}
struct node {
    int u,v,nxt,w;
}e[M << 1],E[M << 1],ans[M << 1];
int anss;
int head[N],ejs;
void add(int u,int v,int w) {
    e[++ejs].u = u;e[ejs].v = v;e[ejs].w = w;e[ejs].nxt = head[u];head[u] = ejs;
    e[++ejs].u = v;e[ejs].v = u;e[ejs].w = 0;e[ejs].nxt = head[v];head[v] = ejs;
}
void ADD(int u,int v) {
    E[++ejs].u = u;E[ejs].v = v;E[ejs].nxt = head[u];head[u] = ejs;
    E[++ejs].v = u;E[ejs].u = v;E[ejs].nxt = head[v];head[v] = ejs;
}
int n,m,S,T;
int lb[N];
void con(int u) {
    for(int i = head[u];i;i = E[i].nxt) {
        int v = E[i].v;
        if(lb[v]) continue;
        lb[v] = 3 - lb[u];
        con(v);
    }
}
int dep[N],dfn[N],inque[N],sta[N],top,low[N],cnt,col[N],coljs;
void tarjan(int u) {
    dfn[u] = low[u] = ++cnt;
    sta[++top] = u;inque[u] = 1;
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(e[i].w <= 0) continue;
        if(!dfn[v]) tarjan(v),low[u] = min(low[u],low[v]);
        else if(inque[v]) low[u] = min(low[u],low[v]);
    }
    if(low[u] == dfn[u]) {
        ++coljs;
        while(sta[top + 1] != u) {
            inque[sta[top]] = 0;
            col[sta[top--]] = coljs;
        }
    }
}
queue<int>q;
int bfs() {
    memset(dep,0,sizeof(dep));
    while(!q.empty()) q.pop();
    q.push(S);dep[S] = 1;

    while(!q.empty()) {
        int u = q.front();q.pop();
        for(int i = head[u];i;i = e[i].nxt) {
            int v = e[i].v;
            if(dep[v] || e[i].w <= 0) continue;
            dep[v] = dep[u] + 1;
            if(v == T) return 1;
            q.push(v);
        }
    }
    return 0;
}
int dfs(int u,int now) {
    if(u == T) return now;
    int re = 0;
    for(int i = head[u];i;i = e[i].nxt) {
        int v = e[i].v;
        if(e[i].w <= 0 || dep[v] != dep[u] + 1) continue;
        int k = dfs(v,min(now,e[i].w));
        if(k) {
            e[i].w -= k;
            e[change(i)].w += k;
            now -= k;
            re += k;
            if(!now) break;
            // return k;
        }
    }
    return re;
}
void dinic() {
    while(bfs()) {
        int k = dfs(S,INF);
        while(k) {
            k = dfs(S,INF);
        }
    }
}
bool tmp(node X,node Y) {
    int k1 = min(X.u,X.v),t1 = max(X.u,X.v),k2 = min(Y.u,Y.v),t2 = max(Y.u,Y.v);
    return k1 == k2 ? t1 < t2 : k1 < k2;
}
int main() {
    n = read(),m = read();
    for(int i = 1;i <= m;++i) {
        int u = read(),v = read();
        ADD(u,v);
    }
    for(int i = 1;i <= n;++i)
        if(!lb[i]) lb[i] = 1,con(i);
    memset(head,0,sizeof(head));
    ejs = 0;
    S = n + 1,T = S + 1;
    for(int i = 1;i <= n;++i) {
        if(lb[i] == 1) add(S,i,1);
        else add(i,T,1);
    }
    for(int i = 1;i <= m * 2;i += 2) {
        if(lb[E[i].u] == 1) add(E[i].u,E[i].v,1);
        else add(E[i].v,E[i].u,1);
    }
    dinic();
    for(int i = 1;i <= n;++i) if(!dfn[i]) tarjan(i);
    for(int i = 1;i <= ejs;i += 2) {
        int u = e[i].u,v = e[i].v;
        if(col[u] != col[v] && e[i].w == 0 && e[i].u <= n &&e[i].v <= n) {
            ans[++anss] = e[i];
        }
    }
    printf("%d\n",anss);
    sort(ans + 1,ans + anss + 1,tmp);
    for(int i = 1;i <= anss;++i) {
        printf("%d %d\n",min(ans[i].u,ans[i].v),max(ans[i].u,ans[i].v));
    }
    return 0;
}

原文地址:https://www.cnblogs.com/wxyww/p/10354848.html

时间: 2024-10-14 00:10:14

luogu3731 新型城市化的相关文章

[HAOI2017]新型城市化

题目描述 Anihc国有n座城市.城市之间存在若一些贸易合作关系.如果城市x与城市y之间存在贸易协定.那么城市文和城市y则是一对贸易伙伴(注意:(x,y)和(y,x))是同一对城市). 为了实现新型城市化.实现统筹城乡一体化以及发挥城市群辐射与带动作用.国 决定规划新型城市关系.一些城市能够被称为城市群的条件是:这些城市两两都是贸易伙伴. 由于Anihc国之前也一直很重视城市关系建设.所以可以保证在目前已存在的贸易合作关系的情况下Anihc的n座城市可以恰好被划分为不超过两个城市群. 为了建设新

Luogu3731 HAOI2017新型城市化(二分图匹配+强连通分量)

将未建立贸易关系看成连一条边,那么这显然是个二分图.最大城市群即最大独立集,也即n-最大匹配.现在要求的就是删哪些边会使最大匹配减少,也即求哪些边一定在最大匹配中. 首先范围有点大,当然是跑个dinic,转化成最大流.会使最大流减少的边相当于可能在最小割中的边,因为删掉它就相当于无代价的割掉了一条边.那么用曾经看到过的结论就可以了:当且仅当该边满流且残余网络(包括反向边)中该边两端点处于不同SCC时,该边可能在最小割中.不太会证.于是tarjan一发就可以了.注意不要把开始给的图和网络流建图搞混

洛谷 P3731 [HAOI2017]新型城市化【最大流(二分图匹配)+tarjan】

我到底怎么建的图为啥要开这么大的数组啊?! 神题神题,本来以为图论出不出什么花来了. 首先要理解'团'的概念,简单来说就是无向图的一个完全子图,相关概念详见度娘. 所以关于团一般都是NP问题,只有二分图例外.而题目中有这样一句话"n座城市可以恰好被划分为不超过两个城市群",并且给出的是没有的边,也就是这个图的补图,两个团就很显然表示这个补图是个二分图(我一开始还考虑1个团咋整后来发现根本不用整= =),模型就变成了二分图的最大独立集,考虑最大独立集=n-最大匹配,那么只要求出删掉哪些边

[HAOI2017] 新型城市化 - 强联通分量,最大流,二分图染色

给定一个可以划分为不超过两个团的稠密图,以补图的形式描述.求有多少对点满足在它们之间建边后最大团的大小会增加.\(n \leq 10^4, m \leq 1.5\times 10^5\) Solution 原图的最大团就是补图的最大独立集,由题意补图是二分图,于是转化为求删去哪些边可以使得二分图的最大独立集减少 考虑到最大独立集数=最大匹配数,于是转化为求哪些边一定在最大匹配里 定理 二分图的某条边一定在最大匹配中当且仅当这条边满流,且残量网络中这条边的两个顶点不在同一个 SCC 中 于是我们跑

公交wifi运营平台分析

一.前言背景 昨晚下午,老板让看一些车载公交wifi后台管理的一些东西,这个随着移动端设备而兴起的wifi战,慢慢的也会越演越烈. 现在于很多人在外面的时候,进入一家店首先看的不是菜单,而是问一句“你们的wifi密码是多少”?没有贴着“免费wifi”标签的店,估计都不会有人进去用餐,咖啡店,甜品店,餐厅,美发店……到处都可以看到免费wifi的字样,wifi已经成为标配了.随着移动端的兴起,微信营销的推广,对WiFi的需求也越来越多,这个可以说是生有体会,武汉某商圈的兴起就和wifi,微信脱不了关

草根智库最新热点 - 土地流转:美元资本将敲响中国社会崩溃的丧钟 - QQ邮箱

body { font-family: 微软雅黑; font-size: 10.5pt; line-height: 1.5; } html, body { color: ; background-color: ; } h1 { font-size:1.5em; font-weight:bold; } h2 { font-size:1.4em; font-weight:bold; } h3 { font-size:1.3em; font-weight:bold; } h4 { font-size:

Python程序猿必知的新型字符串格式漏洞

本文对Python开发中引入的一种格式化字符串的新型语法的安全漏洞进行了深入的分析,并提供了相应的安全解决方案. 当我们对不可信的用户输入使用str.format的时候,将会带来安全隐患--对于这个问题,其实我早就知道了,但是直到今天我才真正意识到它的严重性.因为攻击者可以利用它来绕过Jinja2沙盒,这会造成严重的信息泄露问题.同时,我在本文最后部分为str.format提供了一个新的安全版本. 需要提醒的是,这是一个相当严重的安全隐患,这里之所以撰文介绍,是因为大多数人很可能不知道它是多么容

ArcGIS for Server 10.3.X 新型紧凑型缓存的解读和应用

早在2010年年底,牛魔王中王在其博客空间牛魔王的作坊中对ArcGIS 10中推出的紧凑型缓存格式进行了详细的解读,详见<ArcGIS 切片缓存紧凑文件格式分析与使用>.紧随着的4年时间里,ArcGIS for Server本身经历了10.10.1.X和10.2.X各版本的逐级更替,特别是软件架构发生了显著的变化.然而,就紧凑型缓存本身而言,牛魔王中王的解读一直都是适用的.衷心地向我们的大牛致敬! 直到2014年年底ArcGIS 10.3正式发布,Esri才推出了新的紧凑型缓存格式以增强用户的

3、Spring新型方式实现定时调度

1.实现和循环调度类似 public class QuartzJob3{ public void test(){ SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss"); System.out.println("Spring新型方法-使用定时触发器-被调用"+sdf.format(new Date())); } } 2.Spring配置如下 (1)注入调度类对象(注入2个类对象,用不同方式触发) <!-- 注