2020/round2/circular_circles.cpp

// Circular Circles
// Solution by Jacob Plachta

#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]; // CS[i] = edge weights in circle i
multiset<int> HS[LIM][2]; // HS[i][j] = edge weights in half j of circle i
multiset<int> DS; // DS = circles' D values
multiset<int> IS; // IS = inter-circle edge weights

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;
  // init
  DS.clear(), IS.clear();
  Fox(i, N)
    CS[i].clear(), HS[i][0].clear(), HS[i][1].clear();
  // input
  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);
  // initialize edge info
  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);
  }
  // process events
  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);
}