CC QGRID [分治][树链剖分][Dijkstra]

$Solution$

%%%%%%%%%PBS
道理上和ZJOI2016旅行者是相似的。
在大佬的带领下终于打掉了这题。。
根据最短路所在分治结构中的位置来建最短路树，并操作询问答案。
自己打的时候真的失了智。刚开始$m$和$n$都读反了。。后面分治的顺序也搞乱掉了。。
代码能力好垃圾哦。。

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 601010;
const long long INF = 1ll << 60;
typedef long long ll;

inline char get(void) {
    static char buf[100000], *S = buf, *T = buf;
    if (S == T) {
        T = (S = buf) + fread(buf, 1, 100000, stdin);
        if (S == T) return EOF;
    }
    return *S++;
}
template<typename T>
inline void read(T &x) {
    static char c; x = 0;
    for (c = get(); c < '0' || c > '9'; c = get());
    for (; c >= '0' && c <= '9'; c = get()) x = x * 10 + c - '0';
}

int n, m, q, cnt;
int Step[N], H[N];
ll ans[N];
ll Ans[N];
ll x;
struct Qry {
    int opt, id;
    int i1, i2, j1, j2;
    int step, h;
    int usd;
    ll c;
    ll ans;
};
Qry a[N], b[N], d[N];
struct edge {
    int to, next;
    ll key;
    edge(int t = 0, int n = 0, ll k = 0):to(t), next(n), key(k) {}
};
int id[4][N];
template<typename T>
inline T Min(T a, T b) {
    return a < b ? a : b;
}
template<typename T>
inline T Max(T a, T b) {
    return a > b ? a : b;
}

