Graph kruskal(Graph& g) { Graph N; Equiv e(g.numEdges); qsort((void*) g.arrayEdges, g.numEdges, sizeof(Edge), (QSORT_COMPARE_TYPE) compareEdges); if(tracer==2) { printf("\nThe array of edges after sorting:\n"); printGraph(g); } for(int i = 0; i < g.numEdges; i++) { if(tracer==2) { printf("\nThe edges %i and %i are being considered.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } if(!together(e, g.arrayEdges[i].vertOne, g.arrayEdges[i].vertTwo)) { if(tracer==2) { printf("The edges %i and %i were combined.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } combine(e, g.arrayEdges[i].vertOne, g.arrayEdges[i].vertTwo); N.arrayEdges[N.numEdges++] = g.arrayEdges[i]; } else { if(tracer==2) { printf("The edges %i and %i were not combined.\n",g.arrayEdges[i].vertOne,g.arrayEdges[i].vertTwo); } } } return N; }
int main() { char str1[10],str2[10]; memset(head.next,0,sizeof(head.next)); head.id=-1; while(~scanf("%s %s\n",str1,str2)) { // printf("%s %s\n",str1,str2); int s1=find(str1),s2=find(str2); // printf("%d %d\n",s1,s2); if(!deg[s1]) father[s1]=s1; if(!deg[s2]) father[s2]=s2; ++deg[s1],++deg[s2]; together(s1,s2); } judge(); return 0; }
int main() { while(scanf("%d%d",&n,&m)) { int k,x,y; if(!n&&!m) break; for(int i=0;i<n;++i) father[i]=i; for(int i=1;i<=m;++i){ scanf("%d",&k); scanf("%d",&x); for(int j=2;j<=k;++j){ scanf("%d",&y); together(x,y); } } ans=1; int f=getfather(0); for(int i=1;i<n;++i) if(getfather(i)==f) ++ans; printf("%d\n",ans); } }
IntervalledPolynom generateIntervalPartition(const unsigned int* const dimensional_upper_bounds, const size_t dimensions) { DEBUG_MSG("Interval Partitioning started"); // vektor<std::pair<vektor<unsigned int>, vektor<unsigned int> > solution; vektor<IB> intervalbounds; intervalbounds.push_back(dimensional_upper_bounds[0]); IntervalledPolynom intervalledPolynom; { Polynom pol(1); pol[0] = 1; intervalledPolynom.push_back(dimensional_upper_bounds[0], pol); } for(size_t k = 1; k < dimensions; ++k) { DEBUG_MSG("k: " << k); assert(dimensional_upper_bounds[k] > 0); vektor<IB> help_intervalbounds; help_intervalbounds.push_back(dimensional_upper_bounds[k] - 1); for(const IB& old_intervalbound : intervalbounds) help_intervalbounds.push_back(old_intervalbound + dimensional_upper_bounds[k]); vektor<IB> tmp_intervalbounds; IntervalledPolynom tmp_intervalledPolynom; for(size_t i = 0, j = 0, witness_left = 0, witness_right = 0, last_upper_bound_index = 0, last_lower_bound_index = 0; j < help_intervalbounds.size();) { const IB intervalbound = i < intervalbounds.size() ? intervalbounds[i] : 0; const IB help_intervalbound = help_intervalbounds[j]; const IB last_upper_bound = last_upper_bound_index == 0 ? 0 : (last_upper_bound_index > intervalbounds.size() ? intervalbounds[last_upper_bound_index-2] : intervalbounds[last_upper_bound_index-1]); const IB last_lower_bound = last_lower_bound_index == 0 ? 0 : (last_lower_bound_index > intervalbounds.size() ? intervalbounds[last_lower_bound_index-2] : intervalbounds[last_lower_bound_index-1]); DEBUG_MSG(""); DEBUG_MSG("k: " << k << ", i: " << i << ", j: " << j); if(i < intervalbounds.size()) { if(intervalbound < help_intervalbound) { tmp_intervalbounds.push_back(intervalbound); if(last_upper_bound < intervalbound) { ++witness_right; ++last_upper_bound_index; } if(intervalbound > last_lower_bound + dimensional_upper_bounds[k] ) //TODO: with else? { ++witness_left; ++last_lower_bound_index; } DEBUG_MSG("Fall 1, addiere " << intervalbound); // jetzt summe mit Anfangsintervall [..., // _old_intervals[j-1]] // und Endintervall [_old_intervals[i-1], ...]auswerten // Ergebnis zu _new_coefficients hinzufuegen ++i; } else if(intervalbound > help_intervalbound) { tmp_intervalbounds.push_back(help_intervalbound); if(last_upper_bound < help_intervalbound) { ++witness_right; ++last_upper_bound_index; } if(help_intervalbound > last_lower_bound + dimensional_upper_bounds[k]) { ++witness_left; ++last_lower_bound_index; } DEBUG_MSG("Fall 2, addiere " << help_intervalbound); // jetzt summe mit Anfangsintervall [..., // _old_intervals[j-1]] // und Endintervall [_old_intervals[i-1], // ...]auswerten // Ergebnis zu _new_coefficients hinzufuegen ++j; } else { tmp_intervalbounds.push_back(intervalbound); if(intervalbound > last_upper_bound) { ++witness_right; ++last_upper_bound_index; } if(intervalbound > last_lower_bound + dimensional_upper_bounds[k]) { ++witness_left; ++last_lower_bound_index; } DEBUG_MSG("Fall 3, addiere " << help_intervalbound); // jetzt summe mit Anfangsintervall [..., // _old_intervals[j-1]] // und Endintervall [_old_intervals[i-1], // ...]auswerten // Ergebnis zu _new_coefficients hinzufuegen ++i; ++j; } } else { tmp_intervalbounds.push_back(help_intervalbound); if(help_intervalbound > last_upper_bound && last_upper_bound_index <= intervalbounds.size()) { ++witness_right; ++last_upper_bound_index; } if(help_intervalbound > last_lower_bound + dimensional_upper_bounds[k]) { ++witness_left; ++last_lower_bound_index; } /* if(help_intervalbound <= static_cast<long>(intervalbounds[intervalbounds.size()-1])) { witness_right = intervalbounds.size(); ++witness_left; } else { if(witness_right == intervalbounds.size()) ++witness_right; else ++witness_left; } */ DEBUG_MSG("Fall 4, addiere " << help_intervalbound); // jetzt summe mit Anfangsintervall [..., // _old_intervals[j-1]] // und Endintervall [_old_intervals[i-1], ...]auswerten // Ergebnis zu _new_coefficients hinzufuegen ++j; } DEBUG_MSG("intervalledPolynom: " << intervalledPolynom); DEBUG_MSG("tmp_intervalledPolynom: " << tmp_intervalledPolynom); DEBUG_MSG("Witness: " << "[" << witness_left << ", " << witness_right << "]"); DEBUG_MSG("tmp_intervalbounds: " << tmp_intervalbounds); DEBUG_MSG("intervalbounds: " << intervalbounds); if(witness_left == witness_right) { if(witness_left <= intervalbounds.size() && witness_left > 0) { const IB& current_intervalbound = intervalbounds[witness_left-1]; //! DEBUG_MSG("Intervalbound: " << current_intervalbound); const Polynom& toSum = intervalledPolynom.at(current_intervalbound); const Polynom& upper = SumFromZeroToUpper::s(toSum); const Polynom lower = sumFromZeroToZMinusGamma(toSum, dimensional_upper_bounds[k]+1); Polynom together(std::max(upper.size(), lower.size())+1); for(size_t l = 0; l < together.size(); ++l) { if(l < upper.size()) together[l] += upper[l]; if(l < lower.size()) together[l] -= lower[l]; } DEBUG_MSG("Together Sum: " << together); tmp_intervalledPolynom.push_back(tmp_intervalbounds.back(), together); } else tmp_intervalledPolynom.push_back(tmp_intervalbounds.back(), Polynom::zero); } else { const Polynom lower_sum = (witness_left < 1 || witness_left-1 >= intervalbounds.size()) ? Polynom::zero : [&] () -> Polynom { const IB& lower_sum_intervalbound = intervalbounds[witness_left-1]; //! DEBUG_MSG("Lower Interval: " << lower_sum_intervalbound); return sumFromZMinusGammaToUpper(intervalledPolynom.at(lower_sum_intervalbound), dimensional_upper_bounds[k], lower_sum_intervalbound); }(); DEBUG_MSG("Lower Sum: " << lower_sum); const Z const_sum = ( (witness_left > 0 || witness_right > 0) && witness_right-witness_left > 1) ? [&] () -> Z { Q const_sumq; for(size_t constinterval = witness_left; constinterval <= witness_right-2; ++constinterval) { if(constinterval >= intervalbounds.size()) break; //! const IB& intervalupper_bound = intervalbounds[constinterval]; //! const Polynom& summedUp = SumFromZeroToUpper::s(intervalledPolynom.at(intervalupper_bound)); const_sumq += summedUp(intervalupper_bound); if(constinterval > 0) { const IB& intervallower_bound = intervalbounds[constinterval-1]; //! const_sumq -= summedUp(intervallower_bound); } } mpq_canonicalize(const_sumq.get_mpq_t()); assert(const_sumq.get_den() == 1); return const_sumq.get_num(); }() : 0; DEBUG_MSG("Constant Sum: " << const_sum); const Polynom upper_sum = (witness_right-1 >= intervalbounds.size()) ? Polynom::zero : [&] () -> Polynom { const IB& upper_sum_intervalupper_bound = intervalbounds[witness_right-1]; //! Polynom upper_sum_pol = SumFromZeroToUpper::s(intervalledPolynom.at(upper_sum_intervalupper_bound)); if(witness_right > 1) { const IB& upper_sum_intervallower_bound = intervalbounds[witness_right-2]; upper_sum_pol[0] -= upper_sum_pol(upper_sum_intervallower_bound); } DEBUG_MSG("Upper Interval: " << upper_sum_intervalupper_bound); return upper_sum_pol; }(); DEBUG_MSG("Upper Sum: " << upper_sum); Polynom together(std::max(upper_sum.size(), lower_sum.size())+1); for(size_t l = 0; l < together.size(); ++l) { if(l < lower_sum.size()) together[l] += lower_sum[l]; if(l < upper_sum.size()) together[l] += upper_sum[l]; } together[0] += const_sum; DEBUG_MSG("Together Sum: " << together); tmp_intervalledPolynom.push_back(tmp_intervalbounds.back(), together); } } intervalbounds.swap(tmp_intervalbounds); intervalledPolynom.swap(tmp_intervalledPolynom); DEBUG_MSG("_old_intervals: " << intervalbounds); } DEBUG_MSG("Resulting Intervalled Polynom: " << intervalledPolynom); return intervalledPolynom; }