2. 程式人生 > >[kuangbin帶你飛]專題九 連通圖 題解報告

[kuangbin帶你飛]專題九 連通圖 題解報告

阿新 • • 發佈：2019-02-01
A - Network of Schools  原題地址

本題有2個問題，第一個是要算最少要給多少個點軟體，才能使所有點都可以收到副本
第二個是要算最少加多少條邊，使得圖變成強連通

1：tarjan求強連通，然後縮點，計算入度為0的強連通分量
2：設現在有a個入度為0的點，b個出度為0的點（縮完點後的點），最合理的加邊方法肯定是從出度為0的點向入度為0的點新增有向邊，
如果a > b, 新增a條邊，所有點的入度都大於0，所有點的出度也大於0，問題解決，答案是a
如果 a <= b，新增a條邊，所有點入度大於0，但是還有b-a個點，它們的出度是0，所以還要再加b-a條邊，所以答案是b
綜合兩種情況，答案是max（a，b）

當然如果圖原來就是強連通的話，輸出就是1 和 0 了


#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

struct node
{
	int next;
	int to;
}edge[N * N];

int st[N];
int tot, ord, sccnum, top;
int head[N];
int low[N];
int DFN[N];
int in_deg[N];
int out_deg[N];
int block[N];
bool instack[N];

void addedge(int from, int to)
{
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void tarjan (int u)
{
	 DFN[u] = low[u] = ++ord;
	 instack[u] = 1;
	 st[top++] = u;
	 for (int i = head[u]; ~i; i = edge[i].next)
	 {
	 	 int v = edge[i].to;
	 	 if (DFN[v] == -1)
		 {
		 	 tarjan (v);
		 	 if (low[u] > low[v])
			 {
			 	 low[u] = low[v];
			 }
		 }
		 else if (instack[v])
		 {
		 	 low[u] = min(low[u], DFN[v]);
		 }
	 }
	 int v;
	 if (DFN[u] == low[u])
	 {
	 	 sccnum++;
	 	 do
		 {
			v = st[--top];
			block[v] = sccnum;
			instack[v] = 0;
		 }while (v != u);
	 }
}

void init ()
{
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (head, -1, sizeof(head));
	memset (in_deg, 0, sizeof(in_deg));
	memset (out_deg, 0, sizeof(out_deg));
	memset (instack, 0, sizeof(instack));
	top = 0;
	tot = 0;
	sccnum = 0;
	ord = 0;
}

void solve (int n)
{
	for (int i = 1; i <= n; ++i)
	{
		if (DFN[i] == -1)
		{
			tarjan (i);
		}
	}
	if (sccnum == 1)
	{
		printf("1\n0\n");
		return;
	}
	for (int u = 1; u <= n; ++u)
	{
		for (int j = head[u]; ~j; j = edge[j].next)
		{
			int v = edge[j].to;
			if (block[u] == block[v])
			{
				continue;
			}
			out_deg[block[u]]++;
			in_deg[block[v]]++;
		}
	}
	int a, b;
	a = 0;
	b = 0;
	for (int i = 1; i <= sccnum; ++i)
	{
		if (in_deg[i] == 0)
		{
			a++;
		}
		else if (out_deg[i] == 0)
		{
			b++;
		}
	}
	printf("%d\n", a);
	printf("%d\n", max(a, b));
}

int main()
{
	int n;
	int u, v;
	while (~scanf("%d", &n))
	{
		init();
		for (int u = 1; u <= n; ++u)
		{
			while (scanf("%d", &v), v)
			{
				addedge (u, v);
			}
		}
		solve(n);
	}
	return 0;
}

B - Network  原題地址

求割點數目，模版題


#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

struct node
{
	int next;
	int to;
}edge[N * N];

bool instack[N];
bool cut[N];
int head[N];
int DFN[N];
int low[N];
int cnt, tot, ord, root;

void addedge (int from, int to)
{
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void tarjan (int u, int fa)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	int cnt = 0;
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v == fa)
		{
			continue;
		}
		if (DFN[v] == -1)
		{
			tarjan(v, u);
			cnt++;
			if (low[u] > low[v])
			{
				low[u] = low[v];
			}
			if (root == u && cnt > 1)
			{
				cut[u] = 1;
			}
			else if (u != root && low[v] >= DFN[u])
			{
				cut[u] = 1;
			}
		}
		else if (instack[v])
		{
			low[u] = min(low[u], DFN[v]);
		}
	}
}

void init ()
{
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	memset (cut, 0, sizeof(cut));
	memset (head, -1, sizeof(head));
	tot = 0;
	ord = 0;
}

