$f(i,G)_{x}$为$x$对$i$是否有贡献，即在枚举到$x$时，$i$与$x$是否强连通
事实上，$f(i,G)_{x}=1$即不经过$[1,x)$中的点且$i$与$x$强连通
首先，当存在这样的路径，即使$[1,x)$中的点全部删除两者也仍然强连通（有贡献）
同时，若不存在这样的路径，考虑任意两条$i$到$x$和$x$到$i$的路径$P_{1}$和$P_{2}$，对于$P_{1}$和$P_{2}$中编号最小的点$y$，即证明若$y<x$，则其在枚举到$x$时必然被删去
不妨假设$y$在$P_{1}$中，当枚举到$y$时显然存在走$P_{1}$从$i$到$y$的路径，以及$y$到$i$的路径（先走$P_{1}$从$y$到$i$，再走$P_{2}$从$x$到$i$），那么$y$即会被删除
综上，也就证明了前面的结论
考虑对于确定的$i$和$x$，满足$f(i,G_{j})_{x}=1$的$j$必然是一个前缀，下面求出这个前缀——
令$d(i,x,y)$表示从$i$到$x$不经过$[1,y]$的所有路径中，经过的编号最小值的最大值，那么这个前缀的范围即$[0,min(d(i,x,x-1),d(x,i,x-1)))$，差分统计即可
（特别的，为了方便，定义$d(i,i,x)$为$m+1$）
下面考虑如何求出$d(i,x,y)$，显然其与最短路类似，且定义又与Floyd的过程相同，即从大到小枚举中转点来转移即可，复杂度为$o(n^{3}+m)$
也可以暴力计算，即枚举$x$并删去这些点，以$x$为起点对原图和反图分别求一次，同样可以用dijkstra等最短路算法，即可做到$o(nmlog n)$的复杂度
上述两种算法复杂度并不正确，但常数优秀都可以通过
下面给出两份被卡常数的代码，分别是44（Floyd）和80（Dijkstra）
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 1005 4 #define M 300005 5 int n,m,x,y,tot[M],f[N][N]; 6 int main(){ 7 scanf("%d%d",&n,&m); 8 memset(f,-1,sizeof(f)); 9 for(int i=1;i<=n;i++)f[i][i]=m+1; 10 for(int i=1;i<=m;i++){ 11 scanf("%d%d",&x,&y); 12 f[x][y]=i; 13 } 14 for(int i=n;i;i--){ 15 for(int j=1;j<=n;j++) 16 for(int k=1;k<=n;k++) 17 if ((f[j][i]>0)&&(f[i][k]>0))f[j][k]=max(f[j][k],min(f[j][i],f[i][k])); 18 for(int j=i;j<=n;j++) 19 if ((f[i][j]>0)&&(f[j][i]>0))tot[min(f[i][j],f[j][i])-1]++; 20 } 21 for(int i=m;i;i--)tot[i-1]+=tot[i]; 22 for(int i=0;i<=m;i++)printf("%d ",tot[i]); 23 }
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 1005 4 #define M 200005 5 struct Edge{ 6 int nex,to,len; 7 }edge[M<<1]; 8 priority_queue<pair<int,int> >q; 9 int E,n,m,x,y,head[2][N],d[2][N],vis[N],tot[M]; 10 void add(int p,int x,int y,int z){ 11 edge[E].nex=head[p][x]; 12 edge[E].to=y; 13 edge[E].len=z; 14 head[p][x]=E++; 15 } 16 void calc(int p,int st){ 17 memset(d[p],-1,sizeof(d[p])); 18 memset(vis,0,sizeof(vis)); 19 d[p][st]=m+1; 20 q.push(make_pair(d[p][st],st)); 21 while (!q.empty()){ 22 int k=q.top().second; 23 q.pop(); 24 if (vis[k])continue; 25 vis[k]=1; 26 for(int i=head[p][k];i!=-1;i=edge[i].nex) 27 if ((edge[i].to>=st)&&(d[p][edge[i].to]<min(d[p][k],edge[i].len))){ 28 d[p][edge[i].to]=min(d[p][k],edge[i].len); 29 q.push(make_pair(d[p][edge[i].to],edge[i].to)); 30 } 31 } 32 } 33 int main(){ 34 scanf("%d%d",&n,&m); 35 memset(head,-1,sizeof(head)); 36 for(int i=1;i<=m;i++){ 37 scanf("%d%d",&x,&y); 38 add(0,x,y,i); 39 add(1,y,x,i); 40 } 41 for(int i=1;i<=n;i++){ 42 calc(0,i),calc(1,i); 43 for(int j=i;j<=n;j++) 44 if ((d[0][j]>0)&&(d[1][j]>0))tot[min(d[0][j],d[1][j])-1]++; 45 } 46 for(int i=m;i;i--)tot[i-1]+=tot[i]; 47 for(int i=0;i<=m;i++)printf("%d ",tot[i]); 48 }
事实上，还可以做到更优秀的复杂度，回到最初的结论
考虑先枚举$x$，并倒序加边，之后维护有多少个点$i$与$x$强连通即可
强连通即分为两部分，即$x$能到达$i$与$i$能到达$x$，且对于每一个具有单调性，即至多修改一次，因此只需要每一次能够快速找到修改的点即可（以下先考虑前者）
假设加入边$(a,b)$，若$a<x$或$b<x$显然无意义，否则分类讨论：
1.若$x$不能到达$a$或$x$能到达$b$，即目前不影响答案，但其会在以后影响答案，即加入边集
2.若$x$能到达$a$但不能到达$b$，从$b$开始dfs搜索，且在经过一条边后删除其
（关于这一做法的正确性：当一条边被经过后，若其内部没有加边显然没有再搜索的意义，而加边不妨直接对其子树内部搜索即可）
对于$i$能否到达$x$，对其反图做同样的过程即可
此时，对于每一条边仅被搜索一次，复杂度即为$o(nm)$，可以通过
另外由于常数问题，建议使用bfs，且这份代码也只能在洛谷上通过（常数问题）
1 #include<bits/stdc++.h> 2 using namespace std; 3 #define N 1005 4 #define M 200005 5 struct Edge{ 6 int nex,to,len; 7 }edge[M<<1]; 8 priority_queue<pair<int,int> >q; 9 int E,n,m,x,y,head[2][N],d[2][N],vis[N],tot[M]; 10 void add(int p,int x,int y,int z){ 11 edge[E].nex=head[p][x]; 12 edge[E].to=y; 13 edge[E].len=z; 14 head[p][x]=E++; 15 } 16 void calc(int p,int st){ 17 memset(d[p],-1,sizeof(d[p])); 18 memset(vis,0,sizeof(vis)); 19 d[p][st]=m+1; 20 q.push(make_pair(d[p][st],st)); 21 while (!q.empty()){ 22 int k=q.top().second; 23 q.pop(); 24 if (vis[k])continue; 25 vis[k]=1; 26 for(int i=head[p][k];i!=-1;i=edge[i].nex) 27 if ((edge[i].to>=st)&&(d[p][edge[i].to]<min(d[p][k],edge[i].len))){ 28 d[p][edge[i].to]=min(d[p][k],edge[i].len); 29 q.push(make_pair(d[p][edge[i].to],edge[i].to)); 30 } 31 } 32 } 33 int main(){ 34 scanf("%d%d",&n,&m); 35 memset(head,-1,sizeof(head)); 36 for(int i=1;i<=m;i++){ 37 scanf("%d%d",&x,&y); 38 add(0,x,y,i); 39 add(1,y,x,i); 40 } 41 for(int i=1;i<=n;i++){ 42 calc(0,i),calc(1,i); 43 for(int j=i;j<=n;j++) 44 if ((d[0][j]>0)&&(d[1][j]>0))tot[min(d[0][j],d[1][j])-1]++; 45 } 46 for(int i=m;i;i--)tot[i-1]+=tot[i]; 47 for(int i=0;i<=m;i++)printf("%d ",tot[i]); 48 }