Almost Acyclic Graph（【CodeForces】915 D）

【题意】n个点m条边，判断是否可以通过删除一条边使整个图不存在环。

【题解】看到题目的第一反应是Tarjan求强连通，求完强连通后，假如存在两个及以上的强连通分量中存在两个点以上，肯定是不行的。因为一个强连通分量中如果点数大于1肯定存在环，存在多个环一定是不能通过删除一条边解决的。然后对于只有一个强连通分量里面有一大堆的情况分析，可能这一个分量中存在的环不能通过删除一条边解决也可能可以，我当时的想法是对于强连通中任取一个点连到超级源点，与这个点直接相连的点都连到一个超级汇点，并且删除他们和选择的点的边，其他边不变，流量设为1，然后跑网络流，复杂度应该是可以的，正确性未知，但是代码量决定是爆炸多的。然后被队友指点，发现对强连通中的任意一个环枚举每一条边，每一次都再跑一次Tarjan重新判断复杂度也是在时间要求之内的。

代码：

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <algorithm>
#include <queue>
using namespace std;

#define LL long long
const int Max = 1e5 + 100;
const int MAXN=20010;
const int MAXM=100010;
struct Edge{
    int to, next;
}edge[MAXM];
int head[MAXN], tot;
bool vis[Max];
pair<int, int>data[MAXM];
int Low[MAXN], DFN[MAXN], Stack[MAXN],Belong[MAXN] , pres[MAXN];;
int Index, top;
int scc;
bool Instack[MAXN];
int num[MAXN];
void addedge(int u, int v){
    edge[tot].to =v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void Tarjan(int u, int s, int t){//s t是标记一条边，用于枚举用
    int v;
    Low[u]=DFN[u]=++Index;
    Stack[top++]=u;
    Instack[u]=true;
    for(int i=head[u]; i!=-1;i=edge[i].next){
        v=edge[i].to;
        if(u==s&&v==t)continue;
        if(!DFN[v]){
            Tarjan(v, s, t);
            if(Low[u]>Low[v])Low[u]=Low[v];
        }
        else if(Instack[v]&&Low[u]>DFN[v])Low[u]=DFN[v];
    }
    if(Low[u]==DFN[u]){
        scc++;
        do{
            v=Stack[--top];
            Instack[v]=false;
            Belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}
void solve(int N, int s, int t){
    memset(DFN, 0, sizeof(DFN));
    memset(Instack, false, sizeof(Instack));
    memset(num, 0, sizeof(num));
    Index=scc=top=0;
    for(int i=1; i<=N; i++)if(!DFN[i])Tarjan(i, s, t);
}
void init(){
    tot=0;
    memset(pres, -1, sizeof(pres));
    memset(head, -1, sizeof(head));
}
int get_num(){
    for(int a=0; a<=scc; a++){
        if(num[a]>=2)return a;
    }
    return 0;
}

void DFS(int t, int now){
    for(int i=head[now]; i!=-1; i=edge[i].next){
        int v=edge[i].to;
        if(!vis[v]){
                vis[v]=1;
                pres[v]=now;
                DFS(t, v);
        }
        else if(v==t)pres[v]=now;
    }
}
int len;
void get_edge(int t, int u){
    data[len++]=make_pair(pres[u], u);
    if(pres[u]==t)return;
    get_edge(t, pres[u]);
}
int main(){
    int n, m;
    init();
    scanf("%d%d", &n, &m);
    for(int a=0; a<m; a++){
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
    }
    solve(n, 0, 0);
    int sum=0;
    for(int a=0; a<=scc; a++)if(num[a]>=2)sum++;
    if(sum>1)printf("NO\n");
    else if(sum==0)printf("YES\n");
    else {
        int x=get_num();
        len=0;
        for(int a=1; a<=n; a++){
            if(Belong[a]==x){
                DFS(a, a);
                get_edge(a, a);
                break;
            }
        }
        for(int a=0; a<len; a++){
            solve(n, data[a].first, data[a].second);
            int b;
            for(b=0; b<=scc; b++)if(num[b]>=2)break;
            if(b==scc+1){
                printf("YES\n");
                return 0;
            }
        }
        printf("NO\n");
    }
    return 0;
}