void solve (int n)
{
	root = 1;
	tarjan (1, -1);
	int ans = 0;
	for (int i = 1; i <= n; ++i)
	{
		if (cut[i])
		{
			ans++;
		}
	}
	printf("%d\n", ans);
}

int main()
{
	int n;
	int u, v;
	while (~scanf("%d", &n), n)
	{
		init();
		while (scanf("%d", &u), u)
		{
			while (getchar() != '\n')
			{
				scanf("%d", &v);
				addedge (u, v);
				addedge (v, u);
			}
		}
		solve(n);
	}
	return 0;
}

C - Critical Links

求橋，模版題，這題似乎不用判重邊


#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;
const int M = (N << 2);

struct node
{
	int next;
	int to;
//	int id;
}edge[M];

struct BRIDGE
{
	int u;
	int v;
}bridge[M];

int head[N];
int DFN[N];
int low[N];
int st[N];
bool instack[N];
int tot, top, ord, sccnum, cnt;

void init ()
{
	memset (head, -1, sizeof(head));
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	tot = top = cnt = sccnum = ord = 0;
}

void addedge (int from, int to)
{
	edge[tot].to = to;
//	edge[tot].id = id;
	edge[tot].next = head[from];
	head[from] = tot++;
}

int cmp (BRIDGE a, BRIDGE b)
{
	if (a.u == b.u)
	{
		return a.v < b.v;
	}
	return a.u < b.u;
}

void tarjan (int u, int fa)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st[top++] = u;
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v == fa)
		{
			continue;
		}
		if (DFN[v] == -1)
		{
			tarjan (v, u);
			low[u] = min (low[v], low[u]);
			if (low[v] > DFN[u])
			{
				bridge[++cnt].u = u;
				bridge[cnt].v = v;
				if (bridge[cnt].u > bridge[cnt].v)
				{
					swap (bridge[cnt].u, bridge[cnt].v);
				}
			}
		}
		else if (instack[v])
		{
			low[u] = min (low[u], DFN[v]);
		}
	}
	if (low[u] == DFN[u])
	{
		++sccnum;
		int v;
		do
		{
			v = st[--top];
			instack[v] = 0;
		}while (u != v);
	}
}

void solve (int n)
{
	for (int i = 1; i <= n; ++i)
	{
		if (DFN[i] == -1)
		{
			tarjan(i, -1);
		}
	}
	sort (bridge + 1, bridge + cnt + 1, cmp);
	printf("%d critical links\n", cnt);
	for (int i = 1; i <= cnt; ++i)
	{
		printf("%d - %d\n", bridge[i].u - 1, bridge[i].v - 1);
	}
	printf("\n");
}

int main()
{
	int n;
	int u, v;
	int num;
	while (~scanf("%d", &n))
	{
		if (n == 0)
		{
			printf("0 critical links\n\n");
			continue;
		}
		init();
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &u);
			++u;
			getchar();
			getchar();
			scanf("%d", &num);
			getchar();
			while (num--)
			{
				scanf("%d", &v);
				++v;
				addedge (u, v);
			}
		}
		solve (n);
	}
	return 0;
}

D - Network  原題地址
敢不敢不叫 Network了

詢問每次新增一條邊以後剩下的橋的數目
先一次tarjan縮點，得到一顆樹，每次 加邊，兩個端點到它們的lca之間的邊都不再是橋，所以每一次我們都可以通過暴力求出lca，然後統計出少了多少條橋，但是暴力統計時，會遇到某些邊在之前就不是橋的情況，我們用並查集來跳過這些邊（每一次加邊就把lca路徑上的點都合併到一個集合裡去，這裡根用最上面的點，到時如果遇到這種點，直接可以跳到它們的根上去）


#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

const int N = 110010;
const int M = 210010;

int head[N];
int head2[N];
int DFN[N];
int low[N];
int deep[N];
int father[N];
int block[N];
int pre[N];
int st[N];
bool instack[N];
int tot, tot2, top, ord, sccnum, icase;

struct node
{
	int next;
	int to;
	int id;
}edge[M << 2], edge2[M << 2];

void init ()
{
	memset (DFN, -1, sizeof(DFN));
	memset (head, -1, sizeof(head));
	memset (head2, -1, sizeof(head2));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	tot = tot2 = ord = sccnum = top = 0;
}

