题目描述

小 C 喜欢跑步，并且非常喜欢在微信步数排行榜上刷榜，为此他制定了一个刷微信步数的计划。

他来到了一处空旷的场地，处于该场地中的人可以用 kk 维整数坐标 (a1,a2,…,ak)(a1,a2,…,ak) 来表示其位置。场地有大小限制，第 ii 维的大小为 wiwi，因此处于场地中的人其坐标应满足 1≤ai≤wi1≤ai≤wi（1≤i≤k1≤i≤k）。

小 C 打算在接下来的 P=w1×w2×⋯×wkP=w1×w2×⋯×wk 天中，每天从场地中一个新的位置出发，开始他的刷步数计划（换句话说，他将会从场地中每个位置都出发一次进行计划）。

他的计划非常简单，每天按照事先规定好的路线行进，每天的路线由 nn 步移动构成，每一步可以用 cici 与 didi 表示：若他当前位于 (a1,a2,…,aci,…,ak)(a1,a2,…,aci,…,ak)，则这一步他将会走到 (a1,a2,…,aci+di,…,ak)(a1,a2,…,aci+di,…,ak)，其中 1≤ci≤k1≤ci≤k，di∈{−1,1}di∈{−1,1}。小 C 将会不断重复这个路线，直到他走出了场地的范围才结束一天的计划。（即走完第 nn 步后，若小 C 还在场内，他将回到第 11 步从头再走一遍）。

小 C 对自己的速度非常有自信，所以他并不在意具体耗费的时间，他只想知道 PP 天之后，他一共刷出了多少步微信步数。请你帮他算一算。

输入格式

第一行两个用单个空格分隔的整数 n,kn,k。分别表示路线步数与场地维数。

接下来一行 kk 个用单个空格分隔的整数 wiwi，表示场地大小。

接下来 nn 行每行两个用单个空格分隔的整数 ci,dici,di，依次表示每一步的方向，具体意义见题目描述。

输出格式

仅一行一个整数表示答案。答案可能很大，你只需要输出其对 109+7109+7 取模后的值。

若小 C 的计划会使得他在某一天在场地中永远走不出来，则输出一行一个整数 −1−1。

样例数据

3 2
3 3
1 1
2 -1
1 1

21

5 4
6 8 6 5
3 1
2 1
1 1
2 1
2 -1

10265

5 5
3 3 1 3 2
4 1
4 -1
1 -1
3 -1
2 1

150

100 3
8 7 6
1 1
1 -1
3 1
3 -1
3 1
3 -1
3 1
3 -1
1 1
1 -1
1 1
1 -1
2 1
2 -1
1 1
1 -1
2 1
2 -1
3 1
3 -1
3 1
3 -1
3 1
3 -1
2 1
2 -1
3 1
3 -1
3 1
3 -1
1 1
1 -1
1 1
1 -1
3 1
3 -1
3 1
3 -1
1 1
1 -1
1 1
1 -1
2 1
2 -1
1 1
1 -1
2 1
2 -1
2 1
2 -1
2 1
2 -1
3 1
3 -1
1 1
1 -1
3 1
3 -1
3 1
3 -1
3 1
3 -1
3 1
3 -1
1 1
1 -1
3 1
3 -1
1 1
1 -1
2 1
2 -1
1 1
1 -1
1 1
1 -1
2 1
2 -1
2 1
2 -1
1 1
1 -1
3 1
3 -1
1 1
1 -1
2 1
2 -1
1 1
1 -1
3 1
3 -1
3 1
3 -1
3 1
3 -1
2 1
2 -1
3 1
3 -1

-1

数据范围

【样例 #1 解释】

从 (1,1)(1,1) 出发将走 22 步，从 (1,2)(1,2) 出发将走 44 步，从 (1,3)(1,3) 出发将走 44 步。

从 (2,1)(2,1) 出发将走 22 步，从 (2,2)(2,2) 出发将走 33 步，从 (2,3)(2,3) 出发将走 33 步。

从 (3,1)(3,1) 出发将走 11 步，从 (3,2)(3,2) 出发将走 11 步，从 (3,3)(3,3) 出发将走 11 步。

共计 2121 步。

【数据范围】

对于所有测试点，保证 1≤n≤5×1051≤n≤5×105，1≤k≤101≤k≤10，1≤wi≤1091≤wi≤109，di∈{−1,1}di∈{−1,1}。

#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= int(b); i++)
#define per(i, a, b) for (int i = (a); i >= int(b); i--)
using namespace std;
 
