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; }