poj1182和ural1003

poj1182

并查集的运用，集合之间的关系表示，增加一个字段来表示和跟的关系r[x]

如果r[x] == 0表示和根同类，r[x] == 1表示根吃x，r[x] == 2表示x吃根。

那么现在如果x,y的关系为r[y],y,z的关系为r[z]，那么x和z的关系则是(r[y] + r[z]) % 3。不妨画个图看看。

现在读入一个陈述：

1.如果x,y在同一个集合里面：

1. 1 x y陈述x,y是同类，

那么根据他们与根的关系来判断，如果r[x] != r[y]，则说明他们不是同类

2. 2 x y陈述x吃y，那么x与根的关系为r[x],y与根的关系为r[y]，那么根与x的关系为3 - r[x],

所以y与x的关系为3 - r[x] + r[y]，x吃y，则表示为 (3 - r[x] + r[y]) % 3 == 1。明显以x为根的话,y对x关系就是1.

如果x,y不在一个集合里面，则合并集合，

现在要修改根的关系。

首先father[x]和x的关系为r[x]，x和y的关系为d - 1，那么father[x]和y的关系为 r[x] + d - 1;

father[y]和y的关系为r[y],那么y和father[y]的关系为3 - r[y]，那么father[x]和father[y]的关系为 r[x] + d - 1 + 3 - r[y]。

更新r[father[y]]即可。

ural1003:

与poj1182类似。

i, j为偶，则说明i和j - 1的关系为同奇偶。

同理表示为不同奇偶。

r[x] == 0表示和根同奇偶，r[x] == 1表示和根不同奇偶。

那么关系更改就简单很多了比poj1182.

注意一点是，首先要离散化，离散化之后还要注意规定了一个长度，如果他说的大于这个长度很定是假的。

然后答案可能是0.

poj1182

AC代码

#include <cstdio>
#include <cstring>

const int maxn = 50007;

int father[maxn], r[maxn];

int find(int a) {
if (a == father[a]) {
return a;
}
else {
int t = father[a];
father[a] = find(father[a]);
r[a] = (r[a] + r[t]) % 3;
return father[a];
}
}

void union_set(int a, int b, int d) {
int x = find(a);
int y = find(b);
father[y] = x;
r[y] = (r[a] + d - 1 + 3 - r[b]) % 3;
}

int main() {
//    freopen("input.txt", "r", stdin);
int n, m;
int ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
father[i] = i;
r[i] = 0;
}
while (m--) {
int type, a, b;
scanf("%d%d%d", &type, &a, &b);
if (a > n || b > n || (type == 2 && a == b)) {
ans++;
continue;
}
int x = find(a);
int y = find(b);
if (x == y) {
if ((type == 1 && (r[a] != r[b]))) {
ans++;
}
else if (type == 2 && (3 - r[a] + r[b]) % 3 != 1) {
ans++;
}
}
else {
union_set(a, b, type);
}
}
printf("%d\n", ans);
return 0;
}

ural1003

#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>

using namespace std;
const int maxn = 5007;

struct Seg {
int left, right, type;
};
struct Seg seg[maxn];
int father[maxn], r[maxn], ar[maxn], length, cnt;
map<int, int> maps;

void init() {
length = 1;
for (int i = 2; i <= cnt; i++) {
if (ar[i] != ar[i - 1]) {
length++;
ar[length] = ar[i];
}
}
}

int find(int x) {
if (x == father[x]) {
return x;
}
else {
int t = father[x];
father[x] = find(father[x]);
r[x] = (r[x] + r[t]) % 2;
return father[x];
}
}

int binarySearch(int a) {
int low = 1;
int high = length;
while (low <= high) {
int mid = (low + high) >> 1;
if (ar[mid] == a) {
return mid;
}
else if (ar[mid] > a) {
high = mid - 1;
}
else {
low = mid + 1;
}
}
return -1;
}

void union_set(int a, int b, int type) {
int x = find(a);
int y = find(b);
father[y] = x;
r[y] = (r[a] + type + 2 - r[b]) % 2;
}
int main() {
//    freopen("input.txt", "r", stdin);
while (scanf("%d", &length) != EOF) {
if (length == -1) {
break;
}
int m;
scanf("%d", &m);
maps.clear();
cnt = 0;
int flag = 0;
int s_m = m;
for (int i = 1; i <= m; i++) {
int a, b;
char even[30];
scanf("%d%d%s", &a, &b, even);
if (!flag && (a > length || b > length)) {
flag = 1;
s_m = i - 1;
}
ar[++cnt] = a - 1;
ar[++cnt] = b;
seg[i].left = a - 1;
seg[i].right = b;
if (even[0] == 'e') {
seg[i].type = 0;
}
else {
seg[i].type = 1;
}
}
sort(ar + 1, ar + 1 + cnt);
init();
int ans = 0;
for (int i = 1; i <= length; i++) {
father[i] = i;
r[i] = 0;
}
for (int i = 1; i <= m && i <= s_m; i++) {
int left = binarySearch(seg[i].left);
int right = binarySearch(seg[i].right);
int x = find(left);
int y = find(right);
if (x == y) {
if (seg[i].type == 0 && r[left] != r[right]) {
break;
}
else if (seg[i].type == 1 && (r[left] + r[right]) != 1) {
break;
}
}
else {
union_set(left, right, seg[i].type);
}
ans = i;
}
printf("%d\n", ans);
}
}