HDOJ-3635-Dragon ballproblem solving report

<Knowledge Sharing>

This is a question of investigating and querying the path compression of a set. In Wukong's world, there are n dragons and N cities (numbered from 1 to n). At first, X-Dragon placed each Dragon Ball in the corresponding city. Wukong wants to collect dragon beads, but these dragon beads are sometimes transferred. You need to tell Wukong some information about longzhu. Now we have another T group test. Each test group has a n (number of dragons and cities) and a Q (number of operation actions). There are two types of operation actions:

T a B. Move all the dragon beads in the city where the Dragon beads numbered a are located to the city where the Dragon beads numbered B are located. The two cities are different.

Q a, Wukong needs to know X (the number of the city where longzhu A is located), y (the number of longzhu in the city numbered X), and Z (the number of longzhu transfers numbered)

 

Solution: first, we need to know three pieces of information based on the number of each Dragon Ball, the number of the city where the Dragon Ball is located, and the number of times the Dragon Ball has been transferred. First, let's analyze the T operation. First, the two cities must be different. Then, when we move all the dragons to another city, there must be a Dragon Ball that was already in that city and has never been moved at one time. This Dragon Ball is the root node. Similarly, the root node Dragon Ball has never been moved and will not move all the dragon beads in the city to an empty city. With this rule, we can maintain the number of Dragon beads in the city where the root node is located to find the X and Y of each Dragon Ball in the city. As for Z, We need to compress the corresponding node to the root node during path compression, and the corresponding Z should also be updated synchronously, each time we move, we only move the number of root nodes of the city to be moved more than 1. Then, when the path is compressed, the sum of the number of moving nodes along the way (including the nodes to be compressed) this is the actual number of times the node is moved.

 

The solution code is as follows:

1. # Include <stdio. h>
2. # Include <stdlib. h>
3. # Define n 10001
5. Int bleg [N]; // store the parent node of the current node
6. Int Tran [N]; // number of times the storage is moved
7. Int City [N]; // the city where the storage is located
8. Int bnum [N]; // The total number of beads stored in the same location
9. Int T;
10. Int n, m;
12. Void Init (); // Initialization
14. Int find (int x); // query the set
16. Void Union (int x, int y); // query the set and perform the T operation.
18. Void Q (int x );
20. Int main ()
21. {
22. Int Tn = 1;
23. Int I, A, B;
24. Char ch;
25. Scanf ("% d", & T );
26. While (t --)
27. {
28. Scanf ("% d", & N, & M );
29. Init ();
30. Printf ("case % d: \ n", TN ++ );
31. For (I = 0; I <m; ++ I)
32. {
33. Scanf ("% C", & Ch );
34. If (CH = 'T ')
35. {
36. Scanf ("% d", & A, & B );
37. Union (A, B );
38. }
39. Else
40. {
41. Scanf ("% d", & );
42. Q ();
43. }
44. }
45. }
46. Return 0;
47. }
49. Void Init () // Initialization
50. {
51. Int I;
52. For (I = 1; I <= N; ++ I)
53. {
54. Bleg [I] = City [I] = I; // initialize the parent node and the city
55. Tran [I] = 0;
56. Bnum [I] = 1;
57. }
58. Return;
59. }
61. Int find (int x) // query the query set
62. {
63. Int y = X;
64. Int Z;
65. Int ntran = 0;
66. While (y! = Bleg [y])
67. {
68. Ntran + = Tran [y]; // total number of times nodes are moved along the storage path
69. Y = bleg [y];
70. }
71. While (X! = Bleg [x])
72. {
73. Z = bleg [x];
74. Ntran-= Tran [X]; // prepare for the next node to update the number of moves
75. Bleg [x] = y; // compress to the root node
76. Tran [x] + = ntran; // synchronously update the number of moves
77. X = z;
78. }
79. Return y;
80. }
82. Void Union (int x, int y) // query the set and perform the T operation.
83. {
84. Int FX = find (X );
85. Int FY = find (y );
86. Bleg [FX] = FY;
87. + Tran [FX]; // The number of root nodes to be moved increases by 1
88. Bnum [FY] + = bnum [FX]; // update the number of Dragon beads in the city
89. Return;
90. }
92. Void Q (int x)
93. {
94. Int FX = find (X );
95. Printf ("% d \ n", City [FX], bnum [FX], Tran [x]);
96. Return;
97. }