namespace Tree {
    int Gcnt, Pcnt, clc;
    int head[N];
    int fa[N], dep[N], size[N], son[N], pos[N], top[N];
    edge G[N << 4];
    namespace BIT {
        ll c[N];
        int clc;
        int vis[N];
        int maxn;
        void Init(int n) {
            maxn = n; ++clc;
        }
        inline void Add(int x, ll a) {
            for (; x <= maxn; x += x & -x) 
                if (vis[x] == clc) c[x] += a;
                else {
                    vis[x] = clc; c[x] = a;
                }
        }
        inline ll Sum(int x) {
            ll sum = 0;
            for (; x; x -= x & -x)
                if (vis[x] == clc) sum += c[x];
            return sum;
        }
    }
    inline void AddEdge(int from, int to) {
        G[++Gcnt] = edge(to, head[from]); head[from] = Gcnt;
        G[++Gcnt] = edge(from, head[to]); head[to] = Gcnt;
    }
    void Init(int L, int R) {
        clc = Gcnt = Pcnt = 0; int i;
        for (int k = 1; k <= m; k++)
            for (int j = L; j <= R; j++) {
                i = id[k][j];
                head[i] = fa[i] = dep[i] = size[i] = son[i] = pos[i] = top[i] = 0;
        }
        BIT::Init(id[m][n]);
    }
    inline void dfs1(int u) {
        int to; size[u] = 1;
        for (int i = head[u]; i; i = G[i].next) {
            to = G[i].to; if (to == fa[u]) continue;
            fa[to] = u; dep[to] = dep[u] + 1;
            dfs1(to); size[u] += size[to];
            if (size[son[u]] < size[to]) son[u] = to;
        }
    }
    inline void dfs2(int u, int t) {
        int to; top[u] = t; pos[u] = ++Pcnt;
        if (son[u]) dfs2(son[u], t);
        for (int i = head[u]; i; i = G[i].next)
            if (G[i].to != son[u] && G[i].to != fa[u])
                dfs2(G[i].to, G[i].to);
    }
    inline void Add(int u, int v, ll c) {
        static int f1, f2;
        while ((f1 = top[u]) != (f2 = top[v])) {
            if (dep[f1] < dep[f2]) {
                swap(f1, f2); swap(u, v);
            }
            BIT::Add(pos[f1], c);
            BIT::Add(pos[u] + 1, -c);
            u = fa[f1];
        }
        if (pos[u] > pos[v]) swap(u, v);
        BIT::Add(pos[u], c);
        BIT::Add(pos[v] + 1, -c);
    }
    inline ll Query(int u) {
        return BIT::Sum(pos[u]);
    }
}
namespace Gra {
    typedef pair<ll, int> P;
    int Gcnt, st, ed, clc;
    int head[N], pre[N];
    int vis[N], able[N];
    ll dist[N];
    edge G[N << 4];
    priority_queue<P> Q;
    inline void AddEdge(int from, int to, ll key) {
        G[++Gcnt] = edge(to, head[from], key); head[from] = Gcnt;
        G[++Gcnt] = edge(from, head[to], key); head[to] = Gcnt;
    }
    void Dijkstra(int u, int L, int R, int fl = 0) {
        ++clc;
        for (int i = 1; i <= m; i++)
            for (int j = L; j <= R; j++) {
                dist[id[i][j]] = INF;
                able[id[i][j]] = clc;
                pre[id[i][j]] = vis[id[i][j]] = 0;
            }
        Gcnt = 0; int to; dist[u] = 0;
        Q.push(P(0, u));
        while (!Q.empty()) {
            int x = Q.top().second;
            Q.pop();
            if (vis[x]) continue;
            vis[x] = true;
            for (int i = head[x]; i; i = G[i].next) {
                to = G[i].to;
                if (able[to] != clc) continue;
                if (dist[to] > dist[x] + G[i].key) {
                    dist[to] = dist[x] + G[i].key;
                    if (!vis[to]) Q.push(P(-dist[to], to));
                    pre[to] = x;
                }
            }
        }
        if (fl) {
            Tree::Init(L, R);
            for (int i = 1; i <= m; i++)
                for (int j = L; j <= R; j++)
                    if (pre[id[i][j]]) Tree::AddEdge(id[i][j], pre[id[i][j]]);
            Tree::dfs1(u); Tree::dfs2(u, u);
        }
    }
}
void DivAndConq1(int L, int R, int step, int l, int r) {
    if (L > R || l > r) return;
    int Mid = (L + R) >> 1, p1, p2;
    for (int i = 1; i <= m; i++) {
        Gra::Dijkstra(id[i][Mid], L, R);
        for (int j = l; j <= r; j++)
            if (a[j].opt == 1) {
                if (ans[a[j].id] > Gra::dist[id[a[j].i1][a[j].j1]] + Gra::dist[id[a[j].i2][a[j].j2]]) {
                    ans[a[j].id] = Gra::dist[id[a[j].i1][a[j].j1]] + Gra::dist[id[a[j].i2][a[j].j2]];
                    Step[a[j].id] = step; H[a[j].id] = i;
                }
            }
    }
    p1 = l - 1; p2 = r + 1;
    for (int i = l; i <= r; i++) {
        if (a[i].opt == 1 && a[i].j1 < Mid && a[i].j2 < Mid) b[++p1] = a[i];
        if (a[i].opt == 1 && a[i].j1 > Mid && a[i].j2 > Mid) b[--p2] = a[i];
    }
    for (int i = l; i <= p1; i++) a[i] = b[i];
    for (int i = p2; i <= r; i++) a[i] = b[i];
    DivAndConq1(L, Mid - 1, step + 1, l, p1);
    DivAndConq1(Mid + 1, R, step + 1, p2, r);
}
void DivAndConq(int L, int R, int step, int l, int r) {
    if (L > R) return;
    int Mid = (L + R) >> 1, p1, p2;
    for (int i = 1; i <= m; i++) {
        Gra::Dijkstra(id[i][Mid], L, R, 1);
        for (int j = l; j <= r; j++)
            if (a[j].opt == 1) {
                if (a[j].step == step && a[j].h == i)
                    Tree::Add(id[a[j].i1][a[j].j1], id[a[j].i2][a[j].j2], a[j].c);
            } else {
                Ans[a[j].id] += Tree::Query(id[a[j].i1][a[j].j1]);
            }
    }
    p1 = l - 1; p2 = r + 1;
    for (int i = l; i <= r; i++) {
        if ((a[i].opt == 1 && a[i].j1 < Mid && a[i].j2 < Mid) || 
            (a[i].opt == 2 && a[i].j1 < Mid)) b[++p1] = a[i];
        if ((a[i].opt == 1 && a[i].j1 > Mid && a[i].j2 > Mid) || 
            (a[i].opt == 2 && a[i].j1 > Mid)) b[--p2] = a[i];
    }
    for (int i = l; i <= p1; i++) a[i] = b[i];
    for (int i = p2; i <= r; i++) a[i] = b[r - i + p2];
    DivAndConq(L, Mid - 1, step + 1, l, p1);
    DivAndConq(Mid + 1, R, step + 1, p2, r);
}

int main(void) {
    freopen("1.in", "r", stdin);
    freopen("1.out", "w", stdout);
    read(m); read(n); read(q);
    for (int j = 1; j <= n; j++)
        for (int i = 1; i <= m; i++) {
            id[i][j] = ++cnt;
            ans[id[i][j]] = INF;
        }
    for (int i = 1; i < m; i++)
        for (int j = 1; j <= n; j++) {
            read(x);
            Gra::AddEdge(id[i][j], id[i + 1][j], x);
        }
    for (int i = 1; i <= m; i++)
        for (int j = 1; j < n; j++) {
            read(x);
            Gra::AddEdge(id[i][j], id[i][j + 1], x);
        }
    for (int i = 1; i <= q; i++) {
        read(a[i].opt);
        if (a[i].opt == 1) {
            read(a[i].i1); read(a[i].j1);
            read(a[i].i2); read(a[i].j2);
            read(a[i].c); Ans[i] = -1;
        } else {
            read(a[i].i1); read(a[i].j1);
        }
        a[i].id = i; d[i] = a[i];
    }
    DivAndConq1(1, n, 1, 1, q);
    for (int i = 1; i <= q; i++) {
        a[i] = d[i];
        a[i].step = Step[i];
        a[i].h = H[i];
//      if (a[i].opt == 1 && Step[i] == 0) return cout << i << endl, 0;
    }
    DivAndConq(1, n, 1, 1, q);
    for (int i = 1; i <= q; i++)
        if (~Ans[i]) printf("%lld\n", Ans[i]);
    return 0;
}