|
|
|
|
|
|
| #include <algorithm>
|
| #include <functional>
|
| #include <numeric>
|
| #include <iostream>
|
| #include <iomanip>
|
| #include <cstdio>
|
| #include <cmath>
|
| #include <complex>
|
| #include <cstdlib>
|
| #include <ctime>
|
| #include <cstring>
|
| #include <cassert>
|
| #include <string>
|
| #include <vector>
|
| #include <list>
|
| #include <map>
|
| #include <set>
|
| #include <unordered_map>
|
| #include <unordered_set>
|
| #include <deque>
|
| #include <queue>
|
| #include <stack>
|
| #include <bitset>
|
| #include <sstream>
|
| using namespace std;
|
|
|
| #define LL long long
|
| #define LD long double
|
| #define PR pair<int,int>
|
|
|
| #define Fox(i,n) for (i=0; i<n; i++)
|
| #define Fox1(i,n) for (i=1; i<=n; i++)
|
| #define FoxI(i,a,b) for (i=a; i<=b; i++)
|
| #define FoxR(i,n) for (i=(n)-1; i>=0; i--)
|
| #define FoxR1(i,n) for (i=n; i>0; i--)
|
| #define FoxRI(i,a,b) for (i=b; i>=a; i--)
|
| #define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
|
| #define Min(a,b) a=min(a,b)
|
| #define Max(a,b) a=max(a,b)
|
| #define Sz(s) int((s).size())
|
| #define All(s) (s).begin(),(s).end()
|
| #define Fill(s,v) memset(s,v,sizeof(s))
|
| #define pb push_back
|
| #define mp make_pair
|
| #define x first
|
| #define y second
|
|
|
| template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
|
| template<typename T> T Sqr(T x) { return(x * x); }
|
| string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }
|
|
|
| const int INF = (int)1e9;
|
| const LD EPS = 1e-12;
|
| const LD PI = acos(-1.0);
|
|
|
| #define GETCHAR getchar_unlocked
|
|
|
| bool Read(int& x) {
|
| char c, r = 0, n = 0;
|
| x = 0;
|
| for (;;) {
|
| c = GETCHAR();
|
| if ((c < 0) && (!r))
|
| return(0);
|
| if ((c == '-') && (!r))
|
| n = 1;
|
| else if ((c >= '0') && (c <= '9'))
|
| x = x * 10 + c - '0', r = 1;
|
| else if (r)
|
| break;
|
| }
|
| if (n)
|
| x = -x;
|
| return(1);
|
| }
|
|
|
| #define LIM 1000001
|
| #define MOD 1000000007
|
|
|
| int N, M, E, K;
|
| int X[LIM], Y[LIM], I[LIM], W[LIM], EW[LIM];
|
|
|
| LL sumR;
|
| multiset<int> CS[LIM];
|
| multiset<int> HS[LIM][2];
|
| multiset<int> DS;
|
| multiset<int> IS;
|
|
|
| void ReadSeq(int* V, int N, int K, int mod)
|
| {
|
| int i, A, B, C;
|
| Fox(i, K)
|
| Read(V[i]);
|
| Read(A), Read(B), Read(C);
|
| FoxI(i, K, N - 1)
|
| V[i] = ((LL)A * V[i - 2] + (LL)B * V[i - 1] + C) % mod;
|
| }
|
|
|
| void UpdateSet(multiset<int>& S, int v1, int v2)
|
| {
|
| assert(*S.find(v1) == v1);
|
| S.erase(S.find(v1));
|
| S.insert(v2);
|
| }
|
|
|
| int GetCircleR(int i) { return(*CS[i].rbegin()); }
|
|
|
| int GetCircleD(int i) { return(*HS[i][0].rbegin() + *HS[i][1].rbegin() - *CS[i].rbegin()); }
|
|
|
| int GetHalf(int i, int j) { return(X[i] <= j && j < Y[i] ? 0 : 1); }
|
|
|
| void UpdateCircleEdge(int i, int j, int w1, int w2)
|
| {
|
| int r1 = GetCircleR(i), d1 = GetCircleD(i);
|
| UpdateSet(CS[i], w1, w2);
|
| UpdateSet(HS[i][GetHalf(i, j)], w1, w2);
|
| int r2 = GetCircleR(i), d2 = GetCircleD(i);
|
| sumR += r2 - r1;
|
| UpdateSet(DS, d1, d2);
|
| }
|
|
|
| int ProcessCase()
|
| {
|
| int i, j;
|
| LL sumW;
|
|
|
| DS.clear(), IS.clear();
|
| Fox(i, N)
|
| CS[i].clear(), HS[i][0].clear(), HS[i][1].clear();
|
|
|
| Read(N), Read(M), Read(E), Read(K);
|
| ReadSeq(X, N, K, M);
|
| ReadSeq(Y, N, K, M);
|
| ReadSeq(I, E, K, N * M + N);
|
| ReadSeq(W, E, K, INF);
|
|
|
| sumW = N * M + N;
|
| sumR = N;
|
| Fox(i, N * M + N)
|
| EW[i] = 1;
|
| Fox(i, N)
|
| {
|
| if (X[i] > Y[i])
|
| swap(X[i], Y[i]);
|
| Fox(j, 2)
|
| HS[i][j].insert(0);
|
| Fox(j, M)
|
| {
|
| CS[i].insert(1);
|
| HS[i][GetHalf(i, j)].insert(1);
|
| }
|
| DS.insert(GetCircleD(i));
|
| IS.insert(1);
|
| }
|
|
|
| int ans = 1;
|
| Fox(i, E)
|
| {
|
| j = I[i];
|
| int w1 = EW[j], w2 = W[i];
|
| EW[j] = w2;
|
| sumW += w2 - w1;
|
| if (j < N * M)
|
| UpdateCircleEdge(j / M, j % M, w1, w2);
|
| else
|
| UpdateSet(IS, w1, w2);
|
| LL cur = sumW - sumR - max(*DS.rbegin(), *IS.rbegin());
|
| ans = ans * (cur % MOD) % MOD;
|
| }
|
| return(ans);
|
| }
|
|
|
| int main()
|
| {
|
| int T, t;
|
| Read(T);
|
| Fox1(t, T)
|
| printf("Case #%d: %d\n", t, ProcessCase());
|
| return(0);
|
| } |