void addedge (int from, int to, int id)
{
	edge[tot].to = to;
	edge[tot].id = id;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void addedge2 (int from, int to)
{
	edge2[tot2].to = to;
	edge2[tot2].next = head2[from];
	head2[from ] = tot2++;
}

void dfs (int u, int fa, int d)
{
	pre[u] = fa;
	deep[u] = d;
	for (int i = head2[u]; ~i; i = edge2[i].next)
	{
		int v = edge2[i].to;
		if (v == fa)
		{
			continue;
		}
		dfs (v, u, d + 1);
	}
}

int find (int x)
{
	if (x == father[x])
	{
		return x;
	}
	return father[x] = find(father[x]);
}

void tarjan (int u, int x)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st[top++] = u;
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (edge[i].id == x)
		{
			continue;
		}
		if (DFN[v] == -1)
		{
			tarjan (v, edge[i].id);
			low[u] = min(low[u], low[v]);
		}
		else if (instack[v])
		{
			low[u] = min(low[u], DFN[v]);
		}
	}
	int v;
	if (DFN[u] == low[u])
	{
		++sccnum;
		do
		{
			v = st[--top];
			instack[v] = 0;
			block[v] = sccnum;
		}while (v != u);
	}
}

int LCA (int a, int b)
{
	while (a != b)
	{
		if (deep[a] > deep[b])
		{
			a = pre[a];
		}
		else if (deep[a] < deep[b])
		{
			b = pre[b];
		}
		else
		{
			a = pre[a];
			b = pre[b];
		}
		a = find(a);
		b = find(b);
	}
	return a;
}

void solve (int n)
{
	tarjan (1, -1);
	for (int u = 1; u <= n; ++u)
	{
		for (int i = head[u]; ~i; i = edge[i].next)
		{
			int v = edge[i].to;
			if (block[u] == block[v])
			{
				continue;
			}
			addedge2 (block[u], block[v]);
		}
	}
	for (int i = 1; i <= sccnum; ++i)
	{
		father[i] = i;
	}
	int cnt = sccnum - 1;
	dfs(1, -1, 0);
	int q, a, b, lca;
	scanf("%d", &q);
	printf("Case %d:\n", icase++);
	while (q--)
	{
		scanf("%d%d", &a, &b);
		a = block[a];
		b = block[b];
		if (a == b)
		{
			printf("%d\n", cnt);
			continue;
		}
		a = find(a);
		b = find(b);
		lca = LCA (a, b);
		int x = 0;
		while (a != lca)
		{
			++x;
			father[a] = lca;
			a = pre[a];
			a = find(a);
		}
		while (b != lca)
		{
			++x;
			father[b] = lca;
			b = pre[b];
			b = find(b);
		}
		cnt -= x;
		printf("%d\n", cnt);
	}	
}

int main()
{
	int n, m;
	int u, v;
	icase = 1;
	while (~scanf("%d%d", &n, &m))
	{
		if (!n && !m)
		{
			break;
		}
		init();
		for (int i = 1; i <= m; ++i)
		{
			scanf("%d%d", &u, &v);
			addedge (u, v, i);
			addedge (v, u, i);
		}
		solve(n);
		printf("\n");
	}
	return 0;
}


E - Redundant Paths 原題地址

求橋的數目，模版題，注意重邊的判定

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 5010;
const int M = 10010;

struct node
{
	int next;
	int to;
	int id;
}edge[M << 1];

int head[N];
int DFN[N];
int low[N];
bool instack[N];
int block[N];
int deg[N];
stack <int> st;
int tot, sccnum, ord;

void addedge (int from, int to, int id)
{
	edge[tot].id = id;
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void init ()
{
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	memset (deg, 0, sizeof(deg));
	memset (head, -1, sizeof(head));
	while (!st.empty())
	{
		st.pop();
	}
	tot = sccnum = ord = 0;
}

void tarjan (int u, int x)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st.push(u);
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (x == edge[i].id)
		{
			continue;
		}
		if (DFN[v] == -1)
		{
			tarjan (v, edge[i].id);
			low[u] = min(low[u], low[v]);
		}
		else if (instack[v])
		{
			low[u] = min(low[u], DFN[v]);
		}
	}
	int v;
	if (DFN[u] == low[u])
	{
		++sccnum;
		do
		{
			v = st.top();
			st.pop();
			instack[v] = 0;
			block[v] = sccnum;
		}while (v != u);
	}
}

void solve (int n)
{
	for (int i = 1; i <= n; ++i)
	{
		if (DFN[i] == -1)
		{
			tarjan (i, -1);
		}
	}
	for (int u = 1; u <= n; ++u)
	{
		for (int j = head[u]; ~j; j = edge[j].next)
		{
			int v = edge[j].to;
			if (block[u] == block[v])
			{
				continue;
			}
		    ++deg[block[u]];
		    ++deg[block[v]];
		}
	}
	int cnt = 0;
	for (int i = 1; i <= sccnum; ++i)
	{
		if (deg[i] / 2 == 1)
		{
			++cnt;
		}
	}
	printf("%d\n", (cnt + 1) >> 1);
}

