题目
分析
由于某些原因，以下用「左侧点」和「右侧点」分别代替题目中的「妹子」和「男生」。
根据题意，显然能得出一个左侧点只能向一个或两个右侧点连边。这似乎启发我们把左侧点不看成点，而看成关于右侧的两个点之间的「关系」（更正：不看题解根本想不到）。换句话说，把左侧点看成边，右侧点看成点，就得到了一张 \(n\) 个点 \(m\) 条边的新图。如果一个左侧点向 \(a\) 和 \(b\) 两个右侧点连边，就在新图中加入一条连接 \((a,b)\) 的边（左侧点只连接一个右侧点就是自环）。
考虑左侧点必须选且仅选一个右侧点（注意题目中「保证左侧满匹配」），即新图中每条边必须选择它的一个端点；而新图中每个点只能被一条边选择。说得直观一点，就是要给每条边定向，指向哪个点就表示选择了这个点。同时每个点的入度最多为 \(1\) 。
那么问题就转化成了：给定一张无向图，要给每条边选择一个方向，满足每个点入度最多为 \(1\) 。每条边的两个方向分别有一个权值，要求最大化权值和。
看起来好像还是不可做？通过膜拜题解， 请再次注意这句话：保证左侧满匹配 。根据 霍尔定理 （证明先咕着），左侧满匹配当且仅当在左侧选出任意一个大小为 \(k(0\leq k\leq m)\) 的子集，与这个子集有边相连的右侧点至少有 \(k\) 个。放在新图上，任意选出 \(k\) 条边所对应的点集的大小不少于 \(k\) 。
这说明什么呢？考虑对于新图中的一个连通分量（即极大连通块），它的点数必须大于等于边数。而既然连通，点数最多是边数加 \(1\) 。因此一个连通分量的边数要么比点数少 \(1\) ，要么等于点数。即：要么是树，要么是基环树。这个图竟然有如此优美的性质。
基环树必然定向为基环外向树。对于基环树中的边，如果是树边，那么一定往远离环的方向连。而所有环边都必须连成一个方向（即要么全部顺时针，要么全部逆时针）。因此每个基环树只有两种方案：要么所有顺时针的环边加上外向树边，要么所有逆时针环边加上外向树边。维护这两种情况的答案即可。修改时如果是内向树边就不理（必不选），外向树边直接给最终答案加上差值（必选），环边就更新对应方向的答案。
树会定向成以一个点为根的有向树，因此要分别维护以每个点为根的答案。先随便以一个点为根求出 dfs 序，然后考虑每条边的贡献：如果一条边是从上往下的，那么当根不在 下端点 的子树内时会贡献答案；如果一条边是从下往上的，那么当根在下端点的子树内时会贡献答案。在线段树上区间修改并维护最大值即可。
代码
众所周知，基环树的题嘴起来容易（虽然这个题也不容易），写起来恶心。所以耐心地去写和调吧。
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <vector>
using namespace std;
namespace zyt
{
template<typename T>
inline bool read(T &x)
{
char c;
bool f = false;
x = 0;
do
c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF)
return false;
if (c == '-')
f = true, c = getchar();
do
x = x * 10 + c - '0', c = getchar();
while (isdigit(c));
if (f)
x = -x;
return true;
}
template<typename T>
inline void write(T x)
{
static char buf[20];
char *pos = buf;
if (x < 0)
putchar('-'), x = -x;
do
*pos++ = x % 10 + '0';
while (x /= 10);
while (pos > buf)
putchar(*--pos);
}
typedef pair<int, int> pii;
const int N = 5e5 + 10;
vector<pii> g[N];
int m, n, T, a[N], b[N], dfn[N], fa[N], out[N], dfncnt, ecnt, v[N << 1], val[N][2], rot[N], opp[N << 1];
bool iscir[N], incir[N], vis[N], dir[N << 1];
pii e[N << 1];
int f(const int x)
{
return x == fa[x] ? x : fa[x] = f(fa[x]);
}
void dfs(const int u, const int r)
{
vis[u] = true;
dfn[u] = ++dfncnt;
rot[u] = r;
for (vector<pii>::iterator it = g[u].begin(); it != g[u].end(); it++)
{
int v = it->first;
if (vis[v] || incir[v])
continue;
dfs(v, r);
}
out[u] = dfncnt;
}
int findcir(const int u, const int from)
{
static bool insta[N];
if (insta[u])
return u;
insta[u] = true;
for (vector<pii>::iterator it = g[u].begin(); it != g[u].end(); it++)
{
int v = it->first, tmp;
if (opp[it->second] == from)
continue;
if (~(tmp = findcir(v, it->second)))
{
insta[u] = false;
val[f(u)][0] += ::zyt::v[it->second];
val[f(u)][1] += ::zyt::v[opp[it->second]];
dir[it->second] = 0, dir[opp[it->second]] = 1;
incir[u] = true;
if (u != tmp)
return tmp;
else
return -1;
}
}
insta[u] = false;
return -1;
}
namespace Segment_Tree
{
struct node
{
int mx, tag;
}tree[N << 2];
void add(const int rot, const int x)
{
tree[rot].mx += x, tree[rot].tag += x;
}
void pushdown(const int rot)
{
if (tree[rot].tag)
{
add(rot << 1, tree[rot].tag);
add(rot << 1 | 1, tree[rot].tag);
tree[rot].tag = 0;
}
}
void update(const int rot)
{
tree[rot].mx = max(tree[rot << 1].mx, tree[rot << 1 | 1].mx);
}
void add(const int rot, const int lt, const int rt, const int ls, const int rs, const int x)
{
if (ls <= lt && rt <= rs)
return void(add(rot, x));
int mid = (lt + rt) >> 1;
pushdown(rot);
if (ls <= mid)
add(rot << 1, lt, mid, ls, rs, x);
if (rs > mid)
add(rot << 1 | 1, mid + 1, rt, ls, rs, x);
update(rot);
}
int query(const int rot, const int lt, const int rt, const int ls, const int rs)
{
if (ls <= lt && rt <= rs)
return tree[rot].mx;
int mid = (lt + rt) >> 1;
pushdown(rot);
if (rs <= mid)
return query(rot << 1, lt, mid, ls, rs);
else if (ls > mid)
return query(rot << 1 | 1, mid + 1, rt, ls, rs);
else
return max(query(rot << 1, lt, mid, ls, rs),
query(rot << 1 | 1, mid + 1, rt, ls, rs));
}
}
int work()
{
using namespace Segment_Tree;
read(m), read(n), read(T);
for (int i = 0; i < n; i++)
fa[i] = i;
for (int i = 0; i < m; i++)
read(a[i]);
for (int i = 0; i < m; i++)
read(b[i]);
for (int i = 0; i < m; i++)
{
int x, y;
x = (a[i] - b[i] + n) % n;
y = (a[i] + b[i]) % n;
if (x < y)
swap(x, y);
read(v[ecnt]);
e[ecnt] = pii(x, y);
//fprintf(stderr, "%d %d %d\n", x, y, v[ecnt]);
g[x].push_back(pii(y, ecnt++));
if (x != y)
{
read(v[ecnt]);
e[ecnt] = pii(y, x);
opp[ecnt - 1] = ecnt, opp[ecnt] = ecnt - 1;
//fprintf(stderr, "%d %d %d\n", y, x, v[ecnt]);
g[y].push_back(pii(x, ecnt++));
}
else
opp[ecnt - 1] = ecnt - 1;
if (f(x) == f(y))
iscir[f(x)] = true;
else
{
iscir[f(y)] |= iscir[f(x)];
fa[f(x)] = f(y);
}
}
for (int i = 0; i < n; i++)
if (i == f(i) && iscir[i])
findcir(i, -1);
for (int i = 0; i < n; i++)
if ((!iscir[f(i)] && i == f(i)) || incir[i])
dfs(i, i);
for (int i = 0; i < ecnt; i++)
{
if (iscir[f(e[i].first)])
{
if (!incir[e[i].first] || !incir[e[i].second])
{
if (dfn[e[i].first] < dfn[e[i].second])
val[f(e[i].first)][0] += v[i], val[f(e[i].first)][1] += v[i];
}
}
else
{
if (dfn[e[i].first] < dfn[e[i].second])
{
int r = rot[e[i].first];
add(1, 1, n, dfn[r], dfn[e[i].second] - 1, v[i]);
if (out[e[i].second] < out[r])
add(1, 1, n, out[e[i].second] + 1, out[r], v[i]);
}
else
add(1, 1, n, dfn[e[i].first], out[e[i].first], v[i]);
}
}
int q, ans = 0;
for (int i = 0; i < n; i++)
if (i == f(i))
{
if (iscir[i])
ans += max(val[i][0], val[i][1]);
else
ans += query(1, 1, n, dfn[rot[i]], out[rot[i]]);
}
write(ans), putchar('\n');
read(q);
while (q--)
{
int x, vv;
read(x), read(vv);
x -= ans * T, vv -= ans * T;
--x;
if (iscir[f(e[x].first)])
{
int t = f(e[x].first);
ans -= max(val[t][0], val[t][1]);
if (!incir[e[x].first] || !incir[e[x].second])
{
if (dfn[e[x].first] < dfn[e[x].second])
val[t][0] += vv - v[x], val[t][1] += vv - v[x];
}
else
{
val[t][dir[x]] += vv - v[x];
if (e[x].first == e[x].second)
val[t][dir[x] ^ 1] += vv - v[x];
}
ans += max(val[t][0], val[t][1]);
}
else
{
int r = rot[e[x].first];
ans -= query(1, 1, n, dfn[r], out[r]);
if (dfn[e[x].first] < dfn[e[x].second])
{
add(1, 1, n, dfn[r], dfn[e[x].second] - 1, vv - v[x]);
add(1, 1, n, out[e[x].second] + 1, out[r], vv - v[x]);
}
else
add(1, 1, n, dfn[e[x].first], out[e[x].first], vv - v[x]);
ans += query(1, 1, n, dfn[r], out[r]);
}
v[x] = vv;
write(ans), putchar('\n');
}
return 0;
}
}
int main()
{
return zyt::work();
}