[Codeforces 787D] Legacy

[题目链接]

https://codeforces.com/contest/787/problem/D

[算法]

线段树优化建边 ,  然后用Dijkstra算法求单源最短路

时间复杂度 : O((N + M)logN)

[代码]

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + ;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const ll inf = 1e15;

struct node
{
        int lc , rc;
} a[MAXN * ];
struct edge
{
        int to , w , nxt;
} e[MAXN << ];

int tot , cnt , n , q , s;
int head[MAXN * ] , root[];
bool visited[MAXN * ];
ll dist[MAXN * ];

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
inline void addedge(int x , int y , int w)
{
        ++cnt;
        e[cnt] = (edge){y , w , head[x]};
        head[x] = cnt;
}
inline void buildA(int &now , int l , int r)
{
        if (l == r)
        {
                now = l;
                return;
        }
        now = ++tot;
        int mid = (l + r) >> ;
        buildA(a[now].lc , l , mid);
        buildA(a[now].rc , mid +  , r);
        addedge(now , a[now].lc , );
        addedge(now , a[now].rc , );
}
inline void buildB(int &now , int l , int r)
{
        if (l == r)
        {
                now = l;
                return;
        }
        now = ++tot;
        int mid = (l + r) >> ;
        buildB(a[now].lc , l , mid);
        buildB(a[now].rc , mid +  , r);
        addedge(a[now].lc , now , );
        addedge(a[now].rc , now , );
}
inline void updateA(int now , int l , int r , int ql , int qr , int u , int w)
{
        if (l == ql && r == qr)
        {
                addedge(u , now , w);
                return;
        }
        int mid = (l + r) >> ;
        if (mid >= qr) updateA(a[now].lc , l , mid , ql , qr , u , w);
        else if (mid +  <= ql) updateA(a[now].rc , mid +  , r , ql , qr , u , w);
        else
        {
                updateA(a[now].lc , l , mid , ql , mid , u , w);
                updateA(a[now].rc , mid +  , r , mid +  , qr , u , w);
        }
}
inline void updateB(int now , int l , int r , int ql , int qr , int u , int w)
{
        if (l == ql && r == qr)
        {
                addedge(now , u , w);
                return;
        }
        int mid = (l + r) >> ;
        if (mid >= qr) updateB(a[now].lc , l , mid , ql , qr , u , w);
        else if (mid +  <= ql) updateB(a[now].rc , mid +  , r , ql , qr , u , w);
        else
        {
                updateB(a[now].lc , l , mid , ql , mid , u , w);
                updateB(a[now].rc , mid +  , r , mid +  , qr , u , w);
        }
}
inline void dijkstra(int s)
{
        priority_queue< pair<ll , ll> , vector< pair<ll , ll> > , greater< pair<ll , ll> > > q;
        dist[s] = ;
        q.push(make_pair( , s));
        while (!q.empty())
        {
                int u = q.top().second;
                q.pop();
                if (visited[u]) continue;
                visited[u] = true;
                for (int i = head[u]; i; i = e[i].nxt)
                {
                        int v = e[i].to , w = e[i].w;
                        if (dist[u] + w < dist[v])
                        {
                                dist[v] = dist[u] + w;
                                q.push(make_pair(dist[v] , v));
                        }
                }
        }
}

int main()
{

        read(n); read(q); read(s);
        tot = n;
        buildA(root[] ,  , n);
        buildB(root[] ,  , n);
        while (q--)
        {
                int type;
                read(type);
                if (type == )
                {
                        int u , v , w;
                        read(u); read(v); read(w);
                        addedge(u , v , w);
                }
                if (type == )
                {
                        int l , r , v , w;
                        read(v); read(l); read(r); read(w);
                        updateA(root[] ,  , n , l , r , v , w);
                }
                if (type == )
                {
                        int l , r , v , w;
                        read(v); read(l); read(r); read(w);
                        updateB(root[] ,  , n , l , r , v , w);
                }
        }
        for (int i = ; i <= tot; i++) dist[i] = inf;
        dijkstra(s);
         for (int i = ; i <= n; i++) printf("%lld " , dist[i] == inf ? - : dist[i]);

        return ; 

}