typedef long long ll;
const int maxn = 5e5, mod = 1e9 + 7;
 
int n, k, w[10], c[maxn + 5], d[maxn + 5], dt[10], res, S[11][11], inv[12];
 
struct foo {
    int z[10], l[10], r[10];
    void reset() {
        memset(z, 0, k << 2);
        memset(l, 0, k << 2);
        memset(r, 0, k << 2);
    }
    foo() {
        reset();
    }
    int walk(int c, int d) {
        z[c] += d;
        if (z[c] < l[c] || z[c] > r[c]) {
            l[c] = min(l[c], z[c]);
            r[c] = max(r[c], z[c]);
            return d;
        }
        return 0;
    }
} F, B;
 
inline void red(int &x) {
    x += x >> 31 & mod;
}
 
void prework(int n) {
    S[0][0] = 1;
    rep(i, 1, n) rep(j, 1, i) {
        S[i][j] = (S[i - 1][j - 1] + ll(S[i - 1][j]) * j) % mod;
    }
    inv[1] = 1;
    rep(i, 2, n + 1) {
        inv[i] = ll(mod - mod / i) * inv[mod % i] % mod;
    }
}
 
int calc(int k, int n) {
    int s = 0, c = 1;
    rep(i, 0, k) {
        c = ll(c) * max(0, n - i) % mod;
        s = (s + ll(c) * inv[i + 1] % mod * S[k][i]) % mod;
    }
    return s;
}
 
int work(int a[]) {
    int lim = mod;
    rep(i, 0, k - 1) if (dt[i]) {
        lim = min(lim, (a[i] + dt[i] - 1) / dt[i]);
    }
    int dp[11] = { 1 };
    rep(i, 0, k - 1) {
        per(j, i, 0) {
            dp[j + 1] = (dp[j + 1] + ll(mod - dt[i]) * dp[j]) % mod;
            dp[j] = ll(a[i]) * dp[j] % mod;
        }
    }
    int res = 0;
    rep(i, 0, k) {
        res = (res + ll(dp[i]) * calc(i, lim)) % mod;
    }
    return res;
}
 
int main() {
    scanf("%d %d", &n, &k);
    prework(k);
    rep(i, 0, k - 1) {
        scanf("%d", &w[i]);
    }
    rep(i, 1, n) {
        scanf("%d %d", &c[i], &d[i]), c[i]--;
        if (F.walk(c[i], d[i]) && F.r[c[i]] - F.l[c[i]] <= w[c[i]]) {
            int x = 1;
            rep(j, 0, k - 1) if (j != c[i]) {
                x = ll(x) * max(0, w[j] - F.r[j] + F.l[j]) % mod;
            }
            res = (res + ll(i) * x) % mod;
        }
    }
    rep(i, 1, n) if (F.z[c[i]] < 0) {
        d[i] = -d[i];
    }
    rep(i, 0, k - 1) if (F.z[i] < 0) {
        F.z[i] = -F.z[i];
        swap(F.l[i], F.r[i]);
        F.l[i] = -F.l[i];
        F.r[i] = -F.r[i];
    }
    B = F;
    bool chk = true;
    rep(i, 0, k - 1) {
        dt[i] = B.z[i];
        chk &= dt[i] == 0;
    }
    if (chk) {
        bool ok = false;
        rep(i, 0, k - 1) {
            ok |= B.r[i] - B.l[i] >= w[i];
        }
        printf("%d\n", ok ? res : -1);
        exit(0);
    }
    int a[10] = {};
    rep(i, 1, n) {
        if (F.walk(c[i], d[i]) && F.r[c[i]] - F.l[c[i]] <= w[c[i]]) {
            bool ok = true;
            rep(j, 0, k - 1) if (j != c[i]) {
                ok &= w[j] - F.r[j] + F.l[j] > 0;
            }
            if (!ok) {
                continue;
            }
            rep(j, 0, k - 1) if (j != c[i]) {
                a[j] = w[j] - F.r[j] + F.l[j];
            }
            a[c[i]] = w[c[i]] - F.r[c[i]] + F.l[c[i]] + 1, res = (res + ll(i) * work(a)) % mod;
            a[c[i]] = w[c[i]] - F.r[c[i]] + F.l[c[i]], res = (res + ll(mod - i) * work(a)) % mod;
        }
    }
    rep(i, 0, k - 1) {
        a[i] = max(0, w[i] - B.r[i] + B.l[i]);
    }
    res = (res + ll(n) * work(a)) % mod;
    printf("%d\n", res);
    return 0;
}