点连通度 边连通度 最大流最小割 最小割点集 最小割边集 & POJ 1966 Cable TV Network
概念
(1)一个具有 N 个顶点的图，在去掉任意 k-1 个顶点后 (1<=K<=N) 所得的子图仍连通
，而去掉 K 个顶点后的图不连通则称 G 是连通的， K 称作图 G 的点连通度，记作 K(G) 试设计
(2)相应地如果至少去掉 K 条边使这个图不连通，则 K 成为图的边连通度
等价关系
(1)求边连通度给每条边赋权值 1 ，任意选择源点，枚举汇点，依次求最小割，取其中的最小值即可
(2)那么给定源点和汇点时怎么求最小割呢，那就用到了最大流最小割定理，即一个图的小割等于其源点与汇店间的最大流
(3) 如何求一个图的最小割边集呢：最大流最小割定理，首先求得最大流。然后残留网络中，从源点出发深度优先遍历，所有被遍历到的点构成点集 SET1 ，剩余的点构成点集 SET2 。则 edge
(4)求一个给定的无向图的点连通度，可以转换为求边连通度，怎么转换就如下所示：
将点连通度转化为边连通度时怎么建图呢：
1 ．构造一个网络 N
若 G 为无向图：
(1) 原 G 图中的每个顶点 v 变成 N 网中的两个顶点 v' 和 v" ，顶点 v' 至 v" 有一条弧（有向边）连接，弧容量为 1;
(2) 原 G 图中的每条边 e ＝ uv ，在 N 网中有两条弧 e’= u"v',e"=v"u' 与之对应， e' 弧容量为 ∞ ， e" 弧容量为 ∞
(3)A” 为源顶点， B' 为汇顶点
注意：弧是有向边
若 G 为有向图：
(I) 原 G 图中的每个顶点变成 N 网中的两个顶点 v’ 和 v” ，顶点 v' 至 v” 有一条弧连接，弧容量为 1
(2) 原 G 图中的每条弧 e ＝ uv 变成一条有向轨 u'u"v'v" ，其中轨上的弧 u"v' 的容量为 ∞;
(3)A” 为源顶点， B' 为汇顶点
2 ．指定一个源点 A" ，枚举汇点，求 A" 到 B' 的最大流 F
3 ．求出所有枚举源点与汇点中的最小值 Fmin ，则所有具有流量 1 的弧 (v',v") 对应的 v 顶点组成一个割顶集，在 G 图中去掉这些顶点则 G 图变成不连通。
4 。求出的结果如果 Fmin >= n 则表示这个图是一个强连通图，不存在割点
下面举个求点连通度的例子 POJ 1966 Cable TV Network
#include
#define MAX_N 105
#define MAX_VAL 99999999
#include
using namespace std;
char temp[20];
int n, m, minCutNum;
//保存边1-2*n不保存实际的边，而作为邻接表的入口
struct edge
{
int to;
int next;
}edges[MAX_N * MAX_N + MAX_N];
int edgen;
int graph[MAX_N][MAX_N];
int df[MAX_N][MAX_N], f[MAX_N][MAX_N];
int pre[MAX_N];
bool v[MAX_N];
queue
//插入边
void insertEdge(int from, int to)
{
edgen++;
edges[edgen].to = to;
edges[edgen].next = edges[from].next;
edges[from].next = edgen;
}
//bfs找增广路径
int bfs(const int &source, const int &dest)
{
memset(v, 0, sizeof(v));
memset(pre, 0, sizeof(pre));
while(!bfsq.empty()) bfsq.pop();
v[source] = true;
bfsq.push(source);
while(!bfsq.empty())
{
int curid = bfsq.front();
bfsq.pop();
if(curid == dest) break;
int next = edges[curid].next, nextid;
while(next != 0)
{
nextid = edges[next].to;
if(!v[nextid] && df[curid][nextid] > 0)
{
v[nextid] = true;
pre[nextid] = curid;
bfsq.push(nextid);
}
next = edges[next].next;
}
}
if(!pre[dest]) return -1;
int preid, curid = dest, curminw = MAX_VAL;
while((preid = pre[curid]) != 0)
{
if(df[preid][curid] < curminw) curminw = df[preid][curid];
curid = preid;
}
return curminw;
}
//最大流算法
int admonsKarp(const int &source, const int &dest)
{
int val;
memcpy(df, graph, sizeof(graph));
memset(f, 0, sizeof(f));
while((val = bfs(source, dest)) != -1)
{
//更新残留网络与权值网络
int preid, curid = dest;
while((preid = pre[curid]) != 0)
{
df[preid][curid] -= val;
df[curid][preid] += val;
f[preid][curid] += val;
f[curid][preid] = -f[preid][curid];
curid = preid;
}
}
int next = edges[source].next, toid, total = 0;
while(next != 0)
{
toid = edges[next].to;
total += f[source][toid];
next = edges[next].next;
}
return total;
}
int main()
{
int i, p;
while(scanf("%d%d", &n, &m) != EOF)
{
edgen = 2 * n;
minCutNum = MAX_VAL;
memset(edges, 0, sizeof(edges));
memset(graph, 0, sizeof(graph));
//建图，将点连通度转换为边连通度
for(i = 1; i <= m; i++)
{
scanf("%s", temp);
int val1 = 0, val2 = 0;
p = 1;
while(temp[p] != ',')
{
val1 = val1 * 10 + int(temp[p] - '0');
p++;
}
p++;
while(temp[p] != ')')
{
val2 = val2 * 10 + int(temp[p] - '0');
p++;
}
val1++; val2++;
graph[val1 + n][val2] = MAX_VAL;
graph[val2 + n][val1] = MAX_VAL;
insertEdge(val1 + n, val2);
insertEdge(val2 + n, val1);
}
for(i = 1; i <= n; i++)
{
graph[i][i + n] = 1;// = graph[i + n][i] = 1;
insertEdge(i, i + n);
//insertEdge(i + n, i);
}
int curcutnum;
for(i = 2; i <= n; i++)
{
curcutnum = admonsKarp(1 + n, i);
if(curcutnum < minCutNum) minCutNum = curcutnum;
}
if(minCutNum >= n) printf("%d/n", n);
else printf("%d/n", minCutNum);
}
return 0;
}