int main()
{
	int n, m;
	int u, v;
	while (~scanf("%d%d", &n, &m))
	{
		init();
		for (int i = 1; i <= m; ++i)
		{
			scanf("%d%d", &u, &v);
			addedge (u, v, i);
			addedge (v, u, i);
		}
		solve(n);
	}
	return 0;
}



F - Warm up 原題地址

詢問如何加一條邊，使得剩下的橋的數目最少，輸出數目
我的做法是先tarjan縮點，得到樹，然後求出樹的直徑，把邊加在直徑的兩端，減少的橋肯定是最多的

#include <map>
#include <set>
#include <list>
#include <stack>
#include <vector>
#include <queue>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

const int N = 200010;
const int inf = 0x3f3f3f3f;
const int M = 3000010;

struct node
{
    int next;
    int to;
    int id;
}edge[M], edge2[M];

bool vis[N];
bool flag[N];
int dist[N];
int head[N];
int head2[N];
int low[N];
int block[N];
int DFN[N];
bool instack[N];
stack<int>qu;
int br_cnt, n, m, end_p;
int tot, tot2, maxs, index, top, sccnum;

void addedge(int from, int to, int id)
{
    edge[tot].id = id;
    edge[tot].to = to;
    edge[tot].next = head[from];
    head[from] = tot++;
}

void addedge2(int from, int to)
{
    edge2[tot].to = to;
    edge2[tot].next = head2[from];
    head2[from] = tot++;
}

void init()
{
    index = 0;
    sccnum = 0;
    top = 0;
    tot = 0;
    tot2 = 0;
    maxs = 0;
    br_cnt = 0;
    end_p = 0;
    memset ( head, -1, sizeof(head) );
    memset (head2, -1, sizeof(head2) );
    memset ( low, 0, sizeof(low) );
    memset (DFN, 0, sizeof(DFN) );
    memset ( instack, 0, sizeof(instack) );
    memset ( flag, 0, sizeof(flag) );
    memset (vis, 0, sizeof(vis) );

}

void build()
{
    int u, v;
    while (!qu.empty() )
    {
        qu.pop();
    }
    for (int i = 1; i <= m; ++i)
    {
        scanf("%d%d", &u, &v);
        addedge(u, v, i);
        addedge(v, u, i);
    }
}

void tarjan(int u, int fa)  
{  
    qu.push(u);
    instack[u] = 1;
    DFN[u] = low[u] = ++index;  
    for (int i = head[u]; i != -1; i = edge[i].next)  
    {  
        int v = edge[i].to;  
        if (fa == edge[i].id)  
        {
            continue;
        }   
        if ( !instack[v] )  
        {  
            tarjan(v, edge[i].id);  
            low[u] = min(low[u], low[v]);  
            if (DFN[u] < low[v])
            {
                br_cnt++;
            }
        }  
        else 
        {
            low[u] = min(DFN[v], low[u]);
        }  
    }
    if (DFN[u] == low[u])
    {
        sccnum++;
        int v;
        while(1)
        {
            v = qu.top();
            qu.pop();
            instack[v] = 0;
            block[v] = sccnum;
            if(v == u)
            {
                break;
            }
        }
    }
}

void bfs(int s)
{
    queue<int>qu;
    while ( !qu.empty() )
    {
        qu.pop();
    }
    memset ( vis, 0, sizeof(vis) );
    qu.push(s);
    dist[s] = 0;
    vis[s] = 1;
    maxs = 0;
    while ( !qu.empty() )
    {
        int u = qu.front();
        qu.pop();
        for (int i = head2[u]; i != -1; i = edge2[i].next)
        {
            int v = edge2[i].to;
            if (!vis[v])
            {
                vis[v] = 1;
                dist[v] = dist[u] + 1;
                qu.push(v);
                if (maxs < dist[v])
                {
                    maxs = dist[v];
                    end_p = v;
                }
            }
        }
    }
}

void solve()
{
    for (int i = 1; i <= n; ++i)
    {
        if (DFN[i] == 0)
        {
            tarjan(i, -1);
        }
    } 
    for (int u = 1; u <= n; ++u)
    {
        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].to;
            if (block[u] != block[v])
            {
                addedge2(block[u], block[v]);
            }
        }
    }
    bfs(1);
    bfs(end_p);
    printf("%d\n", br_cnt - maxs);
}

int main()
{
    while (~scanf("%d%d", &n, &m))
    {
        if (!n && !m)
        {
            break;
        }
        init();
        build();
        solve();
    }
    return 0;
}

G - Strongly connected 原題地址

