hdu3639 Hawk-and-Chicken（Tarjan缩点+反图搜索）

http://acm.hdu.edu.cn/showproblem.php?pid=3639

题意：给你n个小孩和m个关系，关系中x, y代表x认为y受欢迎，欢迎度可传递，求最后最受欢迎的人有多少，并输出这些人。

ps：这题数组好多啊，要不是看题解我都晕了。。思路也比较杂，容易晕。

思路：首先用Tarjan找出强连通分量，将其缩点，这样把等价的点都缩为一个点，可以减少运算量。接着就是找出其中最受欢迎的点。这里我没有想到，别人说要建立反图。怎么建反图不重要，关键是为什么要建反图。刚开始我想成从最不受欢迎的人深搜求通过节点数最多的即为最受欢迎的人，后来想不是这样的。最受欢迎的人是所有能够到达他的人，这样的话就包含了好多路径。而且注意这是一个有向图，形象上比喻就是好多点汇聚而来，形成一个倒三角形。我们知道缩点后的DAG入度为0和出度为0的点都不止一个，那这样就转变为DAG正图(反图以前的图)中求能够汇聚到出度为0的点的最大汇聚数。这样的话正向搜索就办不到了，起点这个东西很重要，而将图反过来就可以将原先出度为0的点变为入度为0的点，这样搜索就方便将所有的汇聚度累加从而求得结果。其他的就是普通的Tarjan，不过要注意别搞混了。

下面上一张图，大概就是正图搜索与反图搜索的区别，正图为正三角，反图为反三角，前提是这图是有向图。

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

typedef long long LL;

const int N = 100010;
const int INF = 0x3f3f3f3f;

stack<int>S;

int dfn[N], low[N], head[N], head0[N], Belong[N], cost[N], in[N], num[N], save[N];
//save数组代表反图中入度为0的元素中保存的节点个数
int countt, time, n, m, pos, pos0;
bool instack[N], vis[N];

struct node
{
    int from, to, next;
}edge[N], edge0[N];

void add(int u, int v)
{
    edge[pos] = (struct node){u, v, head[u]};
    head[u] = pos++;
}

void add0(int u, int v)
{
    edge0[pos0] = (struct node){u, v, head0[u]};
    head0[u] = pos0++;
}

void init()
{
    time = countt = pos = pos0 = 0;
    memset(num, 0, sizeof(num));
    memset(dfn, 0, sizeof(dfn));
    memset(in, 0, sizeof(in));
    memset(low, 0, sizeof(low));
    memset(save, -1, sizeof(save));
    memset(head, -1, sizeof(head));
    memset(head0, -1, sizeof(head0));
    memset(instack, false, sizeof(instack));
}

void Tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++time;
    instack[u] = true;
    S.push(u);
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        v = edge[i].to;
        if(dfn[v] == 0)
        {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(instack[v] == 1)
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(dfn[u] == low[u])
    {
        countt ++;
        do
        {
            v = S.top();
            S.pop();
            instack[v] = false;
            Belong[v] = countt;
            num[countt]++;
        }while(u != v);
    }
}

int dfs(int u)
{
    vis[u] = true;
    int sum = num[u];
    for(int i = head0[u]; i != -1; i = edge0[i].next)
    {
        int v = edge0[i].to;
        if(!vis[v])
        {
            sum += dfs(v);
        }
    }
    return sum;
}

int main()
{
 //   freopen("in.txt", "r", stdin);
    int t, u, v, Case = 1;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        init();
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d", &u, &v);
            add(u, v);
        }
        //缩点、反向建图
        for(int i = 0; i < n; i++)
        {
            if(dfn[i] == 0)
                Tarjan(i);
        }
        for(u = 0; u < n; u++)
        {
            for(int i = head[u]; i != -1; i = edge[i].next)
            {
                v = edge[i].to;
                if(Belong[u] != Belong[v])
                {
                   add0(Belong[v], Belong[u]);
                   in[Belong[u]]++;
                }
            }
        }
        //遍历所有反图中入度为0的点
        int ans = -1;
        for(int i = 1; i <= countt; i++)
        {
            if(in[i] == 0)
            {
             //   printf("{%d}", i);
                memset(vis, false, sizeof(vis));
                save[i] = dfs(i);
            //    printf("[%d]\n", save[i]);
                ans = max(ans, save[i]);
            }
        }
        printf("Case %d: %d\n", Case++, ans-1);
        int flag = 1;
        for(int i = 0; i < n; i++)
        {
            if(save[Belong[i]] == ans)
            {
                if(flag == 1)
                {
                    printf("%d", i);
                    flag = 0;
                }
                else printf(" %d", i);
            }
        }
        printf("\n");
    }
    return 0;
}