从早上11点开始一直到现在，推倒重构了一次还，就是不知道哪里挂了。求助神犇。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rl register ll
#define foa(i, a, b) for(rl i=a; i < b; ++ i)
#define fos(i, a, b) for(rl i=a; i <= b; ++ i)
#define fop(i, a, b) for(rl i=a; i >= b; -- i)
#define ws putchar(' ')
#define wl putchar('\n')

template <class T> inline void waw(T x)
{
    if(x > 9) waw(x / 10);
    putchar(x % 10 ^ 48);
}

template <class T> inline void ww(T x)
{
    if(x < 0) x = ~x + 1, putchar('-');
    waw(x);
}

template <class T> inline void read(T &res)
{
    char ch = getchar(); bool f = 0; res = 0;
    for(; !isdigit(ch); ch = getchar()) f |= ch == '-';
    for(; isdigit(ch); ch = getchar()) res = (res << 1) + (res << 3) + (ch ^ 48);
    res = f ? ~res + 1 : res;
}

const ll A = 510, N = A * A, M = N << 2, K = 55;

ll n, m, T;

ll tot, h[N];

ll dis[N], f[K << 1][K << 1], g[K][K], ridx[A << 2];

bool st[N];

struct edge { ll v, w, ne; } e[M];

struct Ray
{
    ll x, p, t;
    bool operator <(const Ray &x)const
    {
        return p < x.p;
    }
} ray[K];

struct node
{
    ll id, dis;
    bool operator <(const node &x) const 
    {
        return dis > x.dis;
    }
};

inline ll id (ll x, ll y) { return x * (m + 1) + y; }

inline void add_single(ll a, ll b, ll c) { e[tot] = {b, c, h[a]}, h[a] = tot ++ ; }

inline ll add(ll a, ll b, ll c) { add_single(a, b, c), add_single(b, a, c); return tot - 2; }

inline ll get_g(ll x, ll y, ll scnt)
{
    if(x > scnt) x -= scnt;
    if(y > scnt) y -= scnt;
    return g[x][y];
}

inline void dij(ll start)
{
    memset(st, 0, sizeof st);
    memset(dis, 0x3f, sizeof dis);

    dis[start] = 0;
    priority_queue<node> q;

    q.push({start, 0});

    while(q.size())
    {
        auto t = q.top();
        q.pop();
        ll u = t.id;
        if(st[u]) continue;
        st[u] = true;

        for(rl i=h[u]; ~i; i = e[i].ne)
        {
            ll v = e[i].v;
            if(dis[v] > dis[u] + e[i].w)
            {
                dis[v] = dis[u] + e[i].w;
                q.push({v, dis[v]});
            }
        }
    }
}

inline ll work(ll idx, ll scnt)
{
    if(!scnt) return 0;

    fos(i, 1, scnt)
    {
        dij(idx + i);
        fos(j, 1, scnt) g[i][j] = dis[tot + j];
    }

    memset(f, 0x3f, sizeof f);

    for(rl len = 2; len <= 2 * scnt; len += 2)
        for(rl l = 1; l + len - 1 <= 2 * scnt; l ++ )
        {
            ll r = l + len - 1;
            if(len == 2) f[l][r] = get_g(l, r, scnt);
            else
            {
                f[l][r] = get_g(l, r, scnt) + f[l + 1][r - 1];
                for(rl k = l + 1; k < r; k += 2)
                    f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
            }
        }

    ll res = 1e18;

    for(rl i=1; i <= scnt; ++ i) res = min(res, f[i][i + scnt - 1]);

    return res;
}

int main()
{
    read(n), read(m), read(T);

    memset(h, -1, sizeof h);

    fos(i, 1, n - 1) fos(j, 1, m)
    {
        ll c; read(c);
        add(id(i, j - 1), id(i, j), c);
    }

    fos(i, 1, n) fos(j, 1, m - 1)
    {
        ll c; read(c);
        add(id(i - 1, j), id(i, j), c);
    }

    ll k = 1;

    foa(i, 0, m) ridx[k ++ ] = add(id(0, i), id(0, i + 1), 0);
    foa(i, 0, n) ridx[k ++ ] = add(id(i, m), id(i + 1, m), 0);
    fop(i, m, 1) ridx[k ++ ] = add(id(n, i), id(n, i - 1), 0);
    fop(i, n, 1) ridx[k ++ ] = add(id(i, 0), id(i - 1, 0), 0);

    while(T -- )
    {
        ll cnt; read(cnt);
        foa(i, 0, cnt)
        {
            ll x, p, t; read(x), read(p), read(t);
            ray[i] = {x, p, t};

            ll k = ridx[p];
            e[k].w = e[k ^ 1].w = x;
        }

        sort(ray, ray + cnt);
        ll bidx = tot;
        ll idx = (n + 1) * (m + 1), scnt = 0;

        foa(i, 0, cnt)
        {
            ll a = i, b = (i + 1) % cnt;
            if(ray[a].t != ray[b].t)
            {
                scnt ++ ;
                ll k = ridx[ray[a].p];
                ll ver = e[k].v;
                add(ver, idx + scnt, 0);
            }
        }

        ww(work(idx, scnt)), wl;

        fos(i, idx + 1, idx + scnt) h[i] = -1;
        foa(i, 0, idx) while(h[i] != -1 && e[h[i]].v > idx) h[i] = e[h[i]].ne;
        foa(i, 0, cnt)
        {
            ll k = ridx[ray[i].p];
            e[k].w = e[k ^ 1].w = 0;
        }
        tot = bidx;
    }
    return 0;
}