/***************************** findParent *********************************
NodeT *findParent(NodeT *pParent, NodeT *p, NodeT *pkid)
Purpose:
Finds the parent of the child we are currently on.
Parameters:
NodeT *pParent
NodeT *p
NodeT *pkid
Returns:
Returns that specified child's parent node.
**************************************************************************/
NodeT *findParent(NodeT *pParent, NodeT *p, NodeT *pkid)
{
NodeT *pFound = NULL;
//if tree passed in is NULL
if (p == NULL)
return NULL;
//pkid has been found
if (strcmp(p->element.szId,pkid->element.szId)==0)
return pParent;
//traverse sibling nodes
if (p->pSibling !=NULL)
pFound = findParent(pParent,p->pSibling,pkid);
//pkid has been found so dont traverse through children
if (pFound != NULL)
return pFound;
//traverse child nodes
if (p->pChild != NULL)
pFound = findParent(p,p->pChild,pkid);
//if found in child nodes, returns the found node, else it returns NULL
return pFound;
}
void unionTwo(int f, int t) {
int a = findParent(f);
int b = findParent(t);
if (a == b) return;
if (a > b) {
parent[a] = b;
} else {
parent[b] = a;
}
}
void unionFind::unite(int child1, int child2){
unionFindNode *parent1 = findParent(child1);
unionFindNode *parent2 = findParent(child2);
if (parent1->getParent() == parent2->getParent())
return;
if (parent1->getRank() < parent2->getRank()) {
parent1->setParent(parent2->getParent());
} else {
parent2->setParent(parent1->getParent());
if (parent2->getRank() == parent1->getRank())
parent1->setRank(parent1->getRank()+1);
}
}
int minMalwareSpread(vector<vector<int>>& graph, vector<int>& initial) {
int n = graph.size();
parent.clear();
count.clear();
for(int i = 0; i < n; ++i) {
parent[i] = i; count[i] = 1;
}
vector<int> visited(n, false);
for(int i = 0; i < n; ++i)
{
for(int j = 0; j < n; ++j)
{
if(graph[i][j])
{
int pi = findParent(i);
int pj = findParent(j);
if(pi != pj)
{
parent[pi] = pj;
count[pj] += count[pi];
}
}
}
}
sort(initial.begin(), initial.end());
map<int, vector<int>> m;
for(int i : initial)
{
m[findParent(i)].push_back(i);
}
int minCount = 0;
int minIdx = initial[0];
for(const auto& p : m)
{
if(p.second.size() == 1)
{
if(count[p.first] > minCount)
{
minCount = count[p.first];
minIdx = p.second[0];
}
}
}
return minIdx;
}
void unionSets(int x, int y) {
int root0 = findParent(x);
int root1 = findParent(y);
if (root0 == root1) return;
if (componentSize[root0] >= componentSize[root1]) {
componentSize[root0] += componentSize[root1];
parent[root1] = root0;
} else {
componentSize[root1] += componentSize[root0];
parent[root0] = root1;
}
numberOfDisjointSets--;
}
void BST::drop(int key) {
if(empty())
return;
Node *keyNode = findParent(key);
if(keyNode->key() == key) {
Node *successor = findSuccessor(keyNode);
if(successor == NULL) { // No right subtree.
if(root != keyNode) {
if(keyNode->parent->left == keyNode)
keyNode->parent->left = keyNode->left;
else
keyNode->parent->right = keyNode->left;
}
else root = keyNode->left;
}
else replaceWithSuccessor(keyNode, successor);
keyNode->parent = NULL;
keyNode->left = NULL;
keyNode->right = NULL;
delete keyNode;
}
}
Symbol *VariableTable::findProperty(ClassScopePtr &cls,
const string &name,
AnalysisResultConstPtr ar) {
Symbol *sym = getSymbol(name);
if (sym) {
assert(sym->declarationSet());
if (!sym->isOverride()) {
return sym;
}
assert(!sym->isStatic());
sym = nullptr;
}
if (!sym) {
if (ClassScopePtr parent = findParent(ar, name, sym)) {
sym = parent->findProperty(parent, name, ar);
if (sym) {
cls = parent;
return sym;
}
}
}
return sym;
}
bool VariableTable::markOverride(AnalysisResultPtr ar, const string &name) {
Symbol *sym = getSymbol(name);
assert(sym && sym->isPresent());
bool ret = false;
if (!sym->isStatic() ||
(sym->isPublic() && !sym->getClassInitVal())) {
Symbol *s2;
ClassScopePtr parent = findParent(ar, name, s2);
if (parent) {
assert(s2 && s2->isPresent());
if (!s2->isPrivate()) {
if (!sym->isStatic() || s2->isProtected()) {
if (sym->isPrivate() || sym->isStatic()) {
// don't mark the symbol as overridden
return true;
}
if (sym->isProtected() && s2->isPublic()) {
// still mark the symbol as overridden
ret = true;
}
sym->setOverride();
}
}
}
}
return ret;
}
void bst::insert(int key)
{
filereader fileReader;
fileReader.open(fileName, 'x');
bst_node parentNode;
long parentOffset = findParent(key, &parentNode);
if (parentOffset != INVALID_OFFSET)
{
bst_node newNode(key);
fileReader.seek(0, END);
long childOffset = fileReader.offset();
fileReader.write_raw((char *) &newNode, sizeof(bst_node));
if (key < parentNode.key)
{
parentNode.l = childOffset;
}
else if (key > parentNode.key)
{
parentNode.r = childOffset;
}
fileReader.seek(parentOffset, BEGIN);
fileReader.write_raw((char *) &parentNode, sizeof(bst_node));
}
else
{
bst_node newNode(key);
fileReader.write_raw((char *) &newNode, sizeof(bst_node));
}
fileReader.close();
}
int main() {
int t;
scanf("%d", &t);
while (t > 0) {
t--;
scanf("%d%d", &n, &m);
for (i = 1; i < n + 1; i++) {
parent[i] = i;
}
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
unionTwo(a, b);
}
for (i = 1; i < n + 1; i++) {
parent[i] = findParent(i);
}
int num = 0;
for (i = 1; i < n + 1; i++) {
if (parent[i] == i) {
num++;
}
}
printf("%d\n", num);
}
return 0;
}
const Node* BST::find(int key) const {
Node *node = findParent(key);
if(node->key() == key)
return node;
else
return NULL;
}
int findParent(int x){
if (subs[x].p != x) {
int p = subs[x].p;
subs[x].p = findParent(subs[x].p);
subs[x].w = (subs[x].w + subs[p].w);
}
return subs[x].p;
}
int findParent(int x, vector<int> &parent) {
if(parent[x] == x) return x;
parent[x] = findParent(parent[x],parent);
return parent[x];
}
/*
* @param a: An integer
* @param b: An integer
* @return: nothing
*/
void connect(int a, int b) {
int parentOfNodeA = findParent(a), parentOfNodeB = findParent(b);
if(parentOfNodeA == parentOfNodeB)
return ;
-- numOfConnectedComponents;
int connectedParent = parentOfNode[parentOfNodeA] + parentOfNode[parentOfNodeB];
if(parentOfNode[parentOfNodeA] > parentOfNode[parentOfNodeB]) {
parentOfNode[parentOfNodeA] = parentOfNodeB;
parentOfNode[parentOfNodeB] = connectedParent;
} else {
parentOfNode[parentOfNodeB] = parentOfNodeA;
parentOfNode[parentOfNodeA] = connectedParent;
}
}
void Union(int x, int y, vector<int> & parent, vector<int> & sz, int &total) {
int x1 = findParent(x,parent);
int y1 = findParent(y,parent);
if(x1==y1) return;
if (sz[x1] < sz[y1]) {
parent[x1] = y1; //注意一定是x,y的root在赋值 不是x,y
sz[x1] += sz[y1];
}
else {
parent[y1] = x1;
sz[y1] += sz[x1];
}
--total;
}
void TransferListView::update(const NTransfer& transfer) {
TransferListItem* file = findTransfer(transfer.user, transfer.filename);
if (!file ) {
file = new TransferListItem(findParent(transfer.user), transfer.user, transfer.filename);
museeq->flush(); // Needed to avoid transfers being added times when update() is called twice.
}
file->update(transfer);
}
std::shared_ptr<ControlResizer::ControlResizerItem> ControlResizer::findParent(const std::map<HWND, std::shared_ptr<ControlResizerItem>>& controls, HWND hwndParent) const
{
for (auto& control : controls)
{
if (control.first == hwndParent)
return control.second;
findParent(control.second->controls, hwndParent);
}
return nullptr;
}
const Tile& getTile(const uint8_t z, const uint32_t x_, const uint32_t y) {
if (z > options.maxZoom)
throw std::runtime_error("Requested zoom higher than maxZoom: " + std::to_string(z));
const uint32_t z2 = std::pow(2, z);
const uint32_t x = ((x_ % z2) + z2) % z2; // wrap tile x coordinate
const uint64_t id = toID(z, x, y);
auto it = tiles.find(id);
if (it != tiles.end())
return it->second.tile;
it = findParent(z, x, y);
if (it == tiles.end())
throw std::runtime_error("Parent tile not found");
// if we found a parent tile containing the original geometry, we can drill down from it
const auto& parent = it->second;
// parent tile is a solid clipped square, return it instead since it's identical
if (parent.is_solid)
return parent.tile;
// drill down parent tile up to the requested one
splitTile(parent.source_features, parent.z, parent.x, parent.y, z, x, y);
it = tiles.find(id);
if (it != tiles.end())
return it->second.tile;
it = findParent(z, x, y);
if (it == tiles.end())
throw std::runtime_error("Parent tile not found");
// drilling stopped because parent was a solid square; return it instead
if (it->second.is_solid)
return it->second.tile;
// otherwise it was an empty tile
return empty_tile;
}
void findParent(int target,int* target_parent) {
int i;
target_parent[count++] = target;
for (i = 1; i <= n; i++) {
if (graph[i][target] == 1) {
findParent(i,target_parent);
//target1_parent[count++] = i;
}
}
}
void nca() {
int i;
int j;
findParent(target1, target1_parent);
findParent(target2, target2_parent);
for (i = 0; i <100; i++) {
for (j = 0; j < 100; j++) {
if (target1_parent[i] != 0 && target2_parent[j] != 0) {
if (target1_parent[i] == target2_parent[j]) {
printf("%d", target1_parent[i]);
return;
}
}
}
}
}
TimerPtr
Dashboard::getTimer(const std::string & theName) {
std::map<std::string,TimerPtr>::iterator found = _myTimers.find(theName);
if (found == _myTimers.end()) {
TimerPtr myParent = findParent();
TimerPtr myNewTimer = TimerPtr(new Timer(myParent));
_myTimers[theName] = myNewTimer;
myNewTimer->setName(theName);
_mySortedTimers.push_back(std::make_pair(theName, myNewTimer));
return myNewTimer;
}
return found->second;
}
bool validTree(int n, vector<pair<int, int>>& edges) {
if (edges.size() != n - 1) {
return false;
}
vector<int> parent(n);
for (int i = 0; i < n; ++i) {
parent[i] = i;
}
for (auto& edge : edges) {
int p1 = findParent(parent, edge.first);
int p2 = findParent(parent, edge.second);
if (p1 != p2) {
parent[p1] = parent[p2];
}
else {
return false;
}
}
return true;
}
BVHSceneNode* BVHSceneTree::findParent(BVHSceneNode* node, SceneObject* object) const
{
BVHSceneNode* parent = nullptr;
if(node->type == SceneNodeType::Leaf)
{
if(node->object == object)
{
parent = node;
}
}
else
{
parent = findParent(node->left, object);
if(parent == nullptr)
{
parent = findParent(node->right, object);
}
}
return parent;
}
void TransferListView::setGroupMode(GroupMode mode) {
if(mode == mGroupMode)
return;
mGroupMode = mode;
if(mGroupMode == None) {
QList<QTreeWidgetItem *> items;
QList<QTreeWidgetItem *> subitems;
QList<QTreeWidgetItem *>::iterator sitx;
items = invisibleRootItem()->takeChildren ();
QList<QTreeWidgetItem *>::iterator itx = items.begin();
for(; itx != items.end(); ++itx) {
if ( ! ( *itx)->text(1).isNull())
invisibleRootItem()->addChild(*itx);
else {
subitems = (*itx)->takeChildren();
sitx = subitems.begin();
for(; sitx != subitems.end(); ++sitx)
invisibleRootItem()->addChild(*sitx);
}
}
setRootIsDecorated(false);
}
else {
QList<QTreeWidgetItem *> items;
items = invisibleRootItem()->takeChildren ();
QList<QTreeWidgetItem *>::iterator itx = items.begin();
for(; itx != items.end(); ++itx) {
if ( (*itx)->text(1).isNull())
invisibleRootItem()->addChild(*itx);
}
itx = items.begin();
for(; itx != items.end(); ++itx) {
if (! (*itx)->text(1).isNull()) {
TransferListItem *itxx = dynamic_cast<TransferListItem *>(*itx);
if (itxx)
findParent(itxx->user())->addChild(*itx);
}
}
updateParentsStats();
setRootIsDecorated(true);
}
}
// ---------------------------------------------------------------------------
//
// -----------
bGenericXMLBaseElement* bClassesMgr::ParseXMLDescriptors(bArray* xml){
_bTrace_("bClassesMgr::ParseXMLDescriptors",true);
int i,n;
xmlelt xelt;
bGenericXMLBaseElement *elt,*parent;
n=xml->count();
if(n<1){
_te_("empty array");
return(NULL);
}
for(i=1;i<=n;i++){
if(!xml->get(i,&xelt)){
_te_("xml->get failed");
return(NULL);
}
if((i==1)&&(xelt.indent!=0)){
_te_("(i==1)&&(elt->indent!=0)");
return(NULL);
}
elt=(bGenericXMLBaseElement*)CreateXMLInstance(xelt.name);
if(!elt){
_te_("instance not found :"+xelt.name);
return(NULL);
}
xelt.element=elt;
if(!xml->put(i,&xelt)){
_te_("xml->put failed");
return(NULL);
}
elt->setvalue(xelt.value);
if(i>1){
parent=(bGenericXMLBaseElement*)findParent(xml,i,xelt.indent);
if(!parent){
_te_("no parent");
return(NULL);
}
if(!parent->addelement(elt)){
_te_("parent->addelement(elt) returns false");
return(NULL);
}
}
}
xml->get(1,&xelt);
return(xelt.element);
}
void ControlResizer::addControl(HWND hwndCtl, HWND hwndParent, const AnchorStyle& anchorStyle) const
{
std::shared_ptr<ControlResizerItem> parent;
if (!hwndParent || hwndParent == window->hWnd)
parent = window;
else
parent = findParent(window->controls, hwndParent);
if (!parent)
throw std::exception("Parent not found");
RECT rect;
GetWindowRect(hwndCtl, &rect);
MapWindowPoints(HWND_DESKTOP, window->hWnd, (LPPOINT)&rect, 2);
std::shared_ptr<ControlResizerItem> item = std::make_shared<ControlResizerItem>();
item->hWnd = hwndCtl;
item->anchorStyle = anchorStyle;
item->newRect = rect;
parent->controls[hwndCtl] = item;
}
// In the vector, pass back pointers to vs copies of the families.
// Requires that the caller cleans up the families after!!
int CDFamily::createFamilies(vector<CCdCore*>& cds, vector<CDFamily*>& families)
{
vector<CCdCore*>::iterator cdIterator = cds.begin();
while(cdIterator != cds.end())
{
CCdCore* cd = *cdIterator;
if (!findParent(cd, cds)) //no parent, then use this cd as a root of family
{
CDFamily* cdFamily = new CDFamily(cd);
cds.erase(cdIterator);
extractFamily(cd, *cdFamily, cds);
families.push_back(cdFamily);
cdIterator = cds.begin();
}
else
++cdIterator;
}
return families.size(); //all cds should be added
}
// Find the ancestors of a locale, and fill 'out' with it (assumes out has enough
// space). If any of the members of stop_list was seen, write it in the
// output but stop afterwards.
//
// This also outputs the index of the last written ancestor in the stop_list
// to stop_list_index, which will be -1 if it is not found in the stop_list.
//
// Returns the number of ancestors written in the output, which is always
// at least one.
//
// (If 'out' is nullptr, we do everything the same way but we simply don't write
// any results in 'out'.)
size_t findAncestors(uint32_t *out, ssize_t *stop_list_index,
uint32_t packed_locale, const char *script,
const uint32_t *stop_list, size_t stop_set_length) {
uint32_t ancestor = packed_locale;
size_t count = 0;
do {
if (out != nullptr) out[count] = ancestor;
count++;
for (size_t i = 0; i < stop_set_length; i++) {
if (stop_list[i] == ancestor) {
*stop_list_index = (ssize_t) i;
return count;
}
}
ancestor = findParent(ancestor, script);
} while (ancestor != PACKED_ROOT);
*stop_list_index = (ssize_t) -1;
return count;
}
TypePtr VariableTable::checkProperty(BlockScopeRawPtr context,
Symbol *sym, TypePtr type,
bool coerce, AnalysisResultConstPtr ar) {
always_assert(sym->isPresent());
if (sym->isOverride()) {
Symbol *base;
ClassScopePtr parent = findParent(ar, sym->getName(), base);
assert(parent);
assert(parent.get() != &m_blockScope);
assert(base && !base->isPrivate());
if (context->is(BlockScope::FunctionScope)) {
GET_LOCK(parent);
type = parent->getVariables()->setType(ar, base, type, coerce);
} else {
TRY_LOCK(parent);
type = parent->getVariables()->setType(ar, base, type, coerce);
}
}
return setType(ar, sym, type, coerce);
}
void BST::insert(int key, double value) {
if(empty())
root = new Node(key, value);
else {
Node *parent = findParent(key);
// Not the multiset.
if(key == parent->key())
return;
Node *newNode = new Node(key, value);
if(key < parent->key())
parent->left = newNode;
if(key > parent->key())
parent->right = newNode;
newNode->parent = parent;
}
}
