And find out the detailed

When using and looking up a set, if the number of lookups is many, then the use of the naïve version of the lookup must be timed out. For example, there are 1 million elements, every time from the 1 millionth start to find, such an operation is 10^6, if the program asked to find 10 million times, so down is 10^13, it must be a problem.

This is the code of the simple lookup, suitable for a small amount of data

Findx (x)

{

R=x; 

while (parent[!=r)  

R=parent[r];  

R

}

Here's how to find the element using path compression:

Find (//Find the collection where the X element resides, and compress the path when backtracking )

{

if (parent[x]) 

{

parent[Find (parent[//Backtracking compression path  

The nodes that pass from the X-node search to the ancestor node point to the Ancestor node.

parent[x];

}

The above is a recursive way to compress the path, but the recursive compression path may cause overflow stack, I used to because of this re n times, below we say a non-recursive way to do the path compression:

Next is the merged code, which guarantees that the small subtree can be attached to the large subtree.

There are many groups of students, students in the same group often contact, there will be new students to join. But SARS is very easy to infect, as long as the reorganization of a classmate infected with SARS, then all of the group's students are considered SARS. The task now is to figure out how many students are infected with SARS. It is assumed that the student with number 0 is suffering from SARS.

The idea of solving the problem----> obviously and check the set. A detailed explanation of the check set can be learned by clicking and checking the set (disjoint collection). Use num[] to store the number of elements in the collection and update num[when the collection is merged]. Then find the root node x of the collection where 0 is located, so num[x] is answer.

2. Code highlighting produced by Actipro Codehighlighter (freeware) http://www. codehighlighter.com/--> #include <stdio.h>//by ktyanny
4. #include <iostream>
6. Using namespace std;
10. const int maxn = 30001; / * Number of nodes on line * /
12. int PA[MAXN]; /*p[x] Represents the parent node of x * /
14. int RANK[MAXN]; /*rank[x] is an upper bound of the height of x * /
16. int NUM[MAXN]; /*num[] Stores the number of elements in the collection and updates num[when the collection is merged] * /
20. void Make_set (int x)
22. {/* Create a unit set * /
24. PA[X] = x;
26. Rank[x] = 0;
28. NUM[X] = 1;
30. }
34. int Find_set (int x)
36. {/* Lookup with path compression * /
38. / * Save the number you want to find * /
40. int r = x, temp;
42. / * Locate the root node * /
44. while (pa[r]! = r) R = Pa[r];
46. While (x! = r)
48. {
50. temp = pa[x];
52. Pa[x] = r;
54. x = temp;
56. }
58. return x;
60. //if (x! = Pa[x])//commented out is actually OK, but do not want to use the return to do
62. //Pa[x] = Find_set (pa[x]);
64. //return pa[x];
66. }
70. /* Merges the collection of x, y by rank */
72. void Union_set (int x, int y)
74. {
76. x = Find_set (x);
78. y = Find_set (y);
80. if (x = = y)return;
82. if (rank[x] > Rank[y])/* make rank higher as parent node * /
84. {
86. Pa[y] = x;
88. NUM[X] + = Num[y];
90. }
92. Else
94. {
96. Pa[x] = y;
98. if (rank[x] = = Rank[y])
100. rank[y]++;
102. Num[y] + = num[x];
104. }
106. }
110. Answer to 1611
112. int main ()
114. {
116. int N, m, x, y, I, T, J;
118. while (scanf ("%d%d", &n, &m))
120. {
122. if (m==n && n = = 0) break ;
124. if (m = = 0)
126. {
128. cout << "1\n";  continue;
130. }
132. For (i = 0; i < n; i++)
134. Make_set (i);
136. For (i = 0; i < m; i++)
138. {
140. scanf ("%d", &t);
142. scanf ("%d", &x);
144. For (j = 1; j < T; j + +) {
146. scanf ("%d", &y);
148. Union_set (x, y);
150. x = y;
152. }
154. }
156. x = Find_set (0); / * Find the root of the 0 tree * * *
158. //int ans = 0;
160. //for (i = 0; i < n; i++)
162. //if (pa[i] = = x)
164. //ans++;
166. //cout << ans << endl;
168. cout << num[x] << Endl;
170. }
172. return 0;
174. }

And find out the detailed