菜菜种菜
已经提交 已经通过 时间限制：2000ms 内存限制：128MB
64.15%
提交人数：106
通过人数：68
题目描述
菜菜太菜，但他不想种菜。
有 nn 块土地，每块土地有一个菜值。它们之间有 mm 条小路，每条连接两块土地，小路只能单向通行，不存在一条小路两端连接同一块土地，但可能存在两条小路两端连接的土地分别相同。如果存在一条从土地 uu 到土地 vv 的小路，则称 uu 能直接到达 vv。
菜菜可以购买一些土地，他必须在其中选择一块建造自己的家，所购买的剩下的土地都被作为菜地。因为菜菜不想种菜，所以他希望从他家能直接到达的土地中，一块菜地也没有（如果菜菜家不能直接到达任何一块土地，这也能满足他的愿望）。
菜菜提出了 qq 个问题，每个问题给出 L,RL,R ，询问如果他购买了第 LL 到第 RR 块之间的所有土地，那么所有满足他愿望的建造家的选址的菜值之和是多少？
注意，本题空间限制为128MB
P.S. 本题标算有使用读入优化，相关资讯可参考oi-wiki --- 读入、输出优化
输入描述
第 11 行 33 个由空格隔开的整数 n,m,qn,m,q ，分别表示土地的块数、小路的条数和问题的个数。
第 22 行 nn 个由空格隔开的整数，第 ii 个数 a_iai 表示第 ii 块土地的菜值。
接下来 mm 行，每行 22 个由空格隔开整数 u_i,v_iui,vi，表示第 ii 条小路从第 u_iui 块土地通向第 v_ivi 块土地。
接下来 qq 行，每行 22 个由空格隔开整数 l_i,r_ili,ri，表示菜菜第 ii 个问题中购买了 [l_i,r_i][li,ri] 中的所有土地。
- 1\le n,m,q \le 10^61≤n,m,q≤106
- 1\le a_i\le 3001≤ai≤300
- 1\le u_i,v_i\le n,u_i\neq v_i1≤ui,vi≤n,ui=vi
- 1\le l_i\le r_i\le n1≤li≤ri≤n。
输出描述
为了避免输出量过大，设 ans_iansi 表示第 ii 个询问的答案。你只需要输出 11 行 11 个整数 {\rm xor}_{i=1}^qi\times ans_ixori=1qi×ansi，即所有询问的编号与答案的乘积依次按位异或 （c++中的64位整数^）的结果。
样例输入 1
4 2 2 3 5 10 6 1 4 2 3 2 3 1 3
样例输出 1
16
样例输入 2
5 6 3 114 29 219 231 165 5 4 1 2 1 3 5 3 3 2 3 4 2 2 1 2 4 5
样例输出 2
658
提示
对于样例1：第 11 次询问，33 号土地不能直接到达任何土地，是满足要求的，而 22 号土地能到达 33 号土地，33 在 [2,3][2,3] 之内是菜地，不能满足要求，所以这次询问的答案为 1010；第 22 次询问，11 号土地只能到达 44 号土地，不在 [1,3][1,3] 内，是满足要求的，33 号土地仍然满足要求，所以这次询问的答案为 1313。输出 (1\times10){\rm xor} (2\times13)=16(1×10)xor(2×13)=16 。
分析：比较容易想到，每个点都能对一些询问的区间产生贡献，这些区间的范围是由这个点的边决定的。
首先，这些区间要包含这个点，但又不能包含与这个点相连的边，令区间表示为[L,R]，有x<=L<=i,i<=R<=y，其中i表示这个点，x表示从i出去的点中所有小于i的最大的，y表示从i出去的点中所有大于i的最小的，具体画个图就清楚了。
现在我们得到了每个点能产生贡献的范围，问题在于如何统计贡献，也是一个比较套路的问题了，一般都使用bit来维护。
对于左端点很容易确定，将询问按L排序后，每次把不包含L的删掉，把包含L的加进去就可以了。
对于右端点，每个点有一个取值范围是[i,y]，因为我们只需要查询总和，所以在i的位置add上a[i]，在y+1位置上add上-a[i]，这样对于大于这个询问，就可以将贡献抵消掉了。
#include "bits/stdc++.h"
namespace fastIO {
#define BUF_SIZE 100000
bool IOerror = 0;
inline char nc() {
static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, BUF_SIZE, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
inline void read(int &x) {
char ch;
while (blank(ch = nc()));
if (IOerror) return;
// bool flag = 0;
// if (ch == '-') {
// ch = nc();
// flag = 1;
// }
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
// if (flag)x = -x;
}
inline void Out(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) {
Out(a / 10);
}
putchar(a % 10 + '0');
}
#undef BUF_SIZE
};
using namespace fastIO;
using namespace std;
struct BIT {
int n;
vector<int> v;
BIT(int n) : n(n) {
v.resize(n + 1);
}
void update(int x, int d) {
while (x <= n) {
v[x] += d;
x += (x & -x);
}
}
int que(int x) {
int res = 0;
while (x > 0) {
res += v[x];
x -= (x & -x);
}
return res;
}
} bit(1000004);
int a[1000004];
int ans[1000004];
int r[1000004];
struct node {
int l, r, id;
bool friend operator<(node a, node b) {
if (a.l == b.l)return a.r < b.r;
else return a.l < b.l;
}
} b[1000004], c[1000004];
priority_queue<int, vector<int>, greater<int> > pq;
int main() {
int n, m, q;
read(n);
read(m);
read(q);
for (int i = 1; i <= n; ++i) {
read(a[i]);
c[i].l = 1, c[i].r = r[i] = n;
c[i].id = i;
}
for (int i = 1; i <= m; ++i) {
int u, v;
read(u);
read(v);
if (v < u)c[u].l = max(c[u].l, v + 1);
else {
r[u] = c[u].r = min(c[u].r, v - 1);
}
}
for (int i = 1; i <= q; ++i) {
read(b[i].l);
read(b[i].r);
b[i].id = i;
}
sort(b + 1, b + 1 + q);
sort(c + 1, c + 1 + n);
int cnt = 1;
for (int i = 1; i <= q; ++i) {
while (cnt <= n && b[i].l >= c[cnt].l) {
bit.update(c[cnt].id, a[c[cnt].id]);
bit.update(c[cnt].r + 1, -a[c[cnt].id]);
pq.push(c[cnt].id);
cnt++;
}
while (pq.size() && pq.top() < b[i].l) {
int id = pq.top();
pq.pop();
bit.update(id, -a[id]);
bit.update(r[id] + 1, a[id]);
}
ans[b[i].id] = bit.que(b[i].r);
}
long long res = 0;
for (int i = 1; i <= q; ++i) {
res ^= 1LL * i * ans[i];
}
cout << res << endl;
}