BZOJ1093 最大半连通子图

Description

　　一个有向图G=(V,E)称为半连通的(Semi-Connected)，如果满足：?u,v∈V，满足u→v或v→u，即对于图中任意
两点u，v,存在一条u到v的有向路径或者从v到u的有向路径。若G'=(V',E')满足V'?V，E'是E中所有跟V'有关的边，
则称G'是G的一个导出子图。若G'是G的导出子图，且G'半连通，则称G'为G的半连通子图。若G'是G所有半连通子图
中包含节点数最多的，则称G'是G的最大半连通子图。给定一个有向图G，请求出G的最大半连通子图拥有的节点数K
，以及不同的最大半连通子图的数目C。由于C可能比较大，仅要求输出C对X的余数。

Input

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

Output

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

Sample Input

6 6 20070603
1 2
2 1
1 3
2 4
5 6
6 4

Sample Output

3
3

 

正解：tarjan+DP

解题报告：

　　遥遥今天讲课讲了这道题，然后感觉这是最水的，就高兴地开了坑，调了半个晚上都没有发现为什么wa了。

　　最后发现居然是有重边！！！！！！然后方案重复计算了，但我当时没有马上想出怎么判重，于是看了网上的题解发现可以用set，我真傻真的。

　　做法其实挺简单，首先tarjan缩环，然后重构图，可以想到我们一定是在重构的图上选取一条链，使得链的点权和最大。DP可做。

 

 

//It is made by jump~
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#ifdef WIN32   
#define OT "%I64d"
#else
#define OT "%lld"
#endif
using namespace std;
typedef long long LL;
const int MAXN = 100011;
const int MAXM = 1000011;
int MOD;
int n,m,ecnt,ans,num;
int first[MAXN],to[MAXM],next[MAXM];
bool pd[MAXN];
int dfn[MAXN],low[MAXN];
int Stack[MAXN*2],top,belong[MAXN];
int size[MAXN],cnt;
int head[MAXN],ru[MAXN],f[MAXN];
bool vis[MAXN];

set<pair<int,int> >bst;//要有一个空格

struct edge{
    int v,next;
}e[MAXM];

inline int getint()
{
       int w=0,q=0;
       char c=getchar();
       while((c<'0' || c>'9') && c!='-') c=getchar();
       if (c=='-')  q=1, c=getchar();
       while (c>='0' && c<='9') w=w*10+c-'0', c=getchar();
       return q ? -w : w;
}

inline void dfs(int x){
    dfn[x]=++ecnt; low[x]=dfn[x];
    pd[x]=1; Stack[++top]=x;
    for(int i=first[x];i;i=next[i]) {
    int v=to[i];
    if(!dfn[v]) { dfs(v); if(low[v]<low[x]) low[x]=low[v]; }
    else if(pd[v]) low[x]=min(low[v],low[x]);
    }
    if(dfn[x]==low[x]){
    cnt++; size[cnt]++; belong[x]=cnt; pd[x]=0;
    while(Stack[top]!=x&&top) belong[Stack[top]]=cnt,pd[Stack[top]]=0,top--,size[cnt]++;
    top--;
    }
}

inline void tarjan(){
    ecnt=0;
    for(int i=1;i<=n;i++) if(!dfn[i]) dfs(i);
    ecnt=0;
    for(int i=1;i<=n;i++) {
    for(int j=first[i];j;j=next[j]) {
        int v=to[j];
        if(belong[i]!=belong[v]) {
        if(bst.find(make_pair(belong[i],belong[v]))!=bst.end()) continue;
        e[++ecnt].next=head[belong[i]]; head[belong[i]]=ecnt; e[ecnt].v=belong[v];
        ru[belong[v]]++;
        bst.insert(make_pair(belong[i],belong[v]));
        }
    }
    }
}

inline void DFS(int x){
    vis[x]=1;
    for(int i=head[x];i;i=e[i].next) {
    int v=e[i].v;
    if(!vis[v]) DFS(v);
    if(f[v]>f[x]) f[x]=f[v];
    }
    f[x]+=size[x];
}

inline void DFS2(int x){
    vis[x]=1;
    for(int i=head[x];i;i=e[i].next) {
    int v=e[i].v;
    if(!vis[v]) DFS2(v);
    //不能有重边！！！！！！
    if(f[x]==f[v]+size[x]) { dfn[x]+=dfn[v]; if(dfn[x]>=MOD) dfn[x]%=MOD; }
    }
    if(!head[x]) dfn[x]=1;
    if(f[x]==ans) { num+=dfn[x]; if(num>=MOD) num%=MOD; }
}

inline void DP(){    
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=cnt;i++) if(!ru[i]) DFS(i),ans=max(ans,f[i]);
    memset(vis,0,sizeof(vis));  memset(dfn,0,sizeof(dfn));
    for(int i=1;i<=cnt;i++) 
    if(!ru[i]) {
        DFS2(i);
    }
    printf("%d\n%d",ans,num);
}

inline void work(){
    n=getint(); m=getint(); MOD=getint();
    int x,y;
    for(int i=1;i<=m;i++) {
    x=getint(); y=getint();
    next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y; 
    }
    tarjan();
    DP();
}

int main()
{
  work();
  return 0;
}