bzoj4400

/*
 * 此题同bzoj2725
 * 增加了枚举边的操作
 */
#include <bits/stdc++.h>

const int N = 2e5 + ;// oo = 999999999;

#define LL long long

const LL oo = 9e18;

int n, m, S, T;
int Short_path[N], Snum[N], Tnum[N], Id[N], path_js;
bool vis[N];
int head[N], now;
struct Node {int u, v, w, nxt;} G[N << ];
LL dis_s[N], dis_t[N];
LL Minn[N << ], Ans[N];

inline void Add(int u, int v, int w) {
    G[++ now].v = v, G[now].w = w, G[now].nxt = head[u], head[u] = now;
}

struct Node_ {
    int u; LL dis;
    bool operator < (const Node_ a) const {return dis > a.dis;}
};

std:: priority_queue <Node_> Q;

void Dijkstra(int start, LL dis_[]) {
    for(int i = ; i <= n; i ++) dis_[i] = oo, vis[i] = ;
    Node_ now; now = (Node_) {start, }; dis_[start] = ;
    Q.push(now);
    while(!Q.empty()) {
        Node_ topp = Q.top();
        Q.pop();
        if(vis[topp.u]) continue;
        vis[topp.u] = ;
        for(int i = head[topp.u]; ~ i; i = G[i].nxt) {
            int v = G[i].v;
            if(dis_[v] > dis_[topp.u] + G[i].w) {
                dis_[v] = dis_[topp.u] + G[i].w;
                Q.push((Node_) {v, dis_[v]});
            }
        }
    }
}

inline void Bfs(int x, LL dis_[], int bel[]) {
    std:: queue <int> Q1;
    Q1.push(Short_path[x]);
    bel[Short_path[x]] = x;
    while(!Q1.empty()) {
        int topp = Q1.front();
        Q1.pop();
        for(int i = head[topp]; ~ i; i = G[i].nxt) {
            int v = G[i].v;
            if(!Id[v] && !bel[v] && dis_[v] == dis_[topp] + G[i].w) {
                bel[v] = x;
                Q1.push(v);
            }
        }
    }
}

#define lson jd << 1
#define rson jd << 1 | 1

void Sec_G(int l ,int r, int jd, int x, int y, LL num) {
    if(x <= l && r <= y) {
        Minn[jd] = std:: min(Minn[jd], (LL)num);
        return ;
    }
    int mid = (l + r) >> ;
    if(x <= mid) Sec_G(l, mid, lson, x, y, num);
    if(y > mid)  Sec_G(mid + , r, rson, x, y, num);
}

void Dfs_tree(int l, int r, int jd) {
    if(l == r) {
        Ans[l] = Minn[jd];
        return ;
    }
    int mid = (l + r) >> ;
    Minn[lson] = std:: min(Minn[lson], Minn[jd]);
    Minn[rson] = std:: min(Minn[rson], Minn[jd]);
    Dfs_tree(l, mid, lson), Dfs_tree(mid + , r, rson);
}

#define gc getchar()

inline LL read() {
    LL x = ; char c = gc;
    while(c < '' || c > '') c = gc;
    while(c >= '' && c <= '') x = x *  + c - '', c = gc;
    return x;
}

bool visit[N << ];

int main() {
    n = read(), m = read();
    for(int i = ; i <= (N << ); i ++) Minn[i] = oo;
    for(int i = ; i <= n; i ++) head[i] = -;
    for(int i = ; i <= m; i ++) {
        int u = read(), v = read(), w = read();
        Add(u, v, w), Add(v, u, w);
    }
    S = , T = n;
    Dijkstra(S, dis_s);
    Dijkstra(T, dis_t);
    for(int i = S; i != T; i = i) {
    //  visit[i] = 1;
        Short_path[++ path_js] = i;
        Id[i] = path_js;
        for(int j = head[i]; ~ j; j = G[j].nxt) {
            if(dis_t[i] == G[j].w + dis_t[G[j].v]) {
                i = G[j].v;
                visit[j] = ;
                break;
            }
        }
    }
    Short_path[path_js + ] = T, Id[T] = path_js + ;
    for(int i = ; i <= path_js; i ++) Bfs(i, dis_s, Snum);
    for(int i = path_js + ; i >= ; i --) Bfs(i, dis_t, Tnum);
    for(int i = ; i <= n; i ++) {
        for(int j = head[i]; ~ j; j = G[j].nxt) {
            int v = G[j].v;
            if(visit[j]) continue;
            if(Snum[i] < Tnum[v] && Snum[i] && Tnum[v]) {
                Sec_G(, path_js, , Snum[i], Tnum[v] - , dis_s[i] + G[j].w + dis_t[v]);
            }
        }
    }
    Dfs_tree(, path_js, );
    LL Dis = , js;
    for(int i = ; i <= path_js; i ++) {
        if(Ans[i] > Dis && Ans[i] != oo) Dis = Ans[i], js = ;
        else if(Ans[i] == Dis) js ++;
    }
    if(Dis == dis_s[T]) js += m - path_js;
    std:: cout << Dis << " " << js;
    return ;
}
?