求最多可以加多少邊，使得最新的圖不是強連通圖
最終情況一定是再加一條邊，整張圖就是強連通的了，那麼我們可以把圖看成2部分x和y，x和y都是完全圖，然後x每個點到y每個點都有邊，但是y到x沒有邊，如果有肯定是強連通了，設x中有a個點，y中有b個點 則 a + b = n
則邊數就是 a * (a - 1) + b * (b - 1) + a * b - m，化簡得到：n * n - a * b - n - m;
如何讓這個值大那就是如何選取x和y的問題了，顯然a和b差距越大越好，那麼就可以通過tarajan來找出一個包含點最少的強連通分量來當x，其他的強連通分量作為y，這樣就很容易了

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

struct node
{
	int next;
	int to;
}edge[N << 1];

int head[N];
int DFN[N];
int low[N];
int num[N];
int st[N];
bool instack[N];
int block[N];
int in[N];
int out[N];
int tot, top, ord, sccnum;

void addedge (int from, int to)
{
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void init ()
{
	memset (num, 0, sizeof(num));
	memset (in, 0, sizeof(in));
	memset (out, 0, sizeof(out));
	memset (head, -1, sizeof(head));
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	tot = top = ord = sccnum = 0;
}

void tarjan (int u)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st[top++] = u;
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (DFN[v] == -1)
		{
			tarjan (v);
			low[u] = min (low[u], low[v]);
		}
		else if (instack[v])
		{
			low[u] = min(low[u], DFN[v]);
		}
	}
	if (DFN[u] == low[u])
	{
		int v;
		++sccnum;
		do
		{
			++num[sccnum];
			v = st[--top];
			block[v] = sccnum;
			instack[v] = 0;
		}while (v != u);
	}
}

void solve (int n, int m)
{
	for (int i = 1; i <= n; ++i)
	{
		if (DFN[i] == -1)
		{
			tarjan (i);
		}
	}
	if (sccnum == 1)
	{
		printf("-1\n");
		return;
	}
	for (int u = 1; u <= n; ++u)
	{
		for (int i = head[u]; ~i; i = edge[i].next)
		{
			int v = edge[i].to;
			if (block[u] == block[v])
			{
				continue;
			}
			++out[block[u]];
			++in[block[v]];
		}
	}
	long long ans = 0;
	long long ret = (long long)(n * n - n - m);
	for (int i = 1; i <= sccnum; ++i)
	{
		if (in[i] == 0 || out[i] == 0)
		{
			ans = max(ans, ret - (long long)(num[i] * (n - num[i])));
		}
	}
	printf("%lld\n", ans);
}

int main()
{
	int t;
	int n, m;
	int u, v;
	int icase = 1;
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d%d", &n, &m);
		init();
		for (int i = 1; i <= m; ++i)
		{
			scanf("%d%d", &u, &v);
			addedge (u, v);
		}
		printf("Case %d: ", icase++);
		solve (n, m);
	}
	return 0;
}


H - Prince and Princess 原題地址

首先做一次最大匹配，設為cnt，那麼對於左邊，有n-cnt個王子沒有匹配，對於右邊，有m-cnt個公主沒有匹配，所以我們在左邊加上m-cnt個虛擬點，這些點喜歡所有公主，右邊加上n-cnt個虛擬點，這些點被所有王子喜歡，這樣左右兩邊都是n+m-cnt個點，在求一次最大匹配，這一定是一個完備匹配，對於每一個王子，用他目前匹配的公主，向所有他喜歡的公主連一條有向邊，這表示單方面可以替換，所以再對得到的新圖求強連通，處在一個強連通分量的公主可以相互替換

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1100;

int head[N];
int DFN[N];
int low[N];
int block[N];
int match[N];
int match2[N];
bool used[N];
bool instack[N];
bool g[N][N];
stack <int> st;
vector <int> vis;
int n, m, tot, sccnum, ord, num_v, num_u;

struct node
{
	int next;
	int to;
}edge[N * N * 5];

void init ()
{
	vis.clear();
	memset (g, 0, sizeof(g));
	memset (match, -1, sizeof(match));
	memset (match2, -1, sizeof(match2));
	memset (used, 0, sizeof(used));
	memset (instack, 0, sizeof(instack));
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (head, -1, sizeof(head));
	tot = sccnum = ord = 0;
}

