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