【模拟+hash+并查集】2014 Multi-University Training Contest 2｜HDU_4879 ZCC loves march

原题直通车：HDU_4879 ZCC loves march

题意概述：在m*m（m<=10^18）的矩阵中有n（n<=10^5）个数（1~n），有k（k<=10^5）次操作，有以下两种操作：

1、将一个数i在同一行或同一列上移动d个单位

2、将与数i在同一行或同一列的所有数都移到i所在的位置，并输出所有(xi-xj)^2+(yi-yj)^2的和

分析：

1、因为只有移动和操作，所以占用到的坐标数最多为n+k个，所以用一个map将每个坐标映射到一个数。

2、对于操作2，为了便于查到每一行、每一列中有多少个数，所以用map映射到每一行、列分别一个set集合

3、放到每个set集合中的并不是n个数，而是每一个坐标的映射，因为每个坐标可能有多个数，但映射只有一个（理论上是），只要记录每个坐标上有多少个数即可，因为结果只与坐标有关，与n个数无关，以此避免TLE和MLE。

4、一个数只对应一个坐标，移动的时候，可以直接看成坐标的变化，也就是对应坐标映射的变化，所以只需用一个next数据记录移动的位置，数的数量直接相加即可。

5、虽然经过操作2之后，坐标中已经没有数了，但是后面可能会用到相应的next，所以经过了操作2的坐标要重新开辟一个映射，才不会和后面进行操作1时移动到这种坐标的数相应的next冲突。

附：2014 Multi-University Training Contest 2--by 镇海中学
解题报告

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<set>
using namespace std;
const int maxn = 1e5+100;
const int mod = 1e9+7;

int fa[maxn], num[maxn<<1], next[maxn<<1];
long long x[maxn<<1], y[maxn<<1];

typedef long long LL;
typedef pair<LL, LL> pl;
typedef map< pl, int > map_pl;
typedef map< LL, set<int> > map_LL;
typedef pair< map_LL::iterator, map_LL::iterator > pll;

map_LL mx, my;
map_pl M;

int n;
LL m, len, ans, d;

void Input() {
for(int i=1; i<=n; ++i) {
long long xx, yy;
scanf("%I64d%I64d", &xx, &yy);
pl p = make_pair(xx, yy);
if(M[p] == 0) {
x[len] = xx, y[len] = yy, num[len] = 0, next[len] = len;

pll px = mx.equal_range(xx), py = my.equal_range(yy);
if(px.first == px.second) { set<int>s; mx[xx] = s; } //还没有映射的集合
if(py.first == py.second) { set<int>s; my[yy] = s; }
mx[xx].insert(len), my[yy].insert(len);

M[p] = len++;
}
num[M[p]]++;
fa[i] = M[p];
}
}

int get_end(int rt) { //寻找最终的移动位置
return next[rt] == rt ? rt : (next[rt] = get_end(next[rt]));
}

int main() {
while(~scanf("%d%I64d", &n, &m)) {
len = 1, ans = 0;
mx.clear(), my.clear(), M.clear();
Input();
int k, o; scanf("%d", &k);
while(k--) {
char op[5];
scanf("%s%d", op, &o);
o ^= ans;
int rt = get_end(fa[o]);
fa[o] = rt; //指向移动的位置

pl p = make_pair(x[rt], y[rt]);
if(op[0] == 'Q') {
ans = 0;
set<int>sx = mx[x[rt]], sy = my[y[rt]]; //同行、同列的坐标
set<int>::iterator it;
for(it=sx.begin(); it!=sx.end(); ++it)
if((*it) != rt) {
int ne = get_end(*it);
long long u = (y[ne] - y[rt] + mod) % mod;
u = ( (u * u)%mod )*num[ne] %mod;
ans = (ans + u) % mod;
my[y[ne]].erase(ne);
num[rt] += num[ne], num[ne] = 0, next[ne] = rt;
M[make_pair(x[ne], y[ne])] = 0;  // 对应的位置不能再用，因为可能有其它的next指向这里
}
for(it=sy.begin(); it!=sy.end(); ++it)
if((*it) != rt) {
int ne = get_end(*it);
long long u = (x[ne] - x[rt] + mod) % mod;
u = ( (u * u)%mod )*num[ne] %mod;
ans = (ans + u) % mod;
my[x[ne]].erase(ne);
num[rt] += num[ne], num[ne] = 0, next[ne] = rt;
M[make_pair(x[ne], y[ne])] = 0; // 对应的位置不能再用，因为可能有其它的next指向这里
}
printf("%I64d\n", ans);
continue;
}
scanf("%I64d", &d);
long long xx = x[rt], yy = y[rt];
if(op[0] == 'U') xx -= d;
if(op[0] == 'D') xx += d;
if(op[0] == 'L') yy -= d;
if(op[0] == 'R') yy += d;
num[rt]--;
p = make_pair(xx, yy);
if(M[p] == 0) {
x[len] = xx, y[len] = yy, num[len] = 0, next[len] = len;
M[p] = len++;
}
fa[o] = M[p]; //o被移动到M[p]坐标，直接改变坐标指向
num[M[p]]++;
}
}
return 0;
}