Introduction to algorithms Chapter 1 after-school questions (Fuzzy sorting of intervals)

I. Question

Consider such a sorting problem, that is, you cannot accurately know the exact size of each number in the sorting. for each number, we only know that it falls within a certain range on the real axis. that is, the given n closed intervals in the form of [ai, BI], where Ai is less than or equal to bi. the goal of the algorithm is to perform fuzzy-sort for these intervals, that is, to generate a sort for each interval. <I1,
I2, I3, I4 ,... In>, so that there is a CJ in [ai,
BI], satisfying C1 ≤ C2 ≤... ≤ CN.)           Design an algorithm for Fuzzy sorting of N intervals. Your algorithm should have a general structure of the algorithm, which can quickly sort the left endpoint (that is, each AI To improve the running time. (as the number of overlapping intervals increases, sorting of intervals becomes more and more easy. Your algorithm should be able to make full use of this overlap .) b)         Proof:
Generally, your algorithm runs at O (N * lgn) intervals, but when all the intervals overlap, the expected run time is O (n) (that is, when there is a value of X, so that all I have X in [ai, BI]). your algorithms should not explicitly check this situation, but should naturally improve performance as the number of overlaps increases.

Ii. Thinking

Based on the Division idea of the Quick Sort, a certain element is used as the primary element to divide the region into three segments. The first segment is smaller than the principal component, and the second segment is equal to the principal component.

The focus is on Division. If the intervals overlap, they will be treated as equal, and the public part will be extracted for further division.

A. End <B. Start => A <B

A. Start> B. End => A> B

Other cases => A = B

To avoid situations such as (), We need to extract the common factor and update the principal element when the principal element is equal)

The specific explanations are in the code.

Iii. Code

[CPP]
View plaincopyprint?

1. # Include <iostream>
2. Using namespace STD;
4. Struct Node
5. {
6. Int start;
7. Int end;
8. Bool operator <(const node & B) const
9. {
10. Return end <B. Start;
11. }
12. Bool operator = (const node & B) const
13. {
14. Return (end> = B. Start) & (start <= B. End );
15. }
16. Bool operator> (const node & B) const
17. {
18. Return Start> B. end;
19. }
20. };
22. // Division results: 0-> A is smaller than the principal component, A + 1-> B-1 is equal to the principal component, B-> length_a is greater than the principal component
    
23. Struct divid
24. {
25. Int;
26. Int B;
27. };
29. Node A [11];
30. Int length_a = 10;
32. // Display the results in three rows
33. Void print (divid D)
34. {
35. Int I = 1;
36. If (D. A> 0)
37. {
38. For (I = 1; I <= d. a; I ++)
39. Cout <'(' <A [I]. Start <',' <A [I]. End <")";
40. Cout <Endl;
41. I = D. A + 1;
42. }
43. If (d. B> 0)
44. {
45. For (; I <D. B; I ++)
46. Cout <'(' <A [I]. Start <',' <A [I]. End <")";
47. Cout <Endl;
48. I = D. B;
49. }
50. If (I <= length_a)
51. {
52. For (; I <= length_a; I ++)
53. Cout <'(' <A [I]. Start <',' <A [I]. End <")";
54. Cout <Endl;
55. }
56. Cout <Endl;
57. }
58. // Exchange
59. Void Exchange (node & A, node & B)
60. {
61. Node temp;
62. Temp =;
63. A = B;
64. B = temp;
65. }
66. // Division is important
67. Divid partition (node * a, int P, int R)
68. {
69. // Take any element as the primary element
70. Node x = A [R];
71. Int I = p-1, j = R + 1, K = P;
72. While (k <= R & K <j)
73. {
74. // If it is less than the principal component, switch to the front
75. If (A [k] <X)
76. {
77. I ++;
78. Exchange (A [I], a [k]);
79. K ++;
80. }
81. // If the value is greater than, it is switched to the end.
82. Else if (a [k]> X)
83. {
84. J --;
85. Exchange (A [J], a [k]);
86. // K ++ is not allowed here, because the exchanged elements may be greater than the principal element.
    
87. }
88. Else
89. {
90. // If they are equal, they are not exchanged, but the common factor must be extracted.
91. X. End = min (X. End, a [K]. End );
92. X. Start = max (X. Start, a [K]. Start );
93. K ++;
94. }
95. }
96. // Return the division result
97. Divid ret = {I, j };
98. If (Ret. A <p) ret. A =-1;
99. If (Ret. B> r) ret. B =-1;
100. Print (RET );
101. Return ret;
102. }
104. Void quicksort (node * a, int P, int R)
105. {
106. If (P> = r)
107. Return;
108. // Divide the array into three segments
109. Divid q = partition (A, P, R );
110. // If the first segment exists, sort the first segment
111. If (Q. A> 0)
112. Quicksort (A, p, q. );
113. // If the third segment exists, sort the third segment
114. If (Q. B> 0)
115. Quicksort (A, Q. B, R );
116. }
118. Int main ()
119. {
120. Int I, N;
121. Cin> N;
122. Length_a = N;
123. // Init data by random
     
124. For (I = 1; I <= length_a; I ++)
125. {
126. A [I]. Start = rand () % 100;
127. A [I]. End = rand () % 100;
128. If (A [I]. Start> A [I]. End)
129. Swap (A [I]. Start, a [I]. End );
130. }
131. Divid d = {-1,-1 };
132. Print (d );
133. // Sort
134. Quicksort (A, 1, length_a );
135. Return 0;
136. }