void addedge (int from, int to)
{
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

bool dfs (int u)
{
	for (int i = 1; i <= num_v; ++i)
	{
		if (!g[u][i])
		{
			continue;
		}
		int v = i;
		if (!used[v])
		{
			used[v] = 1;
			if (match[v] == -1 || dfs (match[v]))
			{
				match[v] = u;
				return 1;
			}
		}
	}
	return 0;
}

int hungry ()
{
	int cnt = 0;
	for (int i = 1; i <= num_u; ++i)
	{
		memset (used, 0, sizeof(used));
		if (dfs(i))
		{
			++cnt;
		}
	}
	return cnt;
}

void tarjan (int u)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st.push(u);
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (DFN[v] == -1)
		{
			tarjan (v);
			low[u] = min (low[v], low[u]);
		}
		else if (instack[v])
		{
			low[u] = min (low[u], DFN[v]);
		}
	}
	int v;
	if (low[u] == DFN[u])
	{
		++sccnum;
		do
		{
			v = st.top();
			st.pop();
			instack[v] = 0;
			block[v] = sccnum;
		}while (u != v);
	}
}

void solve ()
{
	num_u = n;
	num_v = m;
	int cnt = hungry();
	num_u = n + m - cnt;
	num_v = num_u;
	for (int i = n + 1; i <= num_u; ++i)
	{
		for (int j = 1; j <= num_v; ++j)
		{
			g[i][j] = 1;
		}
	}
	for (int i = 1; i <= num_u; ++i)
	{
		for (int j = m + 1; j <= num_v; ++j)
		{
			g[i][j] = 1;
		}
	}
//	printf("%d\n", cnt);
	memset (match, -1, sizeof(match));
	cnt = hungry();
//	printf("%d\n", cnt);
	for (int i = 1; i <= num_v; ++i)
	{
		match2[match[i]] = i;
	}
	for (int i = 1; i <= num_u; ++i)
	{
		for (int j = 1; j <= num_v; ++j)
		{
			if (g[i][j] && match2[i] != j)
			{
				addedge (match2[i], j);
			}
		}
	}
	for (int i = 1; i <= num_v; ++i)
	{
		if (DFN[i] == -1)
		{
			tarjan (i);
		}
	}
	for (int i = 1; i <= n; ++i)
	{
		vis.clear();
		for (int j = 1; j <= m; ++j)
		{
			if (g[i][j] && block[j] == block[match2[i]])
			{
				vis.push_back (j);
			}
		}
		int tmp = vis.size();
		printf("%d", tmp);
		for (int j = 0; j < tmp; ++j)
		{
			printf(" %d", vis[j]);
		}
		printf("\n");
	}
}

int main ()
{
	int t;
	int u, v, num;
	int icase = 1;
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d%d", &n, &m);
		init();
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &num);
			while (num--)
			{
				scanf("%d", &v);
				g[i][v] = 1;
			}
		}
		printf("Case #%d:\n", icase++);
		solve();
	}
	return 0;
}


I - Caocao's Bridges  原題地址

此題其實不難，但是很坑
1：如果圖不連通，那麼不需要派人去
2：如果有一條橋，防衛兵數目為0，那麼應該派1個人去
3：重邊判定

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;
const int M = N * N;

struct node
{
	int next;
	int to;
	int id;
	int w;
}edge[M << 1];

int head[N];
int DFN[N];
int low[N];
int st[N];
bool instack[N];
int bridge[M];
int tot, cnt, ord, top, sccnum;

