时空宝石（Floyd + 线段树）

题目描述

zP1nG很清楚自己打不过灭霸，所以只能在自己出的题里欺负他。

咳咳。这一次他得到了空间宝石(Tesseract)。

世界之树连接着九界，此时灭霸和zP1nG都在九界的某个地方。而九界是相互无法到达的。zP1nG为了追杀灭霸，决定使用空间宝石的力量到达灭霸身边。因为zP1nG不擅长使用空间宝石，无法直接开一条从自己的位置到灭霸的位置的传送门，所以他只能无意识地使用空间宝石的力量。zP1nG想知道，在自己胡乱地使用空间宝石后，通过传送门到达灭霸的位置最少需要多长时间。

具体地，九界的编号为0~8，共有(n)道传送门，第i道传送门为优先级为(p_i)，由(u_i)到(v_i)，需要花费(w_i)个时间的单向门。传送的规则为：zP1nG按顺序穿过的传送门的优先级必须是单调不降的。例如，zP1nG穿过了三道传送门到达灭霸的位置，这三道传送门的优先级分别为1→2→2即为一种合法的方式，而优先级分别为1→2→1是不合法的。

zP1nG会使用(q)次宝石的力量来尝试进行传送：其中第(i)次尝试会打开数道传送门，这些传送门的优先级会形成(s_i)个区间。例如，在某次尝试中zP1nG打开了三个区间([1,2])，([4,7])，([9,10])，那么优先级在这三个区间内的传送门将全部被打开并允许zP1nG穿过。你需要告诉zP1nG在此情况下从自己的位置(z_i)到达灭霸所在处(t_i)所需的最短时间。尝试结束后所有传送门会关闭。

输入格式

第(1)行包含两个正整数(n)和(S)，(S)的含义见数据范围与约定所述。

第(2)至(n+1)行每行包含4个正整数(p_i)，(u_i)，(v_i)，(w_i)。

第(n+2)行包含一个正整数(q)。

第(n+3)至第(n+q+2)行每行若干个正整数，其中前三个数为(z_i)，(t_i)，(s_i)，之后为(2 imes si)个正整数，表示每个区间的左右端点。

各变量具体含义见题目描述所述。

输出格式

对于zP1nG进行的每次尝试，输出一行一个数表示从zP1nG的位置到灭霸的位置所需的最短时间，如果zP1nG无法到达灭霸的位置则输出-1。

样例

样例输入

  6 2
  1 2 4 1
  2 1 3 3
  3 1 2 2
  4 3 4 5
  5 2 4 3
  6 1 4 2
  4
  1 4 1 1 3
  1 4 1 1 4
  1 4 2 5 5 2 3
  1 4 1 1 6

样例输出

  -1
  8
  5
  2

数据范围与约定

5为无特殊限制

题解

神仙题，考试的时候一头雾水，看着像最短路但总是缺点什么。要知道道路的优先级单凭一次的Dij或Spfa都是无法解决的，因为无论怎么加限制，我们都无法保证在松弛时所做的那一个选择一定是最优的，这点大家可以通过手动模拟数据试验一下。

所以这道题不能用大众的Dij或Spfa来解决。

面对这种限制条件极其恶心，可能情况极其多的类型，最好的办法，那就是把所有情况都算一遍！

那么我们剩下的，也就是只有万年小冷门（其实并没有）的Floyd了！

其实题干中已经说明节点数一共也就有9个，也就是说我们完全可以用联接矩阵来存储整张图，(n^3)的效率完全可以接受，这就给了Floyd操作的空间。而对于优先级的问题，通过研究数据我们知道优先级最多有2000个，在(9^3)的基础上再乘上2000，这样的时空效率我们也是可以接受的。所以我们的办法就是针对每一个优先级都建一个联接矩阵，然后以等级作为区间构建线段树。

没错，你没有看错，就是线段树。鬼知道最短路还能放在线段树上，活久见。

