PKU 2553 the bottom of a graph-extremely large Strongly Connected Component

Pku2553 zju1979 the bottom of a graph

Description:

A directed graph is provided, which defines that if all vertices {wi} that can be reached by node v can both reach V, node v is called sink. All sink points are required.

Analysis:

Similar to such a question,Some members of the football team can contact other members and ask the coach how many members should be notified, so that all players can receive a training notification.

This classic topic is explained in Wu wenhu's graph theory book.Minimum vertex base of a Directed Graph. The method is as follows:

First, divide the directed graph into severalExtremely Large connected component. For each strongly connected component CI, you only need to notify one person. These strongly connected components are either independent of each other, or one-way edge is directed to CJ from the connected component CI to form a forest. For each tree, you only need to notify any one of the Root Node Croot. The entire tree can be notified. Then, you only need to count the number of connected components whose input degree is 0.

 

Now let's go back to this question. Similarly, what the question requires isAll nodes in the connected component with an outbound degree of 0. Output by serial number.

The key to this question isStrongly Connected Component of a Directed Graph. The subsequent work is very simple.

In addition, I'm glad that zju has won the first place in this question :)~

Submit time language run time (MS) Run memory (Kb) User Name
21:53:04 C ++ 30 628 Tiaotiao

1. /*
2. PKU2553 The Bottom of a Graph
3. */
5. # Include <stdio. h>
6. # Include <memory. h>
8. # Define clr (a) memset (a, 0, sizeof ())
9. # Define n 5005
10. # Define M 50000
12. Typedef struct strnode {
13. Int J;
14. Struct strnode * next;
15. } Node;
17. Node mem [m];
18. Int memp;
20. Void addedge (node * E [], int I, Int J ){
21. Node * P = & mem [memp ++];
22. P-> J = J;
23. P-> next = E [I];
24. E [I] = P;
25. }
27. Int g_dfs_first;
28. Void dfs_conn (node * E [], int I, int mark [], int f [], int * NF ){
29. Int J; node * P;
30. If (MARK [I]) return;
32. Mark [I] = 1;
33. If (! G_dfs_first) f [I] = * NF; // reverse search to obtain the connected component number
35. For (P = E [I]; P! = NULL; P = p-> next ){
36. J = p-> J;
37. Dfs_conn (E, J, Mark, F, NF );
38. }
39. If (g_dfs_first) f [(* NF) ++] = I; // forward search, get the timestamp
40. }
42. /*
43. Digraph extremely large Strongly Connected Component
44. Parameters:
45. Join Table E [], number of nodes N. Returns the number of strongly connected branches (ncon.
46. Return CON [I], which indicates the ID of the strongly connected component to which node I belongs, 0 ~ Ncon-1.
47. */
48. Int connection (node * E [], int N, int CON []) {
49. Int I, J, K, Mark [N], ncon;
50. Int time [N], ntime; // time [I] indicates the node whose time stamp is I
51. Node * P, * re [N]; // reverse edge
53. // Construct the reverse edge joining table
54. CLR (re );
55. For (I = 0; I <n; I ++ ){
56. For (P = E [I]; P! = NULL; P = p-> next)
57. Addedge (Re, p-> J, I );
58. }
60. // Forward to DFS to obtain the timestamp
61. G_dfs_first = 1;
62. CLR (Mark); CLR (time); ntime = 0;
63. For (I = 0; I <n; I ++ ){
64. If (! Mark [I])
65. Dfs_conn (E, I, Mark, time, & ntime );
66. }
68. // Reverse DFS to obtain strongly connected components
69. G_dfs_first = 0;
70. CLR (Mark); CLR (CON); ncon = 0;
71. For (I = n-1; I> = 0; I --){
72. If (! Mark [time [I]) {
73. Dfs_conn (Re, time [I], Mark, Con, & ncon );
74. Ncon ++;
75. }
76. }
77. }
80. // Vars
81. Node * E [N];
82. Int CON [N], ncon;
83. Int n, m;
85. Int d [N];
87. Int main ()
88. {
89. Int I, J, K, X, Y;
90. Node * P;
92. While (scanf ("% d", & N )! = EOF & N ){
93. // Init
94. Memp = 0; CLR (E );
95. // Input
96. Scanf ("% d", & M );
97. For (k = 0; k <m; k ++ ){
98. Scanf ("% d", & I, & J); I --; j --;
99. Addedge (E, I, j );
100. }
101. // Connection
102. Ncon = Connection (E, N, con );
103. // Work d []
104. CLR (d );
105. For (I = 0; I <n; I ++ ){
106. X = CON [I];
107. For (P = E [I]; P! = NULL; P = p-> next ){
108. Y = CON [p-> J];
109. If (X! = Y) d [x] ++;
110. }
111. }
112. // Output
113. J = 0;
114. For (I = 0; I <n; I ++ ){
115. K = CON [I];
116. If (d [k] = 0 ){
117. If (j) printf (""); j = 1;
118. Printf ("% d", I + 1 );
119. }
120. }
121. Puts ("");
122. }
124. Return 0;
125. }