void addedge (int from, int to, int id, int w)
{
	edge[tot].w = w;
	edge[tot].to = to;
	edge[tot].id = id;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void init ()
{
	memset (head, -1, sizeof(head));
	memset (DFN, -1, sizeof(DFN));
	memset (low, 0, sizeof(low));
	memset (instack, 0, sizeof(instack));
	tot = cnt = ord = top = sccnum = 0;
}

void tarjan (int u, int x)
{
	DFN[u] = low[u] = ++ord;
	instack[u] = 1;
	st[top++] = u;
	for (int i = head[u]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if (edge[i].id == x)
		{
			continue;
		}
		if (DFN[v] == -1)
		{
			tarjan (v, edge[i].id);
			low[u] = min(low[u], low[v]);
			if (low[v] > DFN[u])
			{
				bridge[++cnt] = edge[i].w;
			}
		}
		else if (instack[v])
		{
			low[u] = min(low[u], DFN[v]);
		}
	}
	int v;
	if (DFN[u] == low[u])
	{
		++sccnum;
		do
		{
			v = st[--top];
			instack[v] = 0;
		}while (u != v);
	}
}

void solve (int n)
{
	int num = 0;
	for (int i = 1; i <= n; ++i)
	{
		if (DFN[i] == -1)
		{
			++num;
			tarjan (i, -1);
		}
		if (num > 1)
		{
			break;
		}
	}
	if (num > 1)
	{
		printf("0\n");
		return;
	}
	if (cnt == 0)
	{
		printf("-1\n");
		return;
	}
	int minx = 0x3f3f3f3f;
	for (int i = 1; i <= cnt; ++i)
	{
		if (minx > bridge[i])
		{
			minx = bridge[i];
		}
	}
	if (minx == 0)
	{
		++minx;
	}
	printf("%d\n", minx);
}

int main()
{
	int n, m;
	int u, v, w;
	while (~scanf("%d%d", &n, &m))
	{
		if (!n && !m)
		{
			break;
		}
		init();
		for (int i = 1; i <= m; ++i)
		{
			scanf("%d%d%d", &u, &v, &w);
			addedge (u, v, i, w);
			addedge (v, u, i, w);
		}
		solve(n);
	}
	return 0;
}


相關推薦

[kuangbin帶你飛]專題九 連通圖 題解報告

A - Network of Schools  原題地址 本題有2個問題，第一個是要算最少要給多少個點軟體，才能使所有點都可以收到副本 第二個是要算最少加多少條邊，使得圖變成強連通 1：tarjan求強連通，然後縮點，計算入度為0的強連通分量 2：設現在有a個入度為0的點，b個出度為0的點（縮完點後的點），

[kuangbin帶你飛]專題一 簡單搜尋 題解報告

又重頭開始刷kuangbin，有些題用了和以前不一樣的思路解決。全部題解如下 點選每道題的標題即可跳轉至VJ題目頁面。 A-棋盤問題 棋子不能擺在相同行和相同列，所以我們可以依此列舉每一行，然後標記每一列是否走過，在此基礎上進行DFS即可。 程式碼如下： 1 #include <i

[kuangbin帶你飛]專題八 生成樹 題解彙總

本來準備省賽和其他的比賽先不打算做kuangbin專題了，不過我朋友AK了最小生成樹專題，問我繼續怎麼練。既然都練了最小生成樹，不如把後面的那個生成樹專題也啃了吧。然後clone生成樹專題，花了5天懟完。主要是中間一堆作業要懟，耽誤了很多時間。我把我的題解和程式碼都放到了Gi

[kuangbin帶你飛]專題一 簡單搜尋 題解

時間很緊了，馬上就要大三了。。 卻還在低階演算法遨遊，說來真是懺愧，好好刷題了，兩個寒假全浪費了 看到了一個同是大二,卻比自己厲害很多的同齡人，自己需要加把勁了 加油！ A題 棋盤問題 直接dfs,列舉所有情況就行 程式碼如下 #include<cstdio&g

kuangbin帶你飛專題一 簡單搜索 題解

上下 bst turn str 表示 stream 就是 += find 目錄 [kuangbin帶你飛]專題一 簡單搜索 [kuangbin帶你飛]專題一 簡單搜索 總結：用時2天半終於把這個專題刷完了 對於最基礎的dfs bfs 路徑打印 狀態轉移也有了一點自己些

I - Fire! ~~ [kuangbin帶你飛]專題一 簡單搜尋

題目描述 喬在迷宮中工作。不幸的是，迷宮的一部分著火了，迷宮的主人沒有制定火災的逃跑計劃。請幫助喬逃離迷宮。根據喬在迷宮中的位置以及迷宮的哪個方塊著火，你必須確定火焰燒到他之前，喬是否可以離開迷宮，如果能離開他能跑多快。 喬和火每分鐘移動一個方格，上、下、左、右，四個方向中的一個。火勢向四個方向

O - Meteor Shower ~~~ [kuangbin帶你飛]專題一 簡單搜尋

Description - 題目描述 Bessie聽說有場史無前例的流星雨即將來臨；有讖言：隕星將落，徒留灰燼。為保生機，她誓將找尋安全之所（永避星墜之地）。目前她正在平面座標系的原點放牧，打算在群星斷其生路前轉移至安全地點。 此次共有M (1 ≤ M ≤ 50,000)

M - Find a way ~~~ [kuangbin帶你飛]專題一 簡單搜尋

hsj和lsh最近迷上了pokemon go的遊戲。在雙十一大物期中考試來臨之前，他們想抓一隻稀有土撥鼠來攢攢人品（因為土撥鼠的重新整理地點最近來到了哈工程） 但是由於土撥鼠過於強大，他的雷霆半月斬以及驚天浪濤沙都可以輕鬆的將他們兩擊敗，但是他們兩的合擊必殺技流影電光閃以及天羽屠鼠舞可以將土撥鼠打至

L - 非常可樂 ~~ [kuangbin帶你飛]專題一 簡單搜尋

大家一定覺的運動以後喝可樂是一件很愜意的事情，但是seeyou卻不這麼認為。因為每次當seeyou買了可樂以後，阿牛就要求和seeyou一起分享這一瓶可樂，而且一定要喝的和seeyou一樣多。但seeyou的手中只有兩個杯子，它們的容量分別是N 毫升和M 毫升 可樂的體積為S （S<101）毫

N - Red and Black ~~ [kuangbin帶你飛]專題一 簡單搜尋

有一個長方形的房間，覆蓋了正方形的磁磚。每塊磁磚的顏色，要麼是紅色，要麼是黑色。一名男子站在一塊黑色的磁磚上。他可以從一塊磁磚移至相鄰四塊磁磚中的某一塊。但是，他不允許在紅色磁磚上移動，他只允許在黑色磁磚上移動。 編寫一個程式，使得他允許重複上述的移動，判斷他所能到達的黑色磁磚的數量。 輸入

K - Oil Deposits ~~ [kuangbin帶你飛]專題一 簡單搜尋

GeoSurvComp地質調查公司負責探測地下石油儲藏。 GeoSurvComp現在在一塊矩形區域探測石油，並把這個大區域分成了很多小塊。他們通過專業裝置，來分析每個小塊中是否蘊藏石油。如果這些蘊藏石油的小方格相鄰，那麼他們被認為是同一油藏的一部分。在這塊矩形區域，可能有很多油藏。你的任務是確定有多

F - Prime Path ~~ [kuangbin帶你飛]專題一 簡單搜尋

給你兩個四位的素數a，b。 a可以改變某一位上的數字變成c，但只有當c也是四位的素數時才能進行這種改變。 請你計算a最少經過多少次上述變換才能變成b。 例如：1033 -> 8179 1033 1733 3733 3739 3779 8779 8179 最少變換了6次。 Input 第

E - Find The Multiple ~ [kuangbin帶你飛]專題一 簡單搜尋

給定一個正整數n，請編寫一個程式來尋找n的一個非零的倍數m，這個m應當在十進位制表示時每一位上只包含0或者1。你可以假定n不大於200且m不多於100位。 提示：本題採用Special Judge，你無需輸出所有符合條件的m，你只需要輸出任一符合條件的m即可。 Input 輸入包含多組資料，

C - Catch That Cow ~ [kuangbin帶你飛]專題一 簡單搜尋

  農夫知道一頭牛的位置，想要抓住它。農夫和牛都於數軸上 ，農夫起始位於點 N(0<=N<=100000) ，牛位於點 K(0<=K<=100000) 。農夫有兩種移動方式： 1、從 X移動到 X-1或X+1 ，每次移動花費一分鐘 2、從 X移動到 2*X ，每

A - 棋盤問題 ~ [kuangbin帶你飛]專題一 簡單搜尋

在一個給定形狀的棋盤（形狀可能是不規則的）上面擺放棋子，棋子沒有區別。要求擺放時任意的兩個棋子不能放在棋盤中的同一行或者同一列，請程式設計求解對於給定形狀和大小的棋盤，擺放k個棋子的所有可行的擺放方案C。 Input 輸入含有多組測試資料。 每組資料的第一行是兩個正整數，n k，用一個空格隔

[kuangbin帶你飛]專題六 最小生成樹

You are a member of the space station engineering team, and are assigned a task in the construction process of the station. You are expected to write a com

[kuangbin帶你飛]專題一 簡單搜尋

The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numb

[kuangbin帶你飛]專題二-搜尋進階-D-Escape

ACM模版 描述 題解 這種問題不難，無非兩點，一：看懂題，二：細心。 矩陣的搜尋一般使用 bfs 比較多，也比較好，這裡的標記要用一個三維陣列，多出來的一維用來標記時間，記住要用 bool 型，習慣性的使用 int 型會爆記憶體的，其他也沒

[kuangbin帶你飛]專題四 最短路練習 A-D

　　上了大二，又有新生來了，壓力也來了，不能像大一這麼鬆懈了，所以開始每天刷刷題，想根據專題一個知識點一個知識點過 　　今天是最短路專題，對於最短路，能想到的方法大概就是dijkstra演算法（求單源最短路不含負環）O（n^2）如果使用堆優化，就是O（mlogn）,還有就是floyd演算法（求圖上任意兩點的

[kuangbin帶你飛]專題十六 KMP & 擴充套件KMP & Manacher 題解報告

來刷kuangbin字串了，字串處理在ACM中是很重要的，一般比賽都會都1——2道有關字串處理的題目，而且不會很難的那種，大多數時候都是用到一些KMP的性質或者找規律。 點選標題可跳轉至VJ比賽題目連結。 A - Number Sequence 題意就是讓你去找在串A找串B首次出現的位置，現在串不是字串