B

B - Legacy

 CodeForces - 787D 

这个题目开始看过去还是很简单的，就是一个最短路，但是这个最短路的建图没有那么简单，因为直接的普通建图边太多了，肯定会超时的，所以要用线段树来优化建图。

这个题目我一开始也没想到，不知道怎么用线段树优化，然后看了一下题解，豁然开朗。

首先建两棵线段树，有点类似拆点，然后其中一颗从下往上建图A，一颗从上往下建图B。

从上往下建图的每一个叶子节点连着从上往下建图的每一个叶子节点。 权值都是0

p==1 那就直接是B 的叶子节点连着A 的叶子节点，权值为w

p==2 那就是A的叶子节点v 连着B的这个区间的节点

p==3 那就是A 的区间节点连着B的叶子节点v

起点在A这颗树的地球位置的根节点。

建完图之后就是跑一个最短路。

这个是大概思路，但是怎么写呢，

首先肯定是建树，建树的过程中建图，而且还要记录每一个节点的编号，并且记录每一个叶子节点的编号。

然后就是根据要求建图如果是区间就要进行查找这个区间节点就可以了。

接下来就是考验码力的时候了。

 这个题目想清楚之后就不是很难写了，只是这个空间要注意，因为这个wa了三发。

这个方法要学习学习。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
#include <map>
#define inf 0x3f3f3f3f
#define inf64 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;
int numa[maxn * 4], numb[maxn * 4], lefta[maxn * 4], leftb[maxn * 4];
ll d[maxn*8], tot;
int n, m;
bool vis[maxn*8];
struct edge {
    int from, to, dist;
    edge(int from=0, int to=0, int dist=0) :from(from), to(to), dist(dist) {}
};
struct heapnode {
    int u;
    ll d;
    heapnode(ll d=0, int u=0) : d(d), u(u) {}
    bool operator<(const heapnode &a) const {
        return a.d < d;
    }
};

vector<edge> vec;
vector<int> g[maxn*8];

void add(int u,int v,int w)
{
    vec.push_back(edge(u, v, w));
    int m = vec.size();
    g[u].push_back(m - 1);
    // printf("u=%d v=%d w=%d
", u, v, w);
}

void dijkstra(int s) {
    priority_queue<heapnode>que;
    for (int i = 0; i <= tot; i++) d[i] = inf64;
    d[s] = 0;
    memset(vis, 0, sizeof(vis));
    que.push(heapnode(0, s));
    while (!que.empty()) {
        heapnode x = que.top(); que.pop();
        int u = x.u;
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = 0; i < g[u].size(); i++) {
            edge &e = vec[g[u][i]];
            // printf("u=%d e.to=%d e.dist=%d
", u, e.to, e.dist);
            // printf("d[%d]=%lld d[%d]=%lld
", u, d[u], e.to, d[e.to]);
            if (d[e.to] > d[u] + e.dist) {
                // printf("ww
");
                d[e.to] = d[u] + e.dist;
                que.push(heapnode(d[e.to], e.to));
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if (d[lefta[i]] >= inf64) printf("-1 ");
        else printf("%lld ", d[lefta[i]]);
    }
}

void builda(int id,int l,int r)
{
    numa[id] = ++tot;
    int mid = (l + r) >> 1;
    if(l==r)
    {
        lefta[l] = tot;
        return;
    }
    builda(id << 1, l, mid);
    builda(id << 1 | 1, mid + 1, r);
    add(numa[id << 1], numa[id], 0);
    add(numa[id << 1 | 1], numa[id], 0);
}

void buildb(int id,int l,int r)
{
    numb[id] = ++tot;
    int mid = (l + r) >> 1;
    if(l==r)
    {
        leftb[l] = tot;
        return;
    }
    buildb(id << 1, l, mid);
    buildb(id << 1 | 1, mid + 1, r);
    add(numb[id], numb[id << 1], 0);
    add(numb[id], numb[id << 1 | 1], 0);
}

void build3(int n)
{
    for (int i = 1; i <= n; i++) add(leftb[i], lefta[i], 0);
}

void updatea(int id,int l,int r,int x,int y,int b,int w)
{
    if (x <= l && y >= r) {
        add(numa[id], b, w);
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) updatea(id << 1, l, mid, x, y, b, w);
    if (y > mid) updatea(id << 1 | 1, mid + 1, r, x, y, b, w);
}

void updateb(int id,int l,int r,int x,int y,int a,int w)
{
    if(x<=l&&y>=r)
    {
        add(a, numb[id], w);
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) updateb(id << 1, l, mid, x, y, a, w);
    if (y > mid) updateb(id << 1 | 1, mid + 1, r, x, y, a, w);
}


int main()
{
    int s;
    tot = 0;
    scanf("%d%d%d", &n, &m, &s);
    builda(1, 1, n), buildb(1, 1, n), build3(n);
    while(m--)
    {
        int opt, u, v, l, r, w;
        scanf("%d", &opt);
        if (opt == 1) {
            scanf("%d%d%d", &u, &v, &w);
            add(lefta[u], leftb[v], w);
        }
        if(opt==2)
        {
            scanf("%d%d%d%d", &u, &l, &r, &w);
            updateb(1, 1, n, l, r, lefta[u], w);
        }
        if(opt==3)
        {
            scanf("%d%d%d%d", &u, &l, &r, &w);
            updatea(1, 1, n, l, r, leftb[u], w);
        }
    }
    dijkstra(lefta[s]);
    return 0;
}