唯一能够有所提示的地方估计就是每次给出的优先级都是区间吧...对优先级建树，每个树节点都有一个矩阵，(dis[i][j]) 代表在当前树节点包含的区间(即优先级区间)内 (i) 到 (j) 的最短路。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
const int maxn = 2000 + 10;
char buf[1 << 20], *p1 = buf, *p2 = buf;
// fread版快读，输入结束后手动输入EOF结束输入
char getc() {
    if (p1 == p2) {
        p1 = buf;
        p2 = buf + fread(buf, 1, 1 << 20, stdin);
        if (p1 == p2)
            return EOF;
    }
    return *p1++;
}
inline int read() {
    int s = 0, w = 1;
    char c = getc();
    while (c < '0' || c > '9') {
        if (c == '-')
            w = -1;
        c = getc();
    }
    while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getc();
    return s * w;
}
struct node {
    int l, r;
    bool operator<(const node& x) const { return l < x.l; }
} q[maxn];  //存储每一个可以打开的区间
struct Maxtrix {
    int dis[10][10];
    void Init() {
        //有点类似于单位矩阵的初始化
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++) dis[i][j] = (i == j ? 0 : 0x3f3f3f3f);
    }
} G[maxn];  //为每一个优先级都建一张图
struct tree {
    Maxtrix data;
    int l, r;
} t[maxn << 2];
inline Maxtrix Update(Maxtrix a, Maxtrix b) {
    Maxtrix c;
    c.Init();
    //标准的floyd最短路 ，又有点像矩阵乘法
    for (int k = 0; k < 9; k++)
        for (int i = 0; i < 9; i++)
            for (int j = 0; j < 9; j++) c.dis[i][j] = min(c.dis[i][j], a.dis[i][k] + b.dis[k][j]);
    return c;
}
#define tl t[u].l
#define tr t[u].r
#define ls (u << 1)
#define rs (u << 1 | 1)
void Pushup(int u) { t[u].data = Update(t[ls].data, t[rs].data); }
void Build(int u, int l, int r) {
    //每个线段树节点的所代表的区间都是优先级的区间
    t[u].l = l;
    t[u].r = r;
    if (l == r) {
        t[u].data = G[l];
        return;
    }
    int mid = (tl + tr) >> 1;
    Build(ls, l, mid);
    Build(rs, mid + 1, r);
    Pushup(u);
}
Maxtrix Ask(int u, int l, int r) {
    if (l <= tl && tr <= r) {
        return t[u].data;
    }
    int mid = (tl + tr) >> 1;
    bool flag = 0;
    Maxtrix ans;
    if (l <= mid) {
        ans = Ask(ls, l, r);
        flag = 1;
    }
    if (r > mid) {
        if (flag)
            ans = Update(ans, Ask(rs, l, r));
        else
            ans = Ask(rs, l, r);
    }
    return ans;
}
int main() {
    int n = read(), S = read();
    for (int i = 1; i <= 2001; i++) G[i].Init();
    int p, u, v, w;
    for (int i = 1; i <= n; i++) {
        p = read(), u = read(), v = read(), w = read();
        G[p].dis[u][v] = min(G[p].dis[u][v], w);
    }
    for (register int t = 1; t <= 2001; t++)  //事先预处理单独每一级优先级的最短路
        for (register int k = 0; k < 9; k++)
            for (register int i = 0; i < 9; i++)
                for (register int j = 0; j < 9; j++)
                    G[t].dis[i][j] = min(G[t].dis[i][j], G[t].dis[i][k] + G[t].dis[k][j]);
    //线段树主要是解决涉及多个优先级的最短路
    //按照优先级作为区间构造线段树，每一个区间内的树节点所记录的数据，就是每一个优先级区间内所能达到的最短路
    Build(1, 1, 2001);
    int cas = read();
    int st, ed, siz;
    while (cas--) {
        st = read(), ed = read(), siz = read();
        for (register int i = 1; i <= siz; i++)  //读入每个可使用的优先级区间
            q[i].l = read(), q[i].r = read();
        sort(q + 1, q + 1 + siz);
        Maxtrix ans = Ask(1, q[1].l, q[1].r);  //我们按照优先级作为区间构造了线段树，更新答案时直接在相应的区间内查询即可
        for (register int i = 2; i <= siz; i++) {
            ans = Update(ans, Ask(1, q[i].l, q[i].r));
        }
        printf("%d
", (ans.dis[st][ed] == 0x3f3f3f3f ? -1 : ans.dis[st][ed]));
    }
}