HDU 2433 (最短路+BFS+剪枝)

http://acm.hdu.edu.cn/showproblem.php?pid=2433

这个问题因为路径都是1，所以可以用bfs遍历

可以看这几篇文章讲解：

http://blog.csdn.net/panyanyany/article/details/7215069

（这篇代码非常清晰，而且效率很高）

http://www.cppblog.com/keroro/archive/2013/05/27/200622.html?opt=admin

 #include <cstdio>
 #include <queue>
 #include <vector>
 using namespace std;

 #define MEM(a,v) memset (a,v,sizeof(a))
 // a for address, v for value

 #define max(x,y) ((x)>(y)?(x):(y))
 #define max(x,y) ((x)>(y)?(x):(y))

 const int L = ;
 const int INF = <<;

 bool    used[L], bCnet, bInit ;
 int     n, m ;
 int     dist[L], map[L][L], sum_d[L], pre[L][L];

 //边表
 struct Edge
 {
           int u,v;
 };

 Edge e[*L];

 int bfs(int beg)
 {
           MEM(used,false);
           MEM(dist,);

           used[beg] = true;

           queue<int> q;
           q.push(beg);

           int i;

           while(!q.empty())
           {
                     int t = q.front();
                     q.pop();
                     for(i = ;i<=n;i++)
                     {
                               if(!used[i] && map[t][i])
                               {
                                         used[i] = true;
                                         dist[i] = dist[t]+;

                                         //初始化    bInit =true
                                         //初始化后  bfs = false
                                         if(bInit)
                                                   pre[beg][i] = t;
                                         //pre储存的是beg树里面，i的上一个元素
                                         //这样只需判断pre[x][u] ==v 和pre[x][v] == u
                                         //就可以知道x树里面有没有uv边

                                         q.push(i);
                               }
                     }
           }

           int sum = ;

           //求出点beg到各边的距离和
           // 从 beg+1 开始 和从 1 开始，效果差不多
           for(i = beg+;i<=n;i++)
           {
                     if(!dist[n])
                               return INF;
                     else
                               sum+=dist[i];
           }
           return sum;

 }

 int main()
 {
           int i,j;

           int u,v,sum,res;

           while(~scanf("%d%d",&n,&m))
           {
                     MEM(map,);
                     MEM(pre,);

                     for(i = ;i<=m;i++)
                     {
                               scanf("%d%d",&u,&v);
                               map[u][v] = ++map[v][u];

                               //如果有重复边的话，map为2

                               e[i].u = v;
                               e[i].v = u;
                     }

                     sum = ;
                     bInit = true;
                     bCnet = true;

                     //求出每个点到其他点的距离和
                     for(i = ;i<=n;i++)
                     {
                               sum_d[i] = bfs(i);
                               sum+=sum_d[i];

                               if(sum>=INF)
                               {
                                         bCnet = false;
                                         break;
                               }
                     }

                     bInit = false;

                     //删除边
                     for(i = ;i<=m;i++)
                     {
                               //uv为删除的边
                               u = e[i].u;
                               v = e[i].v;

                               // map[u][v] 判断有无重边，可以优化300多MS
                               if(bCnet && map[u][v] == )
                               {
                                         res = ;
                                         for(j = ;j<=n;j++)
                                         {
                                                   //j树里不存在删除的边
                                                   // 最重要的剪枝，否则直接超时
                                                   if(pre[j][u] != v && pre[j][v] !=u)
                                                   {
                                                             res += sum_d[j];
                                                   }
                                                   else
                                                   {
                                                             //存在uv边，j树重新bfs
                                                             --map[u][v];
                                                             --map[v][u];
                                                             res += bfs(j);
                                                             ++map[u][v];
                                                             ++map[v][u];

                                                             if(res >= INF)
                                                                       break;

                                                   }

                                         }

                               }
                               else
                                         res=sum;

                               if(res >= INF)
                                         puts("INF");
                               else
                                         printf("%d\n",res*);

                     }

           }

           return ;
 }