# Include <iostream> using namespace STD; struct node {int start; int end; bool operator <(const node & B) const {return end <B. start;} bool operator = (const node & B) const {return (end> = B. start) & (start <= B. end);} bool operator> (const node & B) const {return start> B. end ;}}; // partition result: 0-> A is smaller than principal component, A + 1-> B-1 is equal to Principal Component, B-> length_a is greater than Principal Component struct divid {int; int B ;}; node A [11]; int length_a = 10; // display void print (divid d) {int I = 1; if (D. a> 0) {for (I = 1; I <= D. a; I ++) cout <'(' <A [I]. start <',' <A [I]. end <")"; cout <Endl; I = D. A + 1;} If (D. b> 0) {for (; I <D. b; I ++) cout <'(' <A [I]. start <',' <A [I]. end <")"; cout <Endl; I = D. b;} if (I <= length_a) {for (; I <= length_a; I ++) cout <'<A [I]. start <',' <A [I]. end <")"; cout <Endl ;}cout <Endl ;}// exchange void Exchange (node & A, node & B) {node temp; temp = A; A = B; B = temp;} // Division is the key divid partition (node * a, int P, int R) {// take any element as the primary node x = A [R]; int I = p-1, j = R + 1, K = P; while (k <= R & K <j) {// if it is smaller than the principal component, switch to the front if (a [k] <X) {I ++; exchange (A [I], a [k]); k ++;} // if the value is greater than, switch to the following else if (a [k]> X) {J --; exchange (A [J], a [k]); // here K ++ is not allowed, because the exchanged elements may be greater than the principal element} else {// if they are equal, do not exchange, but extract the public factor X. end = min (X. end, a [K]. end); X. start = max (X. start, a [K]. start); k ++; }}// returns the division result divid ret = {I, j}; If (Ret. A <p) ret. A =-1; if (Ret. b> r) ret. B =-1; print (RET); return ret;} void quicksort (node * a, int P, int R) {If (P> = r) return; // divide the array into three segments: divid q = partition (A, P, R); // if the first segment exists, sort the first segment if (Q. a> 0) quicksort (A, P, Q. a); // if the third segment exists, sort the IF (Q. b> 0) quicksort (A, Q. b, R) ;}int main () {int I, n; CIN> N; length_a = N; // init data by randomfor (I = 1; I <= length_a; I ++) {A [I]. start = rand () % 100; A [I]. end = rand () % 100; if (a [I]. start> A [I]. end) Swap (A [I]. start, a [I]. end) ;}divid D ={-1,-1 }; print (d); // sortquicksort (A, 1, length_a); Return 0 ;}

 

Reprinted from: http://blog.csdn.net/mishifangxiangdefeng/article/details/7681109