hdu 3313  求两点…

给出一个有向图 ， 点数n <= 100000 ， 边数m <= 300000 , 求 s 到 t之间的割点？

解法：先求出s 到 t之间的最短路径 ， 我们可以确定 ， s 到 t之间的所有割点 ， 肯定包含在这条最短路径上 ， 我们再判断这条最短路径上的所有点 ， 是不是割点。

判断点是不是割点时 ， 我们只需要判断这个点是不是可以从其他路径到达 ， 那么我们就能用bfs ， 从s开始遍历 ， 如果遇到了最短路径上的点 ， 我们就不压入队列中 ， 当队列为空 ， 别且没有到达 t 时 ， 这时候割点就增加了一个 ， 然后再从当前点进行bfs ， 直至到达终点 t。

代码：
#include
#include
#include
#include
#include
using namespace std;

#define maxn 100100
#define min(x , y) (x)<(y)?(x):(y)

struct node
{
      int u;
      int next;
}grap[maxn*3];

int n , m , s , t;
int dist[maxn] , path[maxn];
int low[maxn];
int pre[maxn];
int head[maxn];


void init()
{
      for(int i=0;i<=n;i++)
      {
              dist[i]=low[i]=0;
              head[i]=-1;
      }
           
}

void bfs_path()
{
      queueq;
      q.push(s);
      path[s] = -1;
      dist[s] = 1;
      int i;
      while(!q.empty())
      {
            int u = q.front();  q.pop();
            for(i = head[u]; i != -1; i = grap[i].next)
            {
                  int v = grap[i].u;
                  if(!dist[v])
                  {
                        dist[v] = 1;
                        path[v] = u;
                        if(v == t)  return ;
                        q.push(v);
                       
                  }
            }
      }

}

int bfs2(int u)
{
      queueq;
      q.push(u);

      int i , res = u;

      pre[u] = 1;

      while(!q.empty())
      {
            u = q.front(); q.pop();
            for(i = head[u]; i != -1; i = grap[i].next)
            {
                  int e = grap[i].u;
                  if(!pre[e])
                  {
                        pre[e] = 1;
                        if(low[e] == 0)  q.push(e);
                        else if(low[res] > low[e])  res = e;
                  }
            }
      }

      return res;
}

int main()
{
      while(scanf("%d %d" , &n , &m) != EOF)
      {
            init();
            int i , x , y , k = 0;
            for(i = 0; i < m; i++)
            {
                  scanf("%d %d" , &x , &y);
                  grap[k].u = y;
                  grap[k].next = head[x];
                  head[x] = k++;
            }

            scanf("%d %d" , &s , &t);

            if(n == 0 || n == 1)
            {
                  cout<<n<<endl;
                  continue;
            }

            bfs_path();

            if(dist[t] == 0)
            {
                  cout<<n<<endl;
                  continue;
            }
           
            i = t;
            int top = 1;
            while(path[i] != -1)
            {
                  low[i] = top++;
                  i = path[i];
            }
            low[s] = top;

            int sum = 1;

            i = s;
            memset(pre,  0 , sizeof(pre));
            while(i != t)
            {
                  i = bfs2(i);
                  sum += 1;
            }

            cout<<sum<<endl;

      }
      return 0;
}