ZOJ-3795-Grouping 解题报告

       强连通分量缩点+DP优化求关键路径题。题意：浙大有N个人，他们的年龄都不知道。我们有一些有关他们年龄的信息。第i个信息表示Si的年龄不小于Ti。现在我们要把这N个人分成若干个组。要求每个组中的任意两个人都不能被直接或者间接的比较出年龄的大小关系。求最少可以把这N个人分成多少个组。

       我的解题思路：首先该图为有向图，将人看做点，年龄关系看做边。同一个强连通分量里面的任意两点都不能被分到一个组里，因为很明显任意两点之间的大小关系都可以比较出来。将强连通分量缩点成强连通分量图后每一个强连通分量的点权设为该强连通分量的点数。那么答案就是强连通分量图中关键路径上的点权之和，这个关键路径其实就是点权最大的一条路径，或者称为最长路。很明显一条路径中任意两点都不能被分成一组，因为他们的关系是确定的。比如A大于B，B大于C，A大于D，D大于C，A明显大于C，但是B与D的大小却无法比较出来，因此B与D可以被分成同一组。最后就是求这个强连通图的关键路径上的点权和了。注意：使用裸的DFS是会导致TLE的，因为多个路径的公有部分可能会被搜索多次，使用DP优化就可以避免了同一个点被DFS多次。

       我的解题代码：强连通分量Tarjan算法+缩点+DP优化

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 100001;

vector <int> e[N], scce[N];
int dfn[N], low[N];
int stack[N], stop;     //手写栈
bool instack[N];
int timer, sccn;        //时间戳与强连通分量个数
int belong[N];
bool vis[N];
int dp[N];              //以当前强连通分量为起点的路径最大权
int w[N];               //强连通分量权
int n, m;

void InitRead();

void DataProcess();

void Tarjan(int x);

void Dfs(int x);

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

void InitRead()
{
    stop = timer = sccn = 0;
    memset(dfn, 0, sizeof(dfn));
    memset(instack, false, sizeof(instack));
    memset(dp, 0, sizeof(dp));
    memset(vis, false, sizeof(vis));
    for (int i=1; i<=n; ++i)
    {
        e[i].clear();
        scce[i].clear();
    }
    int a, b;
    for (int i=0; i<m; ++i)
    {
        scanf("%d %d", &a, &b);
        e[a].push_back(b);
    }
    return;
}

void DataProcess()
{
    for (int i=1; i<=n; ++i)
    {
        if (!dfn[i]) Tarjan(i);
    }
    for (int i=1; i<=n; ++i)    //建强连通图
    {
        int size = e[i].size();
        for (int j=0; j<size; ++j)
        {
            if (belong[i] != belong[e[i][j]])
            {
                scce[belong[i]].push_back(belong[e[i][j]]);
            }
        }
    }
    int ans = 0;
    for (int i=1; i<=sccn; ++i)
    {
        if (!vis[i])
        {
            Dfs(i);
            ans = max(ans, dp[i]);
        }
    }
    printf("%d\n", ans);
    return;
}

void Tarjan(int x)
{
    int y;
    dfn[x] = low[x] = ++timer;
    stack[stop++] = x;
    instack[x] = true;
    int size = e[x].size();
    for (int i=0; i<size; ++i)
    {
        y = e[x][i];
        if (!dfn[y])
        {
            Tarjan(y);
            low[x] = min(low[x], low[y]);
        }
        else if (instack[y])
        {
            low[x] = min(low[x], dfn[y]);
        }
    }
    if (dfn[x] == low[x])
    {
        sccn++;
        int temp = 0;
        do
        {
            y = stack[--stop];
            instack[y] = false;
            belong[y] = sccn;
            temp++;
        } while (x != y);
        w[sccn] = temp;
    }
    return;
}

void Dfs(int x)
{
    int size = scce[x].size();
    if (0 == size) dp[x] = w[x];
    for (int i=0; i<size; ++i)
    {
        if (!vis[scce[x][i]])
        {
            Dfs(scce[x][i]);
        }
        dp[x] = max(dp[x], dp[scce[x][i]] + w[x]);
    }
    vis[x] = true;
    return;
}