POJ 2375 Cow Ski Area

大意：描述了一片滑雪场，并且规定奶牛从一个点只能向它相邻的并且高度不大于它的点运动，现在想要某些点对之间加上缆车使得奶牛业可以从较低点向较高点运动，问最少需要多少辆这样的缆车就可以使得奶牛可以从一个点到滑雪场的每一个角落。

思路：对于奶牛的运动，我们分两种情况进行考虑。

1、向高度相同运动：应为相互可达，那么只要到达其中一个的话，则整个高度相同的都可以到达，这与强连通分量很相似，所以我们可以把无向边拆成两条单向边，然后把相互可达的缩点处理。

2、向相邻的较低点运动：较高点可以向较低点运动，则连一条单向边。

回到题目的最终问题，让奶牛从每个点都可以到达滑雪场的每个角落，也就是使得图强连通。怎样使得图强连通？很明显，缩点之后算出入度为0与出度为0的最大值即可。特别的，当强连通分量只有一个是，答案为0。

注意输入时n, m的顺序。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAXN = 510;
const int MAXM = 510*510;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};

struct Edge
{
	int v, next;
}edge[MAXM*8];

int n, m;
int cnt;
int scnt, top, tot;

int map[MAXN][MAXN];
int first[MAXM], low[MAXM], dfn[MAXM], belong[MAXM], ins[MAXM], stack[MAXM];
int ind[MAXM], outd[MAXM];

void init()
{
	cnt = 0;
	scnt = top = tot = 0;
	memset(first, -1, sizeof(first));
	memset(ind, 0, sizeof(ind));
	memset(outd, 0, sizeof(outd));
	memset(ins, 0, sizeof(ins));
	memset(dfn, 0, sizeof(dfn));
}

int check(int x, int y)
{
	if(x >= 0 && x < n && y >= 0 && y < m) return 1;
	return 0;
}

void read_graph(int u, int v)
{
	edge[cnt].v = v;
	edge[cnt].next = first[u], first[u] = cnt++;
}

void read_graph2(int i, int j, int d)
{
	int xx = i + dx[d];
	int yy = j + dy[d];
	int u = i*m + j, v = xx*m + yy;
	if(check(xx, yy))
	{
		if(map[i][j] >= map[xx][yy])
		{
			read_graph(u, v);
		}
		if(map[i][j] <= map[xx][yy])
		{
			read_graph(v, u);
		}
	}
}

void dfs(int u)
{
	int v;
	low[u] = dfn[u] = ++tot;
	stack[top++] = u;
	ins[u] = 1;
	for(int e = first[u]; e != -1; e = edge[e].next)
	{
		v = edge[e].v;
		if(!dfn[v])
		{
			dfs(v);
			low[u] = min(low[u], low[v]);
		}
		else if(ins[v])
		{
			low[u] = min(low[u], dfn[v]);
		}
	}
	if(low[u] == dfn[u])
	{
		scnt++;
		do
		{
		    v = stack[--top];
			belong[v] = scnt;
			ins[v] = 0;
		}while(u != v);
	}
}

void Tarjan()
{
	for(int v = 0; v < n*m; v++) if(!dfn[v])
		dfs(v);
}

void build()
{
	init();
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < m; j++)
		{
			scanf("%d", &map[i][j]);
		}
	}
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < m; j++)
		{
			for(int d = 0; d < 4; d++)
			{
				read_graph2(i, j, d);
			}
		}
	}
}

void solve()
{
	build();
	Tarjan();
	for(int u = 0; u < n*m; u++)
	{
		for(int e = first[u]; e != -1; e = edge[e].next)
		{
			int v = edge[e].v;
			if(belong[u] != belong[v])
			{
				outd[belong[u]]++;
				ind[belong[v]]++;
			}
		}
	}
	int s1 = 0, s2 = 0;
	for(int i = 1; i <= scnt; i++)
	{
		if(!ind[i]) s1++;
		if(!outd[i]) s2++;
	}
	if(scnt == 1)  { printf("0\n"); return ;}
	printf("%d\n", max(s1, s2));
}

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