template<class KEY, class VALUE> Nde* Nde::merge_left (int parent_index_this) { // copy all elements from this node into the left sibling, along with the // element in the parent node vector that has this node as its subtree. // this node and its parent element are then deleted. Elem parent_elem = (*mp_parent)[parent_index_this]; parent_elem.mp_subtree = (*this)[0].mp_subtree; Nde* left_sib = (*mp_parent)[parent_index_this-1].mp_subtree; left_sib->vector_insert (parent_elem); for (unsigned int i=1; i<m_count; i++) left_sib->vector_insert (m_vector[i]); mp_parent->vector_delete (parent_index_this); Nde* parent_node = mp_parent; // copy before deleting this node if (mp_parent==find_root() && !mp_parent->key_count()) { m_root.set_root(m_root.get_root(), left_sib); delete mp_parent; left_sib->mp_parent = null_ptr; delete this; return null_ptr; } else if (mp_parent==find_root() && mp_parent->key_count()) { delete this; return null_ptr; } delete this; if (parent_node->key_count() >= parent_node->minimum_keys()) return null_ptr; // no need for parent to import an element return parent_node; // parent must import an element } //_______________________________________________________________________
int merge_left (PBTREE btree, int node_idx, int parent_index_this) { // copy all elements from this node into the left sibling, along with the // element in the parent node vector that has this node as its subtree. // this node and its parent element are then deleted. int i; int parent_node_idx = btree->nodes[node_idx].parent_node_idx; BTREE_ELEMENT parent_elem; memcpy(&parent_elem, &btree->nodes[parent_node_idx].elements[parent_index_this], sizeof(BTREE_ELEMENT)); int left_sib = btree->nodes[parent_node_idx].elements[parent_index_this-1].subtree_node_idx; parent_elem.subtree_node_idx = btree->nodes[node_idx].elements[0].subtree_node_idx; vector_insert (btree, left_sib, &parent_elem); for (i=1; i<btree->nodes[node_idx].element_count; i++) vector_insert (btree, left_sib, &btree->nodes[node_idx].elements[i]); vector_delete_pos (btree, parent_node_idx, parent_index_this); if (parent_node_idx==find_root(btree) && !key_count(btree, parent_node_idx)) { set_root(btree, left_sib); delete_node(btree, parent_node_idx); btree->nodes[left_sib].parent_node_idx = BTREE_INVALID_NODE_IDX; delete_node(btree, node_idx); return BTREE_INVALID_NODE_IDX; } else if (parent_node_idx==find_root(btree) && key_count(btree, parent_node_idx)) { delete_node(btree, node_idx); return BTREE_INVALID_NODE_IDX; } delete_node(btree, node_idx); if (key_count(btree, parent_node_idx) >= btree_minimum_keys()) return BTREE_INVALID_NODE_IDX; // no need for parent to import an element return parent_node_idx; // parent must import an element }
int JoinSet::join(int i, int j) { if (i < 0 || j < 0 || i >= m_set_size || j >= m_set_size) { return -1; } int i_root = find_root(i); int j_root = find_root(j); if (i_root == j_root) { return 0; } LOG("i:%d j:%d m_join_set[i]:%d m_join_set[j]:%d\n", i, j, m_join_set[i], m_join_set[j]); if (m_rank[i_root] < m_rank[j_root]) { m_join_set[i_root] = j_root; } else { m_join_set[j_root] = i_root; if (m_rank[i_root] == m_rank[j_root]) { ++m_rank[i_root]; } } LOG("i:%d j:%d m_join_set[i]:%d m_join_set[j]:%d\n", i, j, m_join_set[i], m_join_set[j]); return 0; }
template<class KEY, class VALUE> Nde* Nde::merge_right (int parent_index_this) { // copy elements from the right sibling into this node, along with the // element in the parent node vector that has the right sibling as it subtree. // the right sibling and that parent element are then deleted Elem parent_elem = (*mp_parent)[parent_index_this+1]; Nde* right_sib = (*mp_parent)[parent_index_this+1].mp_subtree; parent_elem.mp_subtree = (*right_sib)[0].mp_subtree; vector_insert (parent_elem); for (unsigned int i=1; i<right_sib->m_count; i++) vector_insert ((*right_sib)[i]); mp_parent->vector_delete (parent_index_this+1); delete right_sib; if (mp_parent==find_root() && !mp_parent->key_count()) { m_root.set_root(m_root.get_root(), this); delete mp_parent; mp_parent = 0; return null_ptr; } else if (mp_parent==find_root() && mp_parent->key_count()) return null_ptr; if (mp_parent&& mp_parent->key_count() >= mp_parent->minimum_keys()) return null_ptr; // no need for parent to import an element return mp_parent; // parent must import an element }
int btree_delete_ex (PBTREE btree, int node_idx, long target_key) { // target is just a package for the key value. the reference does not // provide the address of the Elem instance to be deleted. // first find the node contain the Elem instance with the given key int parent_index_this = BTREE_INVALID_ELEMENT_IDX; PBTREE_ELEMENT found; int last_visted_node_idx; if (node_idx == BTREE_INVALID_NODE_IDX) node_idx = btree->root_node_idx; last_visted_node_idx = node_idx; found = btree_search_ex (btree, &last_visted_node_idx, target_key); if (!found) return 0; if (is_leaf(btree, last_visted_node_idx) && key_count(btree, last_visted_node_idx) > btree_minimum_keys()) return vector_delete (btree, last_visted_node_idx, target_key); else if (is_leaf(btree, last_visted_node_idx)) { vector_delete (btree, last_visted_node_idx, target_key); // loop invariant: if _node_ is not null_ptr, it points to a node // that has lost an element and needs to import one from a sibling // or merge with a sibling and import one from its parent. // after an iteration of the loop, _node_ may become null or // it may point to its parent if an element was imported from the // parent and this caused the parent to fall below the minimum // element count. while (BTREE_IS_VALID_NODE_IDX(last_visted_node_idx)) { int right, left; // NOTE: the "this" pointer may no longer be valid after the first // iteration of this loop!!! if (last_visted_node_idx == find_root(btree) && is_leaf(btree, last_visted_node_idx)) break; if (last_visted_node_idx == find_root(btree) && !is_leaf(btree, last_visted_node_idx)) // sanity check return 0; // is an extra element available from the right sibling (if any) right = right_sibling(btree, last_visted_node_idx, &parent_index_this); if (BTREE_IS_VALID_NODE_IDX(right) && key_count(btree, right) > btree_minimum_keys()) last_visted_node_idx = rotate_from_right(btree, last_visted_node_idx, parent_index_this); else { // is an extra element available from the left sibling (if any) left = left_sibling(btree, last_visted_node_idx, &parent_index_this); if (BTREE_IS_VALID_NODE_IDX(left) && key_count(btree, left) > btree_minimum_keys()) last_visted_node_idx = rotate_from_left(btree, last_visted_node_idx, parent_index_this); else if (BTREE_IS_VALID_NODE_IDX(right)) last_visted_node_idx = merge_right(btree, last_visted_node_idx, parent_index_this); else if (BTREE_IS_VALID_NODE_IDX(left)) last_visted_node_idx = merge_left(btree, last_visted_node_idx, parent_index_this); } } } else { PBTREE_ELEMENT smallest_in_subtree = smallest_key_in_subtree(btree, found->subtree_node_idx); found->key = smallest_in_subtree->key; found->data_entry_idx = smallest_in_subtree->data_entry_idx; btree_delete_ex (btree, found->subtree_node_idx, smallest_in_subtree->key); } return 1; }
int main() { n = read(); m = read(); for (int i = 1; i <= n; i++) root[i] = i; for (int i = 1; i <= m; i++) { if (num_edges + 1 > n) break; a = read(); b = read(); const int ar = find_root(a), br = find_root(b); if (ar != br) root[ar] = br, edges[num_edges++] = i; } if (num_edges + 1 < n) printf("Disconnected Graph\n"); else for (int i = 0; i < num_edges; i++) printf("%d\n", edges[i]); }
double find_root( double f(double x), double x_guess, double x_second_guess ) { set_first_root_estimate(x_guess); set_second_root_estimate(x_second_guess); return find_root(f); }
GtFeatureNode* gt_feature_info_find_root(const GtFeatureInfo *fi, const char *id) { gt_assert(fi && id); gt_assert(gt_feature_info_get(fi, id)); return find_root(fi, id); }
int find_root(int n) { if(parent[n] != n) parent[n] = find_root(parent[n]); return parent[n]; }
/** * Trims the tree, killing some of the parents *@param board the current board *@param score my score *@param opponentScore other score *@param pointsLeft how many points left in the game *@return the root of it all */ AlphaBetaNode* AlphaBetaAI::trim_tree(int* board, int score, int opponentScore, int pointsLeft) { pthread_mutex_lock(&mutex); AlphaBetaNode* root = find_root(board, NULL, pointsLeft); //printf("found root"); int zeroD = root->getDepth(); // surely there is a better way of doing this... // kill parents and reshape tree for (unsigned int i = 0; i < nodes.size(); i++) { if (nodes[i] != root && nodes[i]->getDepth() <= zeroD) { //printf("going to kill self\n"); nodes[i]->killSelfAndKids(); //printf("managed to kill self\n"); } else { nodes[i]->raise(zeroD); } } // dispose of bodies for (int i = 0; i < (signed)nodes.size(); i++) { if (nodes[i] != root && nodes[i]->isDead()) { //printf("killed one\n"); delete nodes[i]; nodes.erase(nodes.begin()+i); i--; } } myScore = score; otherScore = opponentScore; reset = true; pthread_mutex_unlock(&mutex); return root; }
ea_t auto_find_root_addr() { int i; segment_t *s; ea_t start, end, found; for ( i = 0; i < segs.get_area_qty(); i++ ) { s = getnseg(i); if ( NULL == s ) continue; start = s->startEA; end = s->endEA; while(start < end) { found = bin_search(start, end, root_name, NULL, ROOT_LEN + 1, BIN_SEARCH_FORWARD, BIN_SEARCH_CASE); if ( BADADDR == found ) break; start = found + ROOT_LEN; /* for next iteration */ xrefblk_t xb; int ok; for ( ok = xb.first_to(found,XREF_ALL); ok; ok=xb.next_to() ) { if ( xb.iscode ) /* we want data ref */ continue; if ( NULL != ( found = find_root(found, true) ) ) return found; } } } return NULL; }
int find_pol_roots_homog(unsigned int p, int deg, unsigned int *polmod, unsigned int *roots) { unsigned int r; int n, d, i; if (assess_mod_len<deg+1) { assess_mod_len=deg+1; assess_mod=(unsigned int *)xrealloc(assess_mod,assess_mod_len*sizeof(unsigned int)); } for (i=0; i<=deg; i++) assess_mod[i]=polmod[i]%p; d=deg; n=0; while ((d) && (assess_mod[d]==0)) { d--; roots[n++]=p; } if (d==0) { if (assess_mod[0]==0) complain("find_pol_roots_homog: zero pol\n"); return n; } while (d) { r=find_root(p,d,assess_mod); if (r==p) break; if (pol_eval(p,d,assess_mod,r)) complain("find_pol_roots_homog\n"); do { pol_div_lin(p,&d,assess_mod,r); roots[n++]=r; } while (pol_eval(p,d,assess_mod,r)==0); } return n; }
static GtFeatureNode* find_root(const GtFeatureInfo *fi, const char *id) { const char *delim, *parents; GtFeatureNode *this_feature, *parent_pseudo_feature; gt_assert(fi && id); /* get feature */ delim = strchr(id, ';'); if (delim) { char *first_parent = gt_cstr_dup_nt(id, delim - id); this_feature = gt_hashmap_get(fi->id_to_genome_node, first_parent); parent_pseudo_feature = gt_hashmap_get(fi->id_to_pseudo_parent, first_parent); gt_free(first_parent); } else { this_feature = gt_hashmap_get(fi->id_to_genome_node, id); parent_pseudo_feature = gt_hashmap_get(fi->id_to_pseudo_parent, id); } gt_assert(this_feature); /* recursion */ parents = gt_feature_node_get_attribute(this_feature, GT_GFF_PARENT); if (parents) return find_root(fi, parents); else if (parent_pseudo_feature) return parent_pseudo_feature; return this_feature; }
/*template <class T_t, class G_t>*/ static int tree_dec_lospre (tree_dec_lospre_t/*T_t*/ &T, cfg_lospre_t/*G_t*/ &G, const iCode *ic) { if(tree_dec_lospre_nodes(T, find_root(T), G)) return(-1); wassert(T[find_root(T)].assignments.begin() != T[find_root(T)].assignments.end()); const assignment_lospre &winner = *(T[find_root(T)].assignments.begin()); //std::cout << "Winner (lospre): "; //print_assignment(winner, G); int change; if (change = implement_lospre_assignment(winner, T, G, ic)) nicify (T); T[find_root(T)].assignments.clear(); return(change); }
local boolean simp_isroot(entry* alpha, simpgrp* g) { _index i,r=g->lierank; entry level=0; boolean neg,result=false; for(i=0; i<r; ++i) level+=alpha[i]; /* compute level of |alpha| */ neg=level<0; /* if |neg| holds, |alpha| can only be a negative root */ if (neg) { level= -level; for(i=0; i<r; ++i) alpha[i]= -alpha[i]; } result=find_root(alpha,level,g)>=0; if (neg) for(i=0; i<r; ++i) alpha[i]= -alpha[i]; /* restore |alpha| */ return result; }
/*template <class T_t, class G_t>*/ static int tree_dec_safety (tree_dec_lospre_t/*T_t*/ &T, cfg_lospre_t/*G_t*/ &G, const iCode *ic) { if(tree_dec_safety_nodes(T, find_root(T), G)) return(-1); wassert(T[find_root(T)].assignments.begin() != T[find_root(T)].assignments.end()); const assignment_lospre &winner = *(T[find_root(T)].assignments.begin()); implement_safety(winner, G); #ifdef DEBUG_LOSPRE std::cout << "Winner (safety): "; print_assignment(winner, G); #endif T[find_root(T)].assignments.clear(); return (0); }
joint* joint::find_joint_name(const string & _name) { joint* search_down = _find_joint_name(_name); if (search_down != NULL) return search_down; joint* root = find_root(); return root->_find_joint_name(_name); }
int find_root(int x, int n) { if((x*x) == n) { return x; } else if (x == 0) return -1; return (find_root((x-1),n)); }
int next_mtree(struct iterator_mtree *imt) { int rc; u64 blknum = find_root(imt->mt); if (!blknum) return DONE; rc = next_key(imt, blknum); return rc ? DONE : 0; }
int main(int argc, char* argv[]) { short t = 0, n = 0, i = 0, x = 0, y = 0, gx = 0, gy = 0; char failed = 0, nconfess = 0; #ifndef ONLINE_JUDGE freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout); #endif scanf("%d\n", &t); for(i = 0; i < t; i++){ scanf("%d\n", &n); memset(parent, 0, sizeof(parent)); failed = 0; nconfess = 0; for(x = 1; x <= n; x++){ scanf("%d ", &y); if(failed == 1) continue; if(y == 0){ if(++nconfess > 1) failed = 1; continue; } gx = find_root(x); gy = find_root(y); if(gx == 0 && gy == 0){ parent[x] = x; parent[y] = x; } else if(gx != 0 && gy != 0){ if(gx == gy) failed = 1; else parent[gy] = gx; } else if(gx == 0) parent[x] = gy; else if(gy == 0) parent[y] = gx; } if(failed == 0 && nconfess == 1) printf("YES\n"); else printf("NO\n"); } return 0; }
void top_sort(int graph[][10], int sort[]) { int curr_root, sort_ind = 0; while ((curr_root = find_root(graph)) != -1) { sort[sort_ind] = curr_root; sort_ind++; } }
void pr_mtree(struct mtree *mt) { u64 root = find_root(mt); if (!root) { printf("<empty>\n"); return; } printf("Root: %lld\n", root); pr_block(mt, root, 0); }
void build(int x, int c) { c += x <= n; cut_root[x] = c, vis[x] = true; for (int i = 0; i < int(pass[x].size()); ++i) if (vis[pass[x][i].to]) lca[pass[x][i].index] = find_root(pass[x][i].to); for (int i = 0; i < int(chd[x].size()); ++i) { build(chd[x][i], c); d_set_merge(chd[x][i], x); } }
int main(int argc, char **argv) { struct btrfs_root *root; int dev_fd; int opt; int ret; while ((opt = getopt(argc, argv, "l:o:g:")) != -1) { switch(opt) { case 'o': search_objectid = arg_strtou64(optarg); break; case 'g': search_generation = arg_strtou64(optarg); break; case 'l': search_level = arg_strtou64(optarg); break; default: usage(); exit(1); } } set_argv0(argv); argc = argc - optind; if (check_argc_min(argc, 1)) { usage(); exit(1); } dev_fd = open(argv[optind], O_RDONLY); if (dev_fd < 0) { fprintf(stderr, "Failed to open device %s\n", argv[optind]); exit(1); } root = open_ctree_broken(dev_fd, argv[optind]); close(dev_fd); if (!root) { fprintf(stderr, "Open ctree failed\n"); exit(1); } if (search_generation == 0) search_generation = btrfs_super_generation(root->fs_info->super_copy); csum_size = btrfs_super_csum_size(root->fs_info->super_copy); ret = find_root(root); close_ctree(root); return ret; }
int square_root(int n) { int x; /*int sqr_root;*/ x = n - 1; if ((n == 0) || (n == 1)) return n; else if(n < 0) return -1; /*sqr_root = find_root(x,n);*/ return find_root(x,n); }
int main() { int i, j, m, n, x, y, ncase, min_cap; scanf("%d", &ncase); for(i = 1; i <= ncase; i++) { scanf("%d%d", &n, &m); for(j = 0; j < m; j++) { scanf("%d%d%d", &roads[j][0], &roads[j][1], &roads[j][2]); } qsort(roads, m, sizeof(roads[0]), cmp); for(j = 0; j < n; j++) { parent[j] = j; } min_cap = roads[0][2]; for(j = 0; j < m; j++) { x = find_root(roads[j][0]); y = find_root(roads[j][1]); if ( x != y ) { parent[x] = y; min_cap = roads[j][2]; } } printf("Case #%d: %d\n", i, min_cap); } return 0; }
int main() { int i, n, m, a, b, x, y, max, ncase; scanf("%d", &ncase); while (ncase-- > 0) { scanf("%d%d", &n, &m); for(i = 1; i <= n; i++) { parent[i] = i; size[i] = 1; } while (m-- > 0) { scanf("%d%d", &a, &b); x = find_root(a); y = find_root(b); if ( x != y ) link(x, y); } max = 0; for(i = 1; i <= n; i++) { if ( parent[i] == i ) { if ( size[i] > max ) max = size[i]; } } printf("%d\n", max); } return 0; }
//--------------------------------------------------------------------------------------- void XmlParser::parse_file(const std::string& filename, bool UNUSED(fErrorMsg)) { m_fOffsetDataReady = false; m_filename = filename; pugi::xml_parse_result result = m_doc.load_file(filename.c_str()); if (!result) { m_errorMsg = string(result.description()); m_errorOffset = result.offset; } find_root(); }
//--------------------------------------------------------------------------------------- void XmlParser::parse_char_string(char* str) { m_fOffsetDataReady = false; m_filename.clear(); pugi::xml_parse_result result = m_doc.load_string(str, pugi::parse_default | pugi::parse_declaration); if (!result) { m_errorMsg = string(result.description()); m_errorOffset = result.offset; } find_root(); }
off_t file_bstore::find_root() { off_t best_root = 0; slabs_t::reverse_iterator it = m_slabs.rbegin(); while(it != m_slabs.rend()) { best_root = find_root(it->first, it->second.io); if (best_root != 0) break; it++; } return best_root; }