Street Race

题意：不想写，摘抄NOCOW翻译（http://www.nocow.cn/index.php/Translate:USACO/race3）

描述

图一表示一次街道赛跑的跑道。可以看出有一些路口（用 0 到 N 的整数标号），和连接这些路口的箭头。路口 0 是跑道的起点，路口 N 是跑道的终点。箭头表示单行道。运动员们可以顺着街道从一个路口移动到另一个路口（只能按照箭头所指的方向）。当运动员处于路口位置时，他可以选择任意一条由这个路口引出的街道。

图一：有 10 个路口的街道 一个良好的跑道具有如下几个特点：

• 每一个路口都可以由起点到达。
• 从任意一个路口都可以到达终点。
• 终点不通往任何路口。
• 运动员不必经过所有的路口来完成比赛。有些路口却是选择任意一条路线都必须到达的（称为“不可避免”的）。在上面的例子中，这些路口是 0，3，6，9。对于给出的良好的跑道，你的程序要确定“不可避免”的路口的集合，不包括起点和终点。

假设比赛要分两天进行。为了达到这个目的，原来的跑道必须分为两个跑道，每天使用一个跑道。第一天，起点为路口 0，终点为一个“中间路口”；第二天，起点是那个中间路口，而终点为路口 N。对于给出的良好的跑道，你的程序要确定“中间路口”的集合。如果良好的跑道 C 可以被路口 S 分成两部分，这两部分都是良好的，并且 S 不同于起点也不同于终点，同时被分割的两个部分满足下列条件：（1）它们之间没有共同的街道（2）S 为它们唯一的公共点，并且 S 作为其中一个的终点和另外一个的起点。那么我们称 S 为“中间路口 ”。在例子中只有路口 3 是中间路口。

[编辑]格式

PROGRAM NAME: race3

INPUT FORMAT:

(file race3.in)

输入文件包括一个良好的跑道，最多有 50 个路口，100 条单行道。

一共有 N+2 行，前面 N+1 行中第 i 行表示以编号为(i-1)的路口作为起点的街道，每个数字表示一个终点。行末用 -2 作为结束。最后一行只有一个数字 -1。

OUTPUT FORMAT:

(file race3.out)

你的程序要有两行输出：

第一行包括：跑道中“不可避免的”路口的数量，接着是这些路口的序号，序号按照升序排列。

第二行包括：跑道中“中间路口”的数量，接着是这些路口的序号，序号按照升序排列。

[编辑]SAMPLE INPUT

1 2 -2
3 -2
3 -2
5 4 -2
6 4 -2
6 -2
7 8 -2
9 -2
5 9 -2
-2
-1

[编辑]SAMPLE OUTPUT

2 3 6
1 3

解题思路：

1. 用邻接表存储这张图
2. 不可避免的点求法：对每个点i = [1, N-1]，去掉点和与这个点相关的边，并且相应修改邻接表，然后从点0开始DFS，如果DFS完成后N没有被访问，则i是不可避免的点
3. 中间路口的求法：处理每个不可避免的点。对每个点i，首先去掉所有的“出边”，相应修改邻接表，然后从0开始DFS，用visited1[0...N]来保存每个节点被访问与否的情况（0表示未被访问，1表示被访问）。然后恢复邻接表，去掉所有的“入边”，相应修改邻接表，然后从i开始DFS，用visited2[0...N]来保存每个节点被访问的情况。将visited1和visited2各位相加，得到新的visited_split[0...N]，如果除了visited_split[i] = 2，其他都为1，则点i是中间路口

代码：

/*
ID: zc.rene1
LANG: C
PROG: race3
 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int N;
int matrix[50][51];
int matrix_cp[50][51];
int visited[50];
int stack[50];

int unavoidable_points[50];
int unavoidable_num;
int split_points[50];
int split_num;

int GetInput(FILE *fin)
{
    int i;
    int num = 0;

    memset(matrix, 0, 50 * 51 * sizeof(int));
    i = 0;

    while (num != -1)
    {
	fscanf(fin, "%d", &num);
	if (num != -2)
	{
	    matrix[i][0]++;
	    matrix[i][matrix[i][0]] = num;
	}
	else
	{
	    i++;
	}
    }
    return i-1;
}

void ChangeMatrix(int point)
{
    int i, j;

    memcpy(matrix_cp, matrix, 50 * 51 * sizeof(int));

    for (i=0; i<=N; i++)
    {
	if (i == point)
	{
	    matrix_cp[i][0] = 0;
	    continue;
	}
	for (j=1; j<=matrix_cp[i][0]; j++)
	{
	    if (matrix_cp[i][j] == point)
	    {
		matrix_cp[i][j] = -1;
	    }
	}
    }
}

void DFS(int source)
{
    int bottom = -1, top = -1;
    int current_node, next_node, i;

    memset(visited, 0, 50 * sizeof(int));
    stack[++top] = source;

    while (bottom < top)
    {
	current_node = stack[top--];
	visited[current_node] = 1;

	for (i=1; i<=matrix_cp[current_node][0]; i++)
	{
	    next_node = matrix_cp[current_node][i];
	    if (next_node != -1 && visited[next_node] == 0)
	    {
		stack[++top] = next_node;
	    }
	}
    }
}

void GetUnavoidable(void)
{
    int i;

    unavoidable_num = 0;

    for (i=1; i<N; i++)
    {
	ChangeMatrix(i);
	DFS(0);
	if (visited[N] == 0)
	{
	    unavoidable_points[unavoidable_num++] = i;
	}
    }
}

int IsSplit(int *visited_split, int point)
{
    int i;

    if (visited_split[point] != 2)
    {
	return 0;
    }

    for (i=0; i<=N; i++)
    {
	if (i != point)
	{
	    if (visited_split[i] != 1)
	    {
		return 0;
	    }
	}
    }

    return 1;
}

void GetSplit(void)
{
    int i, j, k, point;
    int visited_split[50];

    split_num = 0;
    memset(visited_split, 0, 50 * sizeof(int));

    for (i=0; i<unavoidable_num; i++)
    {
	point = unavoidable_points[i];
	memcpy(matrix_cp, matrix, 50 * 51 * sizeof(int));
	matrix_cp[point][0] = 0;
	DFS(0);
	memcpy(visited_split, visited, 50 * sizeof(int));

	memcpy(matrix_cp, matrix, 50 * 51 * sizeof(int));
	for (j=0; j<=N; j++)
	{
	    if (j != point)
	    {
		for (k=1; k<=matrix_cp[j][0]; k++)
		{
		    if (matrix_cp[j][k] == point)
		    {
			matrix_cp[j][k] = -1;
		    }
		}
	    }
	}
	DFS(point);
	for (j=0; j<=N; j++)
	{
	    visited_split[j] += visited[j];
	}
	
	if (IsSplit(visited_split, point))
	{
	    split_points[split_num++] = point;
	}
    }
}

int main(void)
{
    FILE *fin, *fout;
    int i;

    fin = fopen("race3.in", "r");
    fout = fopen("race3.out", "w");

    N = GetInput(fin);
    GetUnavoidable();
    GetSplit();
    
    fprintf(fout, "%d", unavoidable_num);
    for (i=0; i<unavoidable_num; i++)
    {
	fprintf(fout, " %d", unavoidable_points[i]);
    }
    fprintf(fout, "\n%d", split_num);
    for (i=0; i<split_num; i++)
    {
	fprintf(fout, " %d", split_points[i]);
    }
    fprintf(fout, "\n");
    return 0;
}