Codeforces Round #677 (Div. 3） G.Reducing Delivery Cost

题意：大概题意就是，给定n个点 m条边（稀疏图） 和 k 对 点的编号，可以进行至多一次操作 ， 把图中任一边权变成0 ， 问 操作后 k对 点之间最短路径之和 最小为多少。 n m k 边权 < 1000.

分析：
这数据范围一开始想的是直接暴力，枚举每一条边，使其边权为0，然后 k对点 都跑一次堆优化版的dijkstra最短路 ， 这样时间复杂度是O(km*m log n) （ 没写过，大概率超时。。）

然后仔细想想，每次枚举一条边跑k次最短路太浪费时间了。所以在枚举前先预处理出原先所有的最短路就能优化时间了，但是这样就需要思考一个问题：枚举边权时，怎么得到更新之后的最短路？其实很简单，假设当前连接的点为 A , B ，起点 st ， 终点 ed ，res[][]为预处理后的结果，无论最短路经不经过当前边，都只需要取

min(res[st][ed] , res[st][a] + res[b][ed] , res[st][b] + res[a][ed])

这样累加k次后，再和ans取较小值，就可以得到最后的答案了。
想到这个“转移方程”之后，应该就很清晰了。
因为是稀疏图，所以最好用邻接表来存图，细节见代码

    #include <iostream>
    #include <algorithm>
    #include <cstdio>
    #include <cmath>
    #include <deque>
    #include <vector>
    #include <queue>
    #include <string>
    #include <cstring>
    #include <map>
    #include <stack>
    #include <set>
    #include <iomanip>

    using namespace std;

    #define ll long long
    #define ull unsigned long long
    #define endl '\n'
    #define P pair<ll,ll>
    #define pancake std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);

    const int inf = 0x3f3f3f3f;
    const int N = 1e3 + 7;
    const ll maxN = 1e12 + 5;
    const int mod = 1e9 + 7;
    const double EPS = 1e-8;
    const double pi = acos(-1.0);


    int read(){
        int x=0,f=1;
        char c=getchar();
        while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
        while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
        return x*f;
    }

    struct edge{
        ll to , val;
    };

    ll n , m , k;
    vector<P>v;
    vector<edge>e[N];
    vector<P>st;
    ll dis[N] , res[N][N];
    int vis[N];

    void dijkstra(ll s)
    {
        memset(dis , 0x3f , sizeof dis);
        memset(vis , 0 , sizeof vis);

        dis[s] = 0LL;

        priority_queue<P , vector<P> , greater<P> > que;

        que.push({0 , s});

        while(!que.empty()){
            P tt = que.top();
            que.pop();
            ll idx = tt.second;

            if(vis[idx]) continue;

            vis[idx] = 1;

            for(int i = 0 ; i < e[idx].size() ; i ++){
                edge now = e[idx][i];
                if(dis[now.to] > dis[idx] + now.val){
                    dis[now.to] = dis[idx] + now.val;
                    que.push({dis[now.to] , now.to});
                }
            }
        }
        
        for(int i = 1 ; i <= n ; i ++){
            res[s][i] = dis[i];
        }
    }

    int main()
    {
        cin >> n >> m >> k;

        for(int i = 1 ; i <= m ; i ++){
            ll a , b , c;
            cin >> a >> b >> c;
            e[a].push_back({b , c});
            e[b].push_back({a , c});
            st.push_back({a , b});
        }

        for(int i = 1 ; i <= k ; i ++){
            ll a , b;
            cin >> a >> b;
            v.push_back({a , b});
        }

        for(ll i = 1 ; i <= n ; i ++) dijkstra(i);

        ll ans = 1e18;

        for(auto i : st){
           ll a = i.first , b = i.second;
           ll sum = 0;
           for(auto j : v){
               ll c = j.first , d = j.second;
               sum += min({res[c][d] , res[c][a] + res[d][b] , res[c][b] + res[d][a]});
           }
           ans = min(ans , sum);
        }

        cout << ans;

        return 0;
    }