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 = 1010;
const int INF = 1<<27;

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[30*L];


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

          used[beg] = true;

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

          int i;

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

                                        //初始化    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 = 0;


          //求出点beg到各边的距离和
          // 从 beg+1 开始 和从 1 开始，效果差不多
          for(i = beg+1;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,0);
                    MEM(pre,0);

                    for(i = 1;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 = 0;
                    bInit = true;
                    bCnet = true;


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

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

                    bInit = false;


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

                              // map[u][v] 判断有无重边，可以优化300多MS
                              if(bCnet && map[u][v] == 1)
                              {
                                        res = 0;
                                        for(j = 1;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
",res*2);

                    }


          }

          return 0;
}