图

给你一个有向图，并指定起点为1和终点为2。问要从起点走向终点，再从终点走向起点，最少需要走过多少不同的节点。

考虑动归
在这种图上，要注意可以用spfa来转移
构出反图，原问题变成了正图从st到end，与反图st到end最少能经过几个城市。
令f[i][j] 为正图走到i，反图走到j的最小答案。
spfa每次正图走一步，反图走一步，松弛操作更新f。
但是这样是不够的，考虑到i，j如果交换了，答案会多算1。
于是我们特判下这特殊情况即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>

using namespace std ;

#define N 110
#define M 220
#define psb( x ) push_back( x ) 

vector< int > E[N],iE[N] ;

int i , j , k , m , n ;

void ins( int x , int y ) {
    E[x].psb( y ) , iE[y].psb( x ) ;
}

int dis[N][N] ;

int min( int x , int y ) {
    return x < y ? x : y ;
}

void FLOYD() {
    int i , j , k ;
    for( k=1 ; k<=n ; k++ ) {
        for( i=1 ; i<=n ; i++ ) {
            for( j=1 ; j<=n ; j++ ) {
                if( dis[k][j]==-1 || dis[i][k]==-1 ) continue ;
                dis[i][j] = min( dis[i][k] + dis[k][j] , dis[i][j] ) ;
            }
        }
    }
}

struct Queue {
    int x , y ;
}q[2*N*N] ;

int f[N][N] ;

bool v[N][N] ;

void SPFA( int st ) {
    int l=0 , r=1 ;
    q[r].x = 1 , q[r].y = 1 ;
    f[1][1] = 1 ;
    while( l!=r ) {
        if( ++l>N*N-2 ) l = 1 ;
        int va =  f[ q[l].x ][ q[l].y ]  ;
        for( int nx = 0 ; nx<E[ q[l].x ].size() ; nx ++ ) {
            int _x = E[ q[l].x ][nx] ;
            if( va + ( q[l].y!=_x ) < f[_x][ q[l].y ] || f[_x][ q[l].y ]==-1 ) {
                f[_x][ q[l].y ] = va + ( q[l].y!=_x ) ;
                if( v[_x][ q[l].y ] == 0 ) {
                    if( ++r > N*N-2 ) r = 1 ;
                    v[_x][ q[l].y ] = 1 ;
                    q[r].x = _x , q[r].y = q[l].y ;
                }
            }
        }
        for( int inx = 0 ; inx<iE[ q[l].y ].size() ; inx ++ ) {
            int _y = iE[ q[l].y ][inx] ;
            if( va + ( q[l].x!=_y ) < f[ q[l].x ][_y] || f[ q[l].x ][_y]==-1 ) {
                f[ q[l].x ][_y] = va + ( q[l].x!=_y ) ;
                if( v[ q[l].x ][_y] == 0 ) {
                    if( ++r > N*N-2 ) r = 1 ;
                    v[ q[l].x ][_y] = 1 ;
                    q[r].x = q[l].x , q[r].y = _y ;
                }
            }
        }
        if( q[l].x != q[l].y && va + dis[ q[l].x ][ q[l].y ] - 1 < f[ q[l].y ][ q[l].x ] ) {
            f[ q[l].y ][ q[l].x ] = va + dis[ q[l].x ][ q[l].y ] - 1 ;
            if( v[ q[l].y ][ q[l].x ] == 0 ) {
                v[ q[l].y ][ q[l].x ] = 1 ;
                if( ++r>N*N-2 )  r = 1 ;
                q[r].x = q[l].y , q[r].y = q[l].x ;
            }
        }
        v[ q[l].x ][ q[l].y ] = 0 ;
    }
}

int main() {
    scanf("%d%d",&n,&m ) ;
    memset( dis , 27 , sizeof dis ) ;
    for( i=1 ; i<=m ; i++ ) {
        int x , y ;
        scanf("%d%d",&x,&y ) ;
        ins( x , y ) ;
        dis[x][y] = 1 ;
    }
    for( i=1 ; i<=n ; i++ ) dis[i][i] = 0 ;
    FLOYD() ;
    memset( f , 27 , sizeof f ) ;
    SPFA( 1 ) ;
    printf("%d\n",f[2][2] ) ;
}