最小点权覆盖集

二分图最小点权覆盖集解决的是这样一个问题:
在二分图中,对于每条边,两个端点至少选一个,求所选取的点最小权值和。
方法:
1、先对图二分染色,对于每条边两端点的颜色不同
2、然后建立源点S,向其中一种颜色的点连一条容量为该点权值的边
3、建立汇点T,由另一种颜色的点向T连一条容量为该点权值的边
4、对于二分图中原有的边,改为由与S相连的点连向与T相连的点的一条容量为INF的边
跑一遍最大流,其结果就是最小点权和。
原理:
实际为最小割。建好图后,对整张图求最小割,那么不可能割INF的边,所以每对点中连向源汇点边权最小的边被割断,整体来看,就是对于任意一对端点,都选了一个较小权值,得到我们要的结果。

最大点权独立集

与最小点权覆盖集相似:
在二分图中,对于每条边,两个端点至多选一条边,求所选取的点的最大权值和。
方法:
先求一次最小点权覆盖集,再用总权值减去它,就得到了最大点权独立集。
原理:
在最小点权独立集中,是每对点至少选择了一个的最小方案,反过来,就是每对点至多选择了一个的最大方案。

洛谷P2274 方格取数问题

方格取数问题就是很经典的最大点权独立集问题:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define LL long long int
using namespace std;
const int maxn=100005,maxm=10000005,INF=2000000000; inline int read(){
int out=0,flag=1;char c=getchar();
while(c<48||c>57) {if(c=='-') flag=-1;c=getchar();}
while(c>=48&&c<=57) {out=out*10+c-48;c=getchar();}
return out*flag;
} int head[maxn],nedge=0;
struct EDGE{
int to,f,next;
}edge[maxm]; inline void build(int a,int b,int w){
edge[nedge]=(EDGE){b,w,head[a]};
head[a]=nedge++;
edge[nedge]=(EDGE){a,0,head[b]};
head[b]=nedge++;
} int color[105][105],N,M,S,T,X[4]={0,0,-1,1},Y[4]={1,-1,0,0}; bool vis[maxn];
int d[maxn],cur[maxn]; bool bfs(){
fill(vis,vis+maxn,false);
queue<int> q;
q.push(S);
vis[S]=true;
d[S]=0;
int u,to;
while(!q.empty()){
u=q.front();
q.pop();
for(int k=head[u];k!=-1;k=edge[k].next)
if(!vis[to=edge[k].to]&&edge[k].f){
d[to]=d[u]+1;
vis[to]=true;
q.push(to);
}
}
return vis[T];
} int dfs(int u,int minf){
if(u==T||!minf) return minf;
int flow=0,f,to;
if(cur[u]==-2) cur[u]=head[u];
for(int& k=cur[u];k!=-1;k=edge[k].next)
if(d[to=edge[k].to]==d[u]+1&&(f=dfs(to,min(edge[k].f,minf)))){
edge[k].f-=f;
edge[k^1].f+=f;
flow+=f;
minf-=f;
if(!minf) break;
}
return flow;
} int maxflow(){
int flow=0;
while(bfs()){
fill(cur,cur+maxn,-2);
flow+=dfs(S,INF);
}
return flow;
} int main()
{
fill(head,head+maxn,-1);
N=read();
M=read();
S=0;
T=N*M+1;
color[0][0]=1;
int x;
LL tot=0;
for(int i=1;i<=N;i++)
for(int j=1;j<=M;j++){
if((i%2&&j%2)||(i%2==0&&j%2==0)) color[i][j]=1;
else color[i][j]=0;
}
for(int i=1;i<=N;i++)
for(int j=1;j<=M;j++){
x=read();
tot+=x;
if(color[i][j]) build(M*(i-1)+j,T,x);
else{
build(S,M*(i-1)+j,x);
for(int k=0;k<4;k++){
int nx=i+X[k],ny=j+Y[k];
if(nx>0&&ny>0&&nx<=N&&ny<=M) build(M*(i-1)+j,M*(nx-1)+ny,INF);
}
}
}
cout<<tot-maxflow()<<endl;
return 0;
}

