bool union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rang[a] < rang[b]) {
swap(a, b);
}
parent[b] = a;
if (rang[a] == rang[b]) {
rang[a]++;
}
return true;
}
return false;
}
/*按秩合并x，y所在的集合*/
void union_set(int x, int y, int w)
{
x = find_set(x);
y = find_set(y);
if(x == y)
return ;
ans += w;
if(rank[x] > rank[y])/*让rank比较高的作为父结点*/
{
pa[y] = x;
}
else
{
pa[x] = y;
if(rank[x] == rank[y])
rank[y]++;
}
}
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;
}
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x == y) {
return;
}
if (rank[x] > rank[y]) {
parent[y] = x;
sz1[x] += sz1[y];
sz2[x] += sz2[y];
} else {
if (rank[x] == rank[y]) {
rank[y]++;
}
parent[x] = y;
sz1[y] += sz1[x];
sz2[y] += sz2[x];
}
}
int find_set(int s)
{
int temp;
if(s!=f[s])
{
temp=f[s];
f[s]=find_set(f[s]);
level[s]=(level[temp]+level[s])%2; // 更新其与依附节点的关系
}
return f[s];
}
int main()
{
char op[5];
int i, p, q;
init();
while(scanf("%s", op) != EOF)
{
if(!strcmp(op, "O"))
{
scanf("%d", &p);
repaire(p);
}
else if(!strcmp(op, "S"))
{
scanf("%d %d", &p, &q);
if(find_set(p) != find_set(q)) printf("FAIL\n");
else printf("SUCCESS\n");
}
}
return 0;
}
int union_set(int x, int y)
{
int px = find_set(x);
int py = find_set(y);
if (px == py) return 0;
if (parent[px] < parent[py])
{
parent[py] += parent[px];
root[px] = 0;
parent[px] = py;
}
else
{
parent[px] += parent[py];
root[py] = 0;
parent[py] = px;
}
return 1;
}
bool is_cycle(Graph* graph) {
int V = graph->V;
int E = graph->E;
Disjoint_Set* allsets = (Disjoint_Set*)malloc(V * sizeof(Disjoint_Set));
for (int v = 0; v < V; v++) {
allsets[v].parent = v;
allsets[v].rank = 0;
}
for (int e = 0; e < E; e++) {
int x = find_set(allsets, graph->edges[e].src);
int y = find_set(allsets, graph->edges[e].dest);
if(x == y) {
return true;
}
union_set(allsets, x, y);
}
return false;
}
int main(int argc, char **argv)
{
int i1=1, i2=2, i3=3;
forest_node_t *s1=make_set(&i1), *s2=make_set(&i2), *s3=make_set(&i3);
assert(find_set(s1) == s1);
union_sets(s1, s2);
assert(find_set(s1) == find_set(s2));
assert(find_set(s1) != find_set(s3));
union_sets(s2, s3);
assert(find_set(s1) == find_set(s2) &&
find_set(s1) == find_set(s3));
return 0;
}
void unite(int v1,int v2)
{
int i,j;
int p1,p2;
int smaller,larger;
p1=find_set(v1);
p2=find_set(v2);
smaller=(p1<p2)?p1:p2;
larger=(p1<p2)?p2:p1;
for(i=1;i<=forest[larger][0];i++)forest[smaller][++forest[smaller][0]]=forest[larger][i];
for(i=larger;i<forest_size-1;i++)
{
for(j=0;j<=forest[i+1][0];j++)forest[i][j]=forest[i+1][j];
}
forest_size--;
}
void MST_kruskal(int G[][20],int no_of_nodes,int mst[][20])
{
int i,j;
int u,v;
for(i=0;i<no_of_nodes;i++)
for(j=0;j<no_of_nodes;j++)
mst[i][j]=0;
for(i=0;i<no_of_nodes;i++)make_set(i);
get_sorted_edge_list(G,no_of_nodes);
for(i=0;i<edge_list_size;i++)
{
u=edge_list[i][0];
v=edge_list[i][1];
if(find_set(u)!=find_set(v))
{
mst[u][v]=mst[v][u]=edge_list[i][2];
unite(u,v);
}
}
}
int check()
{
int i, x, y, z;
x = 0;
for(i = 1;i <= cnt; i++) if(find_set(i) == i) x++;
if(x > 1) return 0;
x = 0; y = 0; z = 0;
for(i = 1;i <= cnt; i++)
if(indeg[i] == outdeg[i]) x++;
else if(indeg[i] == outdeg[i] + 1) y++;
else if(indeg[i] + 1 == outdeg[i]) z++;
return ((x + 2 == cnt && y == 1 && z == 1) || (x == cnt && y == 0 && z == 0));
}
void unionn(int v1,int v2,struct node *A[])
{
int x, y;
if (A[v2] == NULL) {
return;
}
if (v1 == v2) {
return;
}
struct node *temp1, *temp2;
temp1 = find_set(v1,A);
temp2 = find_set(v2,A);
if (temp1 -> data != temp2 -> data) {
if (temp1 -> rank > temp2 -> rank || temp1 -> rank == temp2 -> rank) {
temp2 -> parent = temp1;
if (temp1 -> rank == temp2 -> rank) {
temp1 -> rank = temp1 -> rank + 1;
}
} else {
temp1 -> parent = temp2;
}
}
}
/**
* Runs Kruskal MSF algorithm
* @param el pointer to sorted edge list
* @param fnode_array pointer to forest nodes array
* @param edge_membership designates whether an edge is part of the MSF
*/
void kruskal(edgelist_t *el,
forest_node_t **fnode_array,
unsigned int *edge_membership)
{
unsigned int i;
edge_t *pe;
assert(fnode_array);
assert(edge_membership);
// For each edge, in order by non-decreasing weight...
for ( i = 0; i < el->nedges; i++ ) {
pe = &(el->edge_array[i]);
forest_node_t *set1 = find_set(fnode_array[pe->vertex1]);
forest_node_t *set2 = find_set(fnode_array[pe->vertex2]);
// vertices belong to different forests
if ( set1 != set2 ) {
union_sets(set1, set2);
edge_membership[i] = 1;
}
}
}
int main()
{
int choice, value, v1, v2, i;
struct node *A[100];
struct node *temp;
for(i = 0; i < 100; i++) {
A[i] = NULL;
}
while (1) {
printf("Choices:\n");
printf("1. Make set for an element\n");
printf("2. Find set for an element\n");
printf("3. Union of two sets\n");
printf("4. Display the set\n");
printf("5. Exit\n");
scanf("%d", &choice);
switch(choice)
{
case 1:
printf("Enter the value for the set\n");
scanf("%d", &value);
make_set(value,A);
break;
case 2:
printf("Enter the value for which you want the set representative\n");
scanf("%d", &value);
temp = find_set(value,A);
printf("%d\n", temp -> data);
break;
case 3:
printf("Enter element 1 and element 2\n");
scanf("%d %d",&v1,&v2);
unionn(v1,v2,A);
break;
case 4:
printf("Enter the first element of the set you want to display\n");
scanf("%d", &value);
display(value,A);
break;
case 5:
exit(1);
default:
printf("Invalid choice!\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;
}
/**
* Creates a new set of the given name and parameters.
* @arg set_name The name of the set
* @arg custom_config Optional, can be null. Configs that override the defaults.
* @return 0 on success, -1 if the set already exists.
* -2 for internal error. -3 if there is a pending delete.
*/
int setmgr_create_set(hlld_setmgr *mgr, char *set_name, hlld_config *custom_config) {
int res = 0;
pthread_mutex_lock(&mgr->write_lock);
/*
* Bail if the set already exists.
* -1 if the set is active
* -3 if delete is pending
*/
hlld_set_wrapper *set = find_set(mgr, set_name);
if (set) {
res = (set->is_active) ? -1 : -3;
goto LEAVE;
}
// Scan the pending delete queue
LOCK_HLLD_SPIN(&mgr->pending_lock);
if (mgr->pending_deletes) {
hlld_set_list *node = mgr->pending_deletes;
while (node) {
if (!strcmp(node->set_name, set_name)) {
res = -3; // Pending delete
UNLOCK_HLLD_SPIN(&mgr->pending_lock);
goto LEAVE;
}
node = node->next;
}
}
UNLOCK_HLLD_SPIN(&mgr->pending_lock);
// Use a custom config if provided, else the default
hlld_config *config = (custom_config) ? custom_config : mgr->config;
// Add the set
if (add_set(mgr, set_name, config, 1, 1)) {
res = -2; // Internal error
}
LEAVE:
pthread_mutex_unlock(&mgr->write_lock);
return res;
}
/**
* @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);
// For each direction, count distinct islands.
unordered_set<int> neighbors;
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()) {
neighbors.emplace(find_set(node_id(neighbor, m), &set));
}
}
// For each direction, find and union.
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()) {
union_set(&set, node_id(node, m), node_id(neighbor, m));
}
}
number += 1 - neighbors.size();
numbers.emplace_back(number);
}
return numbers;
}
int main()
{
subset* sub = (subset*)malloc(10*sizeof(subset));
int i;
printf("I am here\n");
for(i=1;i<=10;i++){
make_set(sub,i);
}
for(i=1;i<=10;i++){
printf("%d %d\n",sub[i].parent,sub[i].rank);
}
make_union(sub,1,2);
make_union(sub,2,3);
make_union(sub,3,4);
for(i=1;i<=10;i++){
printf("%d %d\n",sub[i].parent,sub[i].rank);
}
for(i=1;i<=10;i++){
printf("Parent of %d is %d\n",i,find_set(sub,i));
}
return 0;
}
int main() {
scanf("%d", &n);
while (n-- > 0) {
scanf("%d%d", &m, &r);
for (i = 1; i <= 2 * m; ++i) {
initial_set(i);
}
for (i = 0; i < r; i++) {
scanf("%d%d", &x, &y);
union_set(x, m + y);
}
for (i = 1; i <= 2 * m; ++i) {
if (i == find_set(i)) {
ss[cnt++] = i;
}
}
dp[0][0] = 1;
for (i = 0; i < cnt; ++i) {
for (j = m / 2; j >= sz1[ss[i]]; --j) {
for (k = m / 2; k >= sz2[ss[i]]; --k) {
dp[j][k] = dp[j - sz1[ss[i]]][k - sz2[ss[i]]];
}
}
}
for (i = m / 2; i >= 0; i--) {
if (dp[i][i] == 1) {
printf("%d\n", i);
break;
}
}
memset(sz1, 0, sizeof(sz1));
memset(sz2, 0, sizeof(sz2));
memset(ss, 0, sizeof(ss));
memset(dp, 0, sizeof(dp));
}
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) {
// Write your code here
int number = 0;
vector<int> numbers;
unordered_map<int, int> sets;
const vector<pair<int, int>> directions{{0, -1}, {0, 1},{-1, 0}, {1, 0}};
for (const auto& oper : operators) {
const auto& node = make_pair(oper.x, oper.y);
//create a single set
sets[node_id(node, m)] = node_id(node, m);
//For each direction, count distinct islands.
unordered_set<int> neighbors;
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 &&
sets.find(node_id(neighbor, m)) != sets.end()) {
//already in the sets, update neighbor, each island has different key
neighbors.insert(find_set(node_id(neighbor, m), sets));
}
}
// For each direction, find and union.
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 &&
sets.find(node_id(neighbor, m)) != sets.end()) {
//already in the sets, union sperate sets
union_set(node_id(node, m), node_id(neighbor, m), sets);
}
}
number += (1 - neighbors.size());
numbers.push_back(number);
}
return numbers;
}
void make_union(subset subset[],int x,int y)
{
if(subset[x].rank>subset[y].rank){
int p1 = find_set(subset,y);
int p2 = find_set(subset,x);
subset[p1].parent = p2;
}
else if(subset[x].rank<subset[y].rank){
int p1 = find_set(subset,y);
int p2 = find_set(subset,x);
subset[p2].parent = p1;
}
else{
int p1 = find_set(subset,y);
int p2 = find_set(subset,x);
subset[p1].parent = p2;
subset[p2].rank++;
}
}
int find_set(int x)
{
if(x != parent[x]) parent[x] = find_set(parent[x]);
return parent[x];
}
struct Set *find_set(struct Set *item){
if(item->parent==item)
return item;
item->parent=find_set(item->parent);
return item->parent;
}
int size_of_set(int i) { return set_size[find_set(i)]; }
bool is_same_set(int i, int j) { return find_set(i) == find_set(j); }
int find_set(int i) { return (p[i] == i) ? i : (p[i] = find_set(p[i])); }
// 查找x 元素所在的集合，回溯时压缩路径
int find_set(int x)
{
if (x != father[x])
father[x] = find_set(father[x]);
return father[x];
}
int find_set(Disjoint_Set allsets[], int x) {
if (allsets[x].parent != x) {
allsets[x].parent = find_set(allsets, allsets[x].parent);
}
return allsets[x].parent;
}
