int main()
{
int i;
ELE_TYPE ele;
for (i = 1; i <= SET_CNT; i++) {
ele = (ELE_TYPE)i;
make_set(ele);
}
for (i = 1; i <= SET_CNT - 1; i += 2) {
union_set(i, i + 1);
}
for (i = 1; i <= SET_CNT - 3; i += 4) {
union_set(i, i + 2);
}
union_set(1, 5);
union_set(11, 13);
union_set(1, 10);
printf("%d\n", find_set(2)->ele);
printf("%d\n", find_set(9)->ele);
return 0;
}
int main()
{
double cost;
int m, i, j;
scanf("%d %d", &n, &m);
for(i = 1;i <= n; i++)
{
rank[i] = 0;
parent[i] = i;
scanf("%d %d", &x[i], &y[i]);
}
tot = 0;
for(i = 1;i <= n; i++)
{
for(j = i + 1;j <= n; j++)
{
e[tot].u = i;
e[tot].v = j;
e[tot].w = dis((double)x[i], (double)y[i], (double)x[j], (double)y[j]);
tot++;
}
}
while(m--)
{
scanf("%d %d", &i, &j);
union_set(i, j);
}
cost = 0.0;
qsort((void*)e, tot, sizeof(e[0]), cmp);
for(i = 0;i < tot; i++) if(union_set(e[i].u, e[i].v)) cost += e[i].w;
printf("%0.2lf\n", cost);
return 0;
}
/**
* Find in/out
*/
void find_inout()
{
struct block *b = first_block;
struct block *tmpb = (struct block *) malloc(sizeof(struct block));
int i;
int change = 1;
int oldlen;
calc_pred();
DEBUG(print_pred());
while(b) {
b->defin.ini = 0;
copy_set(b, OUT_SET, b, GEN_SET);
b = b->next;
}
while(change) {
change = 0;
b = first_block;
while(b) {
for(i = 0; i < b->predi; i++)
union_set(b, IN_SET, b->pred[i], OUT_SET);
copy_set(tmpb, IN_SET, b, IN_SET);
sub_set(tmpb, IN_SET, b, KILL_SET);
union_set(tmpb, IN_SET, b, GEN_SET);
oldlen = b->defin.outi;
// According to algorithm I should do what is commented belove
/*
copy_set(oldb, OUT_SET, b, OUT_SET);
copy_set(b, OUT_SET, tmpb, IN_SET);
if(!equal_set(oldb, OUT_SET, b, OUT_SET))
change = 1;
*/
// but since out[b] = gen[b] we can do
// 1. union agains copy
// 2. compare set's length to see if it's changed
union_set(b, OUT_SET, tmpb, IN_SET);
if(oldlen != b->defin.outi)
change = 1;
b = b -> next;
}
}
}
int detect_cycle(int graph[MAXSIZE][MAXSIZE], int V, struct node * hash_table[MAXSIZE])
{
int i;
int j;
int flag;
int count;
int temp_parent;
for (i = 1; i <= V; i++) {
for (j = 1; j <= V; j++) {
if (graph[i][j] == 1) {
if (find_set(hash_table, i) != find_set(hash_table, j)) {
union_set(hash_table, i, j);
graph[i][j] = 0;
graph[j][i] = 0;
flag = 0;
} else {
flag = 1;
break;
}
}
}
}
return flag;
}
void tarjan(int node) {
if(vindex[node] != -1) return;
vindex[node] = idx; // Set the depth index for v
vlowlink[node] = idx;
idx++;
S.push(node); // Push v on the stack
vinstack[node] = true;
for(vector<int>::iterator it = g[node].begin(); it != g[node].end(); it++) {
// Consider successors of v
if (vindex[*it] == -1) { // Was successor v' visited?
tarjan(*it); // Recurse
if(vlowlink[node] > vlowlink[*it])
vlowlink[node] = vlowlink[*it];
} else if(vinstack[*it]) { // Is v' on the stack?
if(vlowlink[node] > vindex[*it])
vlowlink[node] = vindex[*it];
}
}
if (vlowlink[node] == vindex[node]) { // Is v the root of an SCC?
int nodep;
do {
nodep = S.top();
S.pop();
vinstack[nodep] = false;
union_set(node, nodep);
// Add all nodes in SCC to a set
} while(nodep != node);
}
}
int main(void){
int i,x,y,result;
int in=1;
while(1){
result=0;
scanf("%d %d",&n,&m);
if(n==0&&m==0){
break;
}
for(i=1;i<=n;i++){
set[i]=i;
occ[i]=0;
}
for(i=0;i<m;i++){
scanf("%d %d",&x,&y);
union_set(x,y);
}
for(i=1;i<=n;i++){
x=find(i);
if(!occ[x]){
occ[x]=1;
result++;
}
}
printf("Case %d: %d\n",in++,result);
}
return 0;
}
int main()
{
char a[11], b[12];
int cnt, i, j;
make_set();
init();
while(scanf("%s %s", a, b) != EOF)
{
i = insert(a);
j = insert(b);
deg[i]++;
deg[j]++;
union_set(i, j);
}
cnt = 0;
for(i = 0;i < tot; i++) if(deg[i] % 2) cnt++;
if(cnt > 2) printf("Impossible\n");
else
{
j = find_set(0);
for(i = 1;i < tot; i++) if(find_set(i) != j) {printf("Impossible\n"); return 0;}
printf("Possible\n");
}
return 0;
}
vector<int> numIslands2(int m, int n, vector<pair<int, int>>& positions) {
vector<int> numbers;
int number = 0;
vector<pair<int, int>> directions{{0, -1}, {0, 1},
{-1, 0}, {1, 0}};
unordered_map<int, int> set;
for (auto& position : positions) {
auto& node = make_pair(position.first, position.second);
set[node_id(node, n)] = node_id(node, n);
++number;
for (auto& d : directions) {
auto& neighbor = make_pair(position.first + d.first,
position.second + d.second);
if (neighbor.first >= 0 && neighbor.first < m &&
neighbor.second >= 0 && neighbor.second < n &&
set.find(node_id(neighbor, n)) != set.end()) {
if (find_set(node_id(node, n), &set) !=
find_set(node_id(neighbor, n), &set)) {
// Merge different islands.
union_set(&set, node_id(node, n), node_id(neighbor, n));
--number;
}
}
}
numbers.emplace_back(number);
}
return numbers;
}
int main()
{
int caseN;
scanf("%d", &caseN);
for (int cs = 1; cs <= caseN; cs++) {
int n, m;
bool found = false;
scanf("%d %d", &n, &m);
init(n);
for (int i = 0, a, b; i < m; i++) {
scanf("%d %d", &a, &b);
int ta = find(a), tb = find(b);
if (ta != tb) {
union_set(a, b);
} else if (rel[a] == rel[b]) {
found = true;
}
}
printf("Scenario #%d:\n", cs);
printf("%s\n", found ? "Suspicious bugs found!" : "No suspicious bugs found!");
if (cs < caseN) {
printf("\n");
}
}
return 0;
}
/**
* @param n an integer
* @param m an integer
* @param operators an array of point
* @return an integer array
*/
vector<int> numIslands2(int m, int n, vector<pair<int, int>>& positions) {
vector<int> numbers;
int number = 0;
const vector<pair<int, int>> directions{{0, -1}, {0, 1},
{-1, 0}, {1, 0}};
vector<int> set(m * n, -1);
for (const auto& position : positions) {
const auto& node = make_pair(position.first, position.second);
set[node_id(node, n)] = node_id(node, n);
++number;
for (const auto& d : directions) {
const auto& neighbor = make_pair(position.first + d.first,
position.second + d.second);
if (neighbor.first >= 0 && neighbor.first < m &&
neighbor.second >= 0 && neighbor.second < n &&
set[node_id(neighbor, n)] != -1) {
if (find_set(node_id(node, n), &set) !=
find_set(node_id(neighbor, n), &set)) {
// Merge different islands, amortised time: O(log*k) ~= O(1)
union_set(&set, node_id(node, n), node_id(neighbor, n));
--number;
}
}
}
numbers.emplace_back(number);
}
return numbers;
}
int main()
{
int n, m, i, x, y, count;
while (scanf("%d", &n) != EOF && n != 0) {
for (i = 1; i <= n; i ++) {
father[i] = i;
}
for (scanf("%d", &m); m > 0; m --) {
scanf("%d %d", &x, &y);
union_set(x, y);
}
for (count = 0, i = 1; i <= n; i ++) {
if (father[i] == i) {
count ++;
}
}
printf("%d\n", count - 1);
}
return 0;
}
void form_kruskal_mst(int graph[MAXSIZE][MAXSIZE], int V, int edge_weights[MAXSIZE][MAXSIZE],
struct node * hash_table[MAXSIZE], struct pq_element mst[MAXSIZE])
{
struct pq_element edge_queue[MAXSIZE];
struct pq_element temp;
int num_edges;
int i;
int j;
int N;
num_edges = 0;
N = 0;
for (i = 1; i <= V; i++) {
for (j = 1; j <= V; j++) {
if (edge_weights[i][j] != 0) {
priority_enqueue(edge_queue, &N, i, j, edge_weights[i][j]);
edge_weights[i][j] = 0;
edge_weights[j][i] = 0;
}
}
}
for (i = 0; i < N; i++) {
temp = priority_dequeue(edge_queue, &N);
if (find_set(hash_table, temp.V1) != find_set(hash_table, temp.V2)) {
mst[num_edges] = temp;
num_edges++;
union_set(hash_table, temp.V1, temp.V2);
}
}
}
int main()
{
int n, m, i, x, y, count;
while (scanf("%d\n", &n) != EOF && n != 0) {
// 初始化并查集
for (i = 1; i <= n; i ++) {
father[i] = i;
}
// 合并并查集
for (scanf("%d", &m); m > 0; m --) {
scanf("%d %d", &x, &y);
union_set(x, y);
}
// 判断连通子图个数
for (count = 0, i = 1; i <= n; i ++) {
if (father[i] == i) {
count ++;
}
}
if (count == 1) {
printf("YES\n");
}else {
printf("NO\n");
}
}
return 0;
}
void init()
{
int i, j, k, u, v;
scanf("%d", &n); getchar();
memset(visited, 0, sizeof(visited));
memset(outdeg, 0, sizeof(outdeg));
memset(indeg, 0, sizeof(indeg));
memset(first, -1, sizeof(first));
memset(ar, 0, sizeof(ar));
tot = -1; cnt = 0;
for(i = 1;i <= n; i++) gets(list[i]);
qsort((void*)&list[1], n, sizeof(list[1]), cmp);
make_set();
for(i = 1;i <= n; i++)
{
j = list[i][0] - 'a' + 1;
k = list[i][strlen(list[i]) - 1] - 'a' + 1;
if(visited[j] == 0) visited[j] = ++cnt;
if(visited[k] == 0) visited[k] = ++cnt;
u = visited[j];
v = visited[k];
add(u, v, i);
union_set(u, v);
outdeg[u]++;
indeg[v]++;
ar[u]--; ar[v]++;
}
}
int main()
{
struct node * hash_table[MAXSIZE] = {NULL};
int N;
char choice[10];
char choice2[10];
int element;
int rep_element;
int rep_element1;
int rep_element2;
do {
scanf("%s", choice);
switch (choice[0]) {
case 'm' : scanf("%s %d", choice2, &element);
make_set(hash_table, element);
break;
case 'f' : scanf("%s %d", choice2, &element);
rep_element = find_set(hash_table, element);
printf("%d\n", rep_element);
break;
case 'u' : scanf("%d %d", &rep_element1, &rep_element2);
union_set(hash_table, rep_element1, rep_element2);
break;
case 'e' : break;
default : printf("Incorrect command!\n");
break;
}
} while (choice[0] != 'e');
return 0;
}
int main(void){
int x,y;
int i=1;
while(1){
scanf("%d %d",&x,&y);
if(x<0&&y<0){
break;
}
if(x==0&&y==0){
if(check()){
printf("Case %d is a tree.\n",i++);
}else{
printf("Case %d is not a tree.\n",i++);
}
initialize();
continue;
}
union_set(x,y);
if(!occ[x]){
treenode[nc++]=x;
occ[x]=1;
}
if(!occ[y]){
treenode[nc++]=y;
occ[y]=1;
}
indegree[y]++;
}
return 0;
}
int main()
{
int n,m,i,j,arr[1005],a,b,father;
while(scanf("%d",&n)!=EOF && n)
{
scanf("%d",&m);
for(i=1;i<=n;i++)
{
arr[i]=0;
fa[i]=i;
}
while(m--)
{
scanf("%d%d",&a,&b);
union_set(a,b);
arr[a]++;
arr[b]++;
}
father=find(1);
for(i=1;i<=n;i++)
{
if(arr[i]%2==1||fa[i]!=father)
{
printf("0\n");
break;
}
}
if(i>n)
printf("1\n");
}
return 0;
}
/**
* @param n an integer
* @param m an integer
* @param operators an array of point
* @return an integer array
*/
vector<int> numIslands2(int n, int m, vector<Point>& operators) {
vector<int> numbers;
int number = 0;
const vector<pair<int, int>> directions{{0, -1}, {0, 1},
{-1, 0}, {1, 0}};
unordered_map<int, int> set;
for (const auto& oper : operators) {
const auto& node = make_pair(oper.x, oper.y);
set[node_id(node, m)] = node_id(node, m);
++number;
for (const auto& d : directions) {
const auto& neighbor = make_pair(oper.x + d.first,
oper.y + d.second);
if (neighbor.first >= 0 && neighbor.first < n &&
neighbor.second >= 0 && neighbor.second < m &&
set.find(node_id(neighbor, m)) != set.end()) {
if (find_set(node_id(node, m), &set) !=
find_set(node_id(neighbor, m), &set)) {
// Merge different islands.
union_set(&set, node_id(node, m), node_id(neighbor, m));
--number;
}
}
}
numbers.emplace_back(number);
}
return numbers;
}
int main()
{
freopen("data.txt","r",stdin);
int n, i, j, x, y, k;
while(scanf("%d", &n) && n)
{
k = n * (n-1) / 2;
j = 0;
for(i = 0; i < k; i++)
{
scanf("%d%d%d", &e[j].x, &e[j].y, &e[j].w);
j++;
}
for(i = 0; i <= n; i++)
make_set(i);
qsort(e, j, sizeof(e[0]), cmp);
/*Kruscal过程求最小生成树*/
ans = 0;
for(i = 0; i < j; i++)
{
x = find_set(e[i].x);
y = find_set(e[i].y);
if(x != y)
union_set(x, y, e[i].w);
}
printf("%d\n", ans);
}
return 0;
}
int kruskal()
{
int cnt = 0, i;
qsort((void*)e, tot, sizeof(e[0]), cmp);
make_set(n);
for(i = 0;i < tot; i++) if(union_set(e[i].u, e[i].v)) cnt += e[i].w;
return cnt;
}
int main()
{
int x,y,i,flag,ti;
scanf("%d",&t);
for(ti=1;ti<=t;ti++)
{
flag=1;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
{
father[i]=i;
sex[i]=0;
}
while(m--)
{
scanf("%d%d",&x,&y);
if(find(x)==find(y))
{
flag=0;
continue;
}
if(sex[x]==0)
sex[x]=y;
else
{
union_set(sex[x],y);
}
if(sex[y]==0)
sex[y]=x;
else
{
union_set(x,sex[y]);
}
}
printf("Scenario #%d:\n",ti);
if(flag)
printf("No suspicious bugs found!\n\n");
else
printf("Suspicious bugs found!\n\n");
}
return 0;
}
// 2. 같은 분리집합인지 확인한다.
// 같은 분리집합인지 확인하는 방법은 부모를 찾아서 부모가 갖지 않음을 보이면 된다.
// 부모의 값은 -1
int find_set(int v1, int v2)
{
int i = v1, j = v2;
while (parent[i] >= 0)
i = parent[i];
while (parent[j] >= 0)
j = parent[j];
if (i != j)
union_set(i, j); // 최종 부모를 찾아 합집합을 진행
return i != j;
}
double kruskal()
{
double cost;
int i;
make_set(n);
cost = 0.0;
qsort((void*)e, tot, sizeof(e[0]), cmp);
for(i = 0;i < tot; i++)
if(union_set(e[i].u, e[i].v)) cost += e[i].w;
return cost;
}
int main()
{
int a, b;
while (EOF != scanf("%d", &n) && n != 0) {
init(n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
union_set(a, b);
}
int ans = 0;
int fp = find(1);
for (int i = 2; i <= n; i++) {
int fb = find(i);
if (fp != fb) {
ans++;
union_set(fp, fb);
}
}
printf("%d\n", ans);
}
return 0;
}
void repaire(int p)
{
double tmp;
int i;
work[p] = 1;
for(i = 1;i <= n; i++)
{
if(work[i] && i != p)
{
tmp = dis(p, i);
if(tmp <= d * d) union_set(p, i);
}
}
}
9 return A
// CPP CODE:
void kruskal() {
int i, u, v, cnt;
for (i = 0; i < cntNode; i++) make_set(i);
// sort the edge in increasing order.
qsort(edge, cntEdge, sizeof(Edge), cmp);
for (i = 0; i < cntEdge ; i++) {
int u = edge[i].u;
int v = edge[i].v;
if (find_set(u) != find_set(v)) {
union_set(u, v);
}
}
}
int main(void)
{
freopen("h.in","r",stdin);
freopen("h.out","w",stdout);
int i;
int max,min;
int s,e,a;
int tcase=1;
init_node(1,1,500000);
while(EOF != scanf("%d",&n))
{
init_p();
for(i=0;i<500006*4;i++)
{
node[i].max=-1;
node[i].min=500006*4;
}
for(i=1;i<=n;i++)
{
scanf("%d",&a);
insert(1,i,i,a);
}
scanf("%d",&m);
for(i=0;i<m;i++)
{
scanf("%d%d",&s,&e);
max=query_max(1,s,e);
min=query_min(1,s,e);
union_set(max,min);
}
scanf("%d",&k);
printf("CASE %d\n",tcase);
tcase++;
for(i=0;i<k;i++)
{
scanf("%d%d",&s,&e);
ps=find(s);
pe=find(e);
if(ps==pe)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
void lca(int u)
{
int i, j;
make_set(u);
ancestor[find_set(u)] = u;
for(i = 1;i <= n; i++)
{
if(tree[u][i] == 1)
{
lca(i);
union_set(u, i);
ancestor[find_set(u)] = u;
}
}
color[u] = 1;
for(i = 1;i <= n; i++)
if(q[u][i] && color[i] == 1) num[ancestor[find_set(i)]]++;
}
int main()
{
char color_l[11], color_r[11];
int i;
tire_create(&root);
memset(color_degree, 0, sizeof(color_degree));
while (scanf("%s%s", color_l, color_r) != EOF)
{
tire_insert(color_l);
tire_insert(color_r);
int x = tire_search(color_l);
int y = tire_search(color_r);
color_degree[x]++;
color_degree[y]++;
if (father[x] == 0) make_set(x);
if (father[y] == 0) make_set(y);
union_set(x, y);
}
int sum = 0;
int father_1 = find_set(1);
for (i = 1; i < total_num; i++)
{
if (color_degree[i]%2 != 0) sum++;
if (sum > 2)
{
printf("Impossible\n");
return 0;
}
if(find_set(i) != father_1)
{
printf("Impossible\n");
return 0;
}
}
printf("Possible\n");
return 0;
}
int main()
{
int m, i, j, s = 1;
while(1)
{
scanf("%d %d", &n, &m);
if(n == 0 && m == 0) break;
make_set(n);
while(m--)
{
scanf("%d %d", &i, &j);
union_set(i, j);
}
m = 0;
for(i = 1;i <= n; i++) if(find_set(i) == i) m++;
printf("Case %d: %d\n", s++, m);
}
return 0;
}
