HDU-6705 path （bfs）

Problem Description

You have a directed weighted graph with n vertexes and m edges. The value of a path is the sum of the weight of the edges you passed. Note that you can pass any edge any times and every time you pass it you will gain the weight.

Now there are q queries that you need to answer. Each of the queries is about the k-th minimum value of all the paths.

 

 

Input

The input consists of multiple test cases, starting with an integer t (1≤t≤100) , denoting the number of the test cases.
The first line of each test case contains three positive integers n,m,q. (1≤n,m,q≤5∗10⁴)

Each of the next m lines contains three integers ui,vi,wi , indicating that the i−th edge is from ui to vi and weighted wi .(1≤ui,vi≤n,1≤wi≤10⁹)

Each of the next q lines contains one integer k as mentioned above.(1≤k≤5∗10⁴)

It's guaranteed that Σn ,Σm , Σq,Σmax(k)≤2.5∗10⁵ and max(k) won't exceed the number of paths in the graph.

 

 

Output

For each query, print one integer indicates the answer in line.

 

 

Sample Input

1 2 2 2 1 2 1 2 1 2 3 4

 

 

Sample Output

3 3

Hint

1->2 value :1 2->1 value: 2 1-> 2-> 1 value: 3 2-> 1-> 2 value: 3

 

题意：题意很简单，就是给你一张单向图，求Q个询问，问整个图的第Q【i】长度路径

思路：开始的时候，是直接暴力添边，直到第k大，但是寻思可能MLE，自作聪明的对队列限制只能加入MAXX个（最大的询问值），超过了就直接和队列的最大值比较。

但是这样是TLE的，因为可能会有菊花图，对于一个点如果直接扩展其所有连边就容易TLE. 复杂度 T*k*log（k*n）

所以我们考虑，对于一条已知的最小边，需要如何扩展，很明显我们可以拓展其出点的最小出边，这肯定是下一个最小的候选答案，因为该边是由入点扩展的一条边，那么如果该入点还有比该边权值大的边，也扩展它，这样就保证了最小的边一定被扩展出来了，后面重复过程，直到计算完MAXX.

 

 

#include<bits/stdc++.h>
using namespace std;

const int maxn = 5e4+5;
int n,m,k,t,q;
typedef pair<int,int>p;
typedef long long ll;
vector<p>node[maxn];

ll ans[maxn];
int Q[maxn];

struct Point
{
    ll val;
    int now,id;
    Point(ll val,int now,int id):val(val),now(now),id(id){}
    bool operator<(const Point &b)const{
        return val > b.val;
    }
};

priority_queue<Point>que;
void bfs(int limit)
{
    while(!que.empty())que.pop();
   for(int i=1;i<=n;i++)sort(node[i].begin(),node[i].end());
   for(int i=1;i<=n;i++)
   {
       if(!node[i].empty())que.push(Point(node[i][0].first,i,0));
   }
    int tot = 0;
    while(!que.empty())
    {
        Point tmp = que.top();
        que.pop();
        ll cost = tmp.val;
        int now = tmp.now;
        int id = tmp.id;
        if(++tot > limit)return;
        ans[tot] = cost;
        if(id < node[now].size() - 1)
        {
            que.push(Point(cost-node[now][id].first+node[now][id+1].first,now,id+1));
        }
        if(!node[node[now][id].second].empty())
        {
            que.push(Point(cost+node[node[now][id].second][0].first,node[now][id].second,0));
        }
    }
}

int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&q);
        int maxx = 0;
        for(int i=1;i<=n;i++)node[i].clear();
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            node[u].push_back(p(w,v));
        }
        for(int i=1;i<=q;i++)
        {
            scanf("%d",&Q[i]);
            maxx = max(maxx,Q[i]);
        }
        bfs(maxx);
        for(int i=1;i<=q;i++)
        {
            printf("%lld\n",ans[Q[i]]);
        }
    }
}