最大半连通子图 bzoj 1093

最大半连通子图

【问题描述】

一个有向图G = (V,E)称为半连通的(Semi-Connected)，如果满足：∀ u, v ∈V，满足u—>v 或 v —> u，即对于图中任意两点u,v, 存在一条u到v的有向路径或者从v到u的有向路径。

若满足，则称G’是G的一个导出子图。

若G’是G的导出子图，且G’半连通，则称G’为G的半连通子图。

若G’是G所有半连通子图中包含节点数最多的，则称G’是G的最大半连通子图。

给定一个有向图G，请求出G的最大半连通子图拥有的节点数K，以及不同的最大半连通子图的数目C。由于C可能比较大，仅要求输出C对X的余数。

【输入文件】

第一行包含两个整数N，M，X。N，M分别表示图G的点数与边数，X的意义如上文所述。接下来M行，每行两个正整数a, b，表示一条有向边(a, b)。图中的每个点将编号为1,2,3…N，保证输入中同一个(a,b)不会出现两次。

【输出文件】

应包含两行，第一行包含一个整数K。第二行包含整数C Mod X.

【样例输入】

6 6 20070603

1 2

2 1

1 3

2 4

5 6

6 4

【样例输出】

3

3

【数据规模】

对于20%的数据， N ≤ 18；

对于60%的数据， N ≤ 10000；

对于100%的数据， N ≤ 100000, M ≤ 1000000；

对于100%的数据， X ≤ 10⁸。

---

题解：

首先用Tarjon缩点，去重连边，得到新图，那么题目就变成了求图中最长链及最长链个数

最长链可以直接用拓扑排序

最长链个数用一个类似递推的方法

记录每一个点的方案数

那么当前点的方案数就等于连到此点且满足距离相等的点的方案数之和

最后查找距离等于最长链的点，答案为它们的方案数之和

 #include<algorithm>
 #include<iostream>
 #include<cstdlib>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 using namespace std;
 inline int Get()
 {
     int x = ;
     char c = getchar();
     while('' > c || c > '') c = getchar();
     while('' <= c && c <= '')
     {
         x = (x << ) + (x << ) + c - '';
         c = getchar();
     }
     return x;
 }
 const int me = ;
 int n, m, mo;
 int x[me], y[me];
 int tot;
 int de[me], to[me], fir[me], nex[me];
 int ue[me];
 int si[me];
 inline void Ins(int x, int y)
 {
     nex[++tot] = fir[x];
     fir[x] = tot;
     to[tot] = y;
 }
 int num, top, col;
 int ti[me], lo[me], st[me], co[me];
 inline void Tarjan(int u)
 {
     ti[u] = lo[u] = ++num;
     st[++top] = u;
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = to[i];
         if(!ti[v])
         {
             Tarjan(v);
             lo[u] = min(lo[u], lo[v]);
         }
         else
             if(!co[v])
                 lo[u] = min(lo[u], ti[v]);
     }
     if(lo[u] == ti[u])
     {
         co[u] = ++col;
         ++si[col];
         while(st[top] != u)
         {
             ++si[col];
             co[st[top]] = col;
             --top;
         }
         --top;
     }
 }
 int t, w;
 int ans;
 int e[me];
 int dis[me];
 inline bool rule(int a, int b)
 {
     if(x[a] != x[b]) return x[a] < x[b];
     return y[a] < y[b];
 }
 int nu[me];
 inline void Remove()
 {
     for(int i = ; i <= m; ++i)
     {
         nu[i] = i;
         x[i] = co[x[i]];
         y[i] = co[y[i]];
     }
     sort(nu + , nu +  + m, rule);
 }
 inline void Build()
 {
     tot = ;
     memset(fir, , sizeof(fir));
     for(int i = ; i <= m; ++i)
     {
         int z = nu[i];
         if((x[z] != y[z]) && (x[z] != x[nu[i - ]] || y[z] != y[nu[i - ]]))
         {
             ++de[y[z]];
             Ins(x[z], y[z]);
         }
     }
 }
 inline void Reset()
 {
     for(int i = ; i <= col; ++i)
         if(!de[i])
         {
             ue[++w] = i;
             dis[i] = si[i];
             e[i] = ;
             if(dis[ans] < dis[i]) ans = i;
         }
 }
 inline void Topo()
 {
     while(t < w)
     {
         int u = ue[++t];
         for(int i = fir[u]; i; i = nex[i])
         {
             int v = to[i];
             --de[v];
             if(dis[v] < dis[u] + si[v])
             {
                 dis[v] = dis[u] + si[v];
                 e[v] = ;
                 if(dis[ans] < dis[v]) ans = v;
             }
             if(dis[v] == dis[u] + si[v])
                 e[v] = (e[v] + e[u]) % mo;
             if(!de[v]) ue[++w] = v;
         }
     }
 }
 int anss;
 inline void Ask()
 {
     for(int i = ; i <= n; ++i)
         if(dis[i] == dis[ans])
             anss = (anss + e[i]) % mo;
 }
 int main()
 {
     n = Get(), m = Get(), mo = Get();
     for(int i = ; i <= m; ++i)
     {
         x[i] = Get(), y[i] = Get();
         Ins(x[i], y[i]);
     }
     for(int i = ; i <= n; ++i)
         if(!ti[i])
             Tarjan(i);
     Remove();
     Build();
     Reset();
     Topo();
     Ask();
     printf("%d\n%d", dis[ans], anss);
 }