ZOJ Monthly, June 2014——Grouping

题目连接

• 题意：

  n个点，m条边

  每条边两个整数a、b，表示a到b的有向边

  求，至少需要几个集合，使得：每个集合中的元素互相不能到达

  N(1≤ N≤
  100000), M(1≤ M≤
  300000)

• 分析：

  相连的两个点不能在同一个集合中，那么，对于一个长度为n的链，至少需要n个集合；如果链中有环，相当于把环展开，这个就需要缩点处理

  就是缩点之后求点权最长路

注意：模板中scc_cnt是从1开始的，如果使用缩点后的图，初始化时需要初始化总点数加一

因为总点数有限，用拓扑排序每次删除所有入度为零的点（缩后的点每次数量减一）

const int MAXN = 110000;

//使用时只更新G完成构图
//scc_cnt从1开始计数

//pre[]表示点在DFS树中的先序时间戳
//lowlink[]表示当前点和后代能追溯到的最早祖先的pre值
//sccno[]表示点所在的双连通分量编号
//vector<int> G保存每个点相邻的下一个点序号
//stack<Edge> S是算法用到的栈
const int MAXV = MAXN;

vector<int> G[MAXV];
int pre[MAXV], lowlink[MAXV], sccno[MAXV], dfs_clock, scc_cnt;
stack<int> S;

void init(int n)
{
    REP(i, n) G[i].clear();
}

void dfs(int u)
{
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v])
        {
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if(lowlink[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}

void find_scc(int n)
{
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for(int i = 0; i < n; i++)
        if(!pre[i]) dfs(i);
};

int ideg[MAXN];
int now;
queue<int> q[2];
vector<int> g[MAXN];
int a[3 * MAXN], b[3 * MAXN], num[MAXN];

int main()
{
//    freopen("in.txt", "r", stdin);
    int n, m;
    while (~RII(n, m))
    {
        CLR(ideg, 0);
        CLR(num, 0);
        now = 0;
        init(n);
        REP(i, n + 1) g[i].clear();

        REP(i, m)
        {
            RII(a[i], b[i]);
            G[a[i] - 1].push_back(b[i] - 1);
        }
        find_scc(n);
        REP(i, m)
        {
            int u = sccno[a[i] - 1], v = sccno[b[i] - 1];
            if (u == v)
                continue;
            g[u].push_back(v);
            ideg[v]++;
        }
        REP(i, n)
            num[sccno[i]]++;
        FE(i, 1, scc_cnt)
        {
            if (ideg[i] == 0)
                q[now].push(i);
        }
        int ans = 0;
        while (!q[now].empty())
        {
            ans++;
            while (!q[now].empty())
            {
                int t = q[now].front();
                q[now].pop();
                if (--num[t] == 0)
                {
                    REP(i, g[t].size())
                    {
                        int v = g[t][i];
                        if (--ideg[v] == 0)
                            q[now ^ 1].push(v);
                    }
                }
                else
                    q[now ^ 1].push(t);
            }
            now ^= 1;
        }
        WI(ans);
    }
    return 0;
}

正常的思路，DAG上的DP（记忆化搜索）：

const int MAXN = 110000;

//使用时只更新G完成构图
//scc_cnt从1开始计数

//pre[]表示点在DFS树中的先序时间戳
//lowlink[]表示当前点和后代能追溯到的最早祖先的pre值
//sccno[]表示点所在的双连通分量编号
//vector<int> G保存每个点相邻的下一个点序号
//stack<Edge> S是算法用到的栈
const int MAXV = MAXN;

vector<int> G[MAXV];
int pre[MAXV], lowlink[MAXV], sccno[MAXV], dfs_clock, scc_cnt;
stack<int> S;

void init(int n)
{
    REP(i, n) G[i].clear();
}

void dfs(int u)
{
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            dfs(v);
            lowlink[u] = min(lowlink[u], lowlink[v]);
        }
        else if(!sccno[v])
        {
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if(lowlink[u] == pre[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top();
            S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}

void find_scc(int n)
{
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for(int i = 0; i < n; i++)
        if(!pre[i]) dfs(i);
};

int ideg[MAXN];
int now;
queue<int> q[2];
vector<int> g[MAXN];
int a[3 * MAXN], b[3 * MAXN], num[MAXN];
int val[MAXN];

int d(int u)
{
    if (val[u])
        return val[u];
    int ret = 0;
    REP(i, g[u].size())
    {
        int v = g[u][i];
        ret = max(ret, d(v));
    }
    return val[u] = ret + num[u];
}

int main()
{
//    freopen("in.txt", "r", stdin);
    int n, m;
    while (~RII(n, m))
    {
        CLR(ideg, 0);
        CLR(val, 0);
        CLR(num, 0);
        now = 0;
        init(n);
        REP(i, n + 1) g[i].clear();

        REP(i, m)
        {
            RII(a[i], b[i]);
            G[a[i] - 1].push_back(b[i] - 1);
        }
        find_scc(n);
        REP(i, m)
        {
            int u = sccno[a[i] - 1], v = sccno[b[i] - 1];
            if (u == v)
                continue;
            g[u].push_back(v);
            ideg[v]++;
        }
        REP(i, n)
            num[sccno[i]]++;
        FE(i, 1, scc_cnt)
        {
            if (ideg[i] == 0)
                g[0].push_back(i);
        }
        WI(d(0));
    }
    return 0;
}

ZOJ Monthly, June 2014——Grouping