Description

\(n\) 個別墅以及一個主建築樓，從每個別墅都有很多種不同方式走到主建築樓，其中不同的定義是（每條邊可以走多次，如果走邊的順序有一條不同即稱兩方式不同）。

詢問最多的不同方式是多少，以及有多少個別墅有這麽多方式，按照順序輸出別墅編號。

如果最多不同方式超過了 \(36500\) 那麽都視作 \(zawsze\)

Solution

因為統計其它 \(n\) 個點到主建築樓的方案數有點困難，我們轉化一下問題，反向建邊，變成求從主建築樓到其它 \(n\) 個點的方案數，這樣源點就只有一個了。

先 \(Tarjan\) 消環，然後拓撲求出從起點所在聯通塊到每個點所在聯通塊的方案數。註意到起點不一定是度數為零的點，所以不能直接將起點 \(push\)

還有要註意的是如果當前聯通塊有環並且能從起點走到該聯通塊的話，就應該讓起點到這個聯通塊的方案數等於 \(36501\)，然後繼續向下處理。（這裏特別要註意能否走到該聯通塊）

Code

#include<queue>
#include<vector>
#include<cstdio>
#include<cctype>
#include<algorithm>
#define N 1000005
#define min(A,B) ((A)<(B)?(A):(B))
 

#define max(A,B) ((A)>(B)?(A):(B))

int dis[N];
int deg[N];
int n,m,pos;
int sum,tot;
int print[N];
int belong[N];
int stk[N],top;
bool in[N],is[N];
int dfn[N],low[N];
int cnt,head[N],head2[N];
std::vector<int> v[N],vans;

struct Edge{
    int to,nxt;
}edge[N<<1],edge2[N<<1];

void
 
 add(int x,int y){
    edge[++cnt].to=y;
    edge[cnt].nxt=head[x];
    head[x]=cnt;
}

void add2(int x,int y){
    edge2[++cnt].to=y;
    edge2[cnt].nxt=head2[x];
    head2[x]=cnt;
}

int getint(){
    int x=0;char ch=getchar();
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    return x;
}

void tarjan(int now){
    dfn[now]=low[now]=++tot;
    stk[++top]=now,in[now]=1;
    for(int i=head[now];i;i=edge[i].nxt){
        int to=edge[i].to;
        if(!dfn[to]){
            tarjan(to);
            low[now]=min(low[now],low[to]);
        }
        else if(in[to])
            low[now]=min(low[now],dfn[to]);
    }
    if(low[now]==dfn[now]){
        int y; sum++;
        if(stk[top]!=now) is[sum]=1;
        do{
            y=stk[top--];
            v[sum].push_back(y);
            belong[y]=sum;
            in[y]=0;
        }while(y!=now);
    }
}

signed main(){
    n=getint(),m=getint();
    for(int i=1;i<=m;i++){
        int x=getint(),y=getint();
        add(y,x);
    }
    cnt=0;
    for(int i=1;i<=n+1;i++){
        if(!dfn[i])
            tarjan(i);
    }
    for(int x=1;x<=n+1;x++){
        for(int i=head[x];i;i=edge[i].nxt){
            int to=edge[i].to;
            if(belong[to]==belong[x]){
                is[belong[x]]=1;
                continue;
            }
            add2(belong[x],belong[to]);
            deg[belong[to]]++;
        }
    }
    std::queue<int> topo;
    for(int i=1;i<=sum;i++){
        if(!deg[i])
            topo.push(i);
    }
    dis[belong[n+1]]=1;
    while(topo.size()){
        int u=topo.front();topo.pop();
        if(is[u] and dis[u]) dis[u]=36501;
        for(int i=head2[u];i;i=edge2[i].nxt){
            int to=edge2[i].to;
            dis[to]=min(dis[to]+dis[u],36501);
            deg[to]--;
            if(!deg[to])
                topo.push(to);
        }
    }
    int ans=0;
    for(int i=1;i<=sum;i++){
        dis[i]=min(dis[i],36501);
        ans=max(ans,dis[i]);
    }
    if(ans==36501) printf("zawsze\n");
    else printf("%d\n",ans);
    for(int i=1;i<=n;i++){
        if(dis[belong[i]]==ans)
            print[++pos]=i;
    }
    printf("%d\n",pos);
    for(int i=1;i<=pos;i++)
        printf("%d ",print[i]);
    puts("");
    return 0;
}

[POI2006] PRO-Professor Szu