hdu 2433 Travel（Dijkstra+思维）

最新推荐文章于 2025-01-08 08:30:00 发布

China震震

最新推荐文章于 2025-01-08 08:30:00 发布

阅读量672

点赞数 2

CC 4.0 BY-SA版权

分类专栏：数据结构--图论文章标签： dijkstra

本文链接：https://blog.youkuaiyun.com/qq_29980371/article/details/76036230

数据结构--图论专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一种解决无向图中删除边后各点间最短路径和的算法。通过预先计算所有点间的最短路径总和，并在删除特定边时调整计算结果，避免了重复计算带来的性能问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2433

题目大意：一个无向图，有N个顶点，M条边，每条边的权值都是1，每次删除1条边，求出删边之后各个点之间最短路的和是多少。输出这个和（很明显是离线处理）

题目思路：优化后的dijstra的复杂度是O(Elog(V))，如果每次都是一个点一个点的求解最短路然后求和的话，题目的复杂度一样会爆炸，所以，只能采用别的方法。

正解：1.先求解出所有点之间的最短路sum[i]的和为Sum

2.然后开始处理某一组的u，v,只对u,v进行最短路的处理得出sum_u,sum_v，如果出现不连通的情况输出INF，否则输出Sum-sum[u]-sum[v]+sum_u+sum_v

这样的复杂度差不多是 3000*3000*2*log(100)勉勉强强可以。

注意的点：无向图，两个方向都要进行存储，E，V要分清！！！因为这个地方WA了一个小时，难受。

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxv=200;
const int inf=2e9+7;
struct edge
{
    int to;
    int cost;
};
struct node
{
    int from;
    int to;
}m[3010];

typedef pair<int,int> P;//frist 是最短距离，second是顶点编号
int V,E;//定义顶点总数和边的总数
vector<edge>G[maxv];//vector的类型为egde
int d[maxv];
int sum[maxv];
void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> >que;//这个地方只是固定的格式，这个vector和上边的那个vector没有半毛钱的关系
    fill(d,d+V+1,inf);
    d[s]=0;
    que.push(P(0,s));

    while(!que.empty()){ //整个过程类似于bfs，一层一层的很好理解
        P p = que.top();que.pop();
        int v = p.second;
        if(d[v]<p.first) continue;
        for(int i=0;i<G[v].size();i++){
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost){
                d[e.to] = d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}

int main()
{
    while(~scanf("%d%d",&V,&E)){
        edge e;
        int flag1=0;
        for(int j=1;j<=V;j++) G[j].clear();
        for(int i=0;i<E;i++){
            scanf("%d%d",&m[i].from,&m[i].to);
            e.cost=1;
            e.to=m[i].from;G[m[i].to].push_back(e);
            e.to=m[i].to;G[m[i].from].push_back(e);
        }
        fill(sum,sum+V+1,0);
        int Sum=0;
        for(int i=1;i<=V;i++){
            dijkstra(i);
            for(int j=1;j<=V;j++){
                sum[i]+=d[j];
                if(d[j]==inf) flag1=1;
            }
            Sum+=sum[i];
        }
        for(int i=0;i<E;i++){
            int flag=0;//记录不存在通路的情况
            for(int j=0;j<=V;j++) G[j].clear();
            for(int k=0;k<E;k++){
                if(i!=k){
                e.cost=1;
                e.to=m[k].from;G[m[k].to].push_back(e);
                e.to=m[k].to;G[m[k].from].push_back(e);
                }
            }
            dijkstra(m[i].from);
            int sumfrom=0,sumto=0;
            for(int z=1;z<=V;z++){
                sumfrom+=d[z];
                if(d[z]==inf) flag=1;
            }
            dijkstra(m[i].to);
            for(int z=1;z<=V;z++){
                sumto+=d[z];
                if(d[z]==inf) flag=1;
            }
            int ans = Sum-sum[m[i].from]-sum[m[i].to]+sumfrom+sumto;
            if(flag||flag1) printf("INF\n");
            else printf("%d\n",ans);
        }
    }
}