最小点权覆盖集&最大点权独立集的更多相关文章

  1. HDU 1569 - 方格取数(2) - [最大点权独立集与最小点权覆盖集]

    嗯,这是关于最大点权独立集与最小点权覆盖集的姿势,很简单对吧,然后开始看题. 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1569 Time Limi ...

  2. hdu1569 方格取数(2) 最大点权独立集=总权和-最小点权覆盖集 (最小点权覆盖集=最小割=最大流)

    /** 转自:http://blog.csdn.net/u011498819/article/details/20772147 题目:hdu1569 方格取数(2) 链接:https://vjudge ...

  3. POJ2125 Destroying The Graph(二分图最小点权覆盖集)

    最小点权覆盖就是,对于有点权的有向图,选出权值和最少的点的集合覆盖所有的边. 解二分图最小点权覆盖集可以用最小割: vs-X-Y-vt这样连边,vs和X部点的连边容量为X部点的权值,Y部和vt连边容量 ...

  4. POJ2125 Destroying The Graph (最小点权覆盖集)(网络流最小割)

                                                          Destroying The Graph Time Limit: 2000MS   Memo ...

  5. POJ 2125 Destroying The Graph (二分图最小点权覆盖集+输出最小割方案)

    题意 有一个图, 两种操作,一种是删除某点的所有出边,一种是删除某点的所有入边,各个点的不同操作分别有一个花费,现在我们想把这个图的边都删除掉,需要的最小花费是多少. 思路 很明显的二分图最小点权覆盖 ...

  6. POJ 2125 最小点权覆盖集(输出方案)

    题意:给一个图(有自回路,重边),要去掉所有边,规则:对某个点,可以有2种操作:去掉进入该点 的所有边,也可以去掉出该点所有边,(第一种代价为w+,第二种代价为w-).求最小代价去除所有边. 己思:点 ...

  7. HDU 1565 - 方格取数(1) - [状压DP][网络流 - 最大点权独立集和最小点权覆盖集]

    题目链接:https://cn.vjudge.net/problem/HDU-1565 Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32 ...

  8. poj2125 最小点权覆盖集

    题意:有一张图,对于每个点,有出边和入边,现在目的是删除改图的所有边,对于每个点,删除出边的花费Wi-,删除入边的花费Wi+,现在的目的求删去所有边后的花费最小. 建图方法:对于每个点i,拆点为i,i ...

  9. HDU1569+最大点权集

    /* 最大点权独立集=总权值-最小点权覆盖集 最大点权独立集=最大流 最小点权覆盖集=最小割 题意: 给你一个m*n的格子的棋盘,每个格子里面有一个非负数. 从中取出若干个数,使得任意的两个数所在的格 ...

随机推荐

  1. 学习HTML 第五节.简单交互 加个按钮

    学习HTML 第五节.简单交互 也许你和我一样,对页面排版的兴趣小于网页交互,那么我们就先略过一些章节,直接先学一下简单交互. 前面点击图片打开链接的网址,已经是最简单的交互方式了,复杂的方式则需要用 ...

  2. JAVA基础学习之路(十二)链表

    定义链表的基本结构: class Link {//外部类 //内部类,只为链表类服务 private class Node {//定义节点类 private String data;//保存的数据 p ...

  3. Node开发项目管理工具 Grunt 对比 Gulp

    转自Gulp vs Grunt 1. Grunt -> Gulp 早些年提到构建工具,难免会让人联想到历史比较悠久的Make,Ant,以及后来为了更方便的构建结构类似的Java项目而出现的Mav ...

  4. 【第七章】MySQL数据库备份-物理备份

    一.数据库备份 备份的目的: 备份: 能够防止由于机械故障以及人为误操作带来的数据丢失,例如将数据库文件保存在了其它地方. 冗余: 数据有多份冗余,但不等备份,只能防止机械故障还来的数据丢失,例如主备 ...

  5. Linux内核学习笔记(1)-- 进程管理概述

    一.进程与线程 进程是处于执行期的程序,但是并不仅仅局限于一段可执行程序代码.通常,进程还要包含其他资源,像打开的文件,挂起的信号,内核内部数据,处理器状态,一个或多个具有内存映射的内存地址空间及一个 ...

  6. LeetCode--147.对链表进行插入排序

    题目描述: 插入排序的动画演示如上.从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示). 每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中. 插入排序算法 ...

  7. Hyperledger Fabric中的Identity

    Hyperledger Fabric中的Identity 什么是Identity 区块链网络中存在如下的角色:peers, orderers, client application, administ ...

  8. MySQL Proxy和 Amoeba 工作机制浅析

    MySQL Proxy处于客户端应用程序和MySQL服务器之间,通过截断.改变并转发客户端和后端数据库之间的通信来实现其功能,这和WinGate 之类的网络代理服务器的基本思想是一样的.代理服务器是和 ...

  9. 由A到D中间可不止“B、C”

    在电子信息系统的学习中,我们或许早就被告知现实世界是模拟的,而数字化的模拟世界则越来越展现更多的风采.但是所谓的数字和模拟只是相对的而已,你可以把模拟量当做无穷数字量的组合,也可以把数字量当做具有不同 ...

  10. 2017软工第十周个人PSP

    11.17--11.23本周例行报告 1.PSP(personal software process )个人软件过程. C(类别) C(内容) ST(开始时间) ET(结束时间) INT(间隔时间) ...