Pku3378 crazy thairs-Dynamic Planning + tree Array

Description:

Given a numerical sequence {ai} with a length of N, ask how many ascending subsequences with a length of 5 in total. (AI <10 ^ 9, n <= 50000)

Analysis:

Because the number range is largeDiscretization1 ~ An integer between N. The original A [] array is converted to the D [] array, where D [I] = J indicates that a [I] is the number smaller than J in the [] array.

AvailableDynamic PlanningTo describe this algorithm:

P starts from 0 to N, And I = d [p].F [I] [k] indicates the number of Ascending Sequences ending with the number I and with the length k.

F [I] [k] + = Σ f [J] [k-1] (1 <= j <I)

F [I] [1] = 1

Such a dynamic transfer equation can be used to find the correct solution, but the time complexity isO (N ^ 2).

This can be used hereTree ArrayTo optimize the algorithm. We can see that what is required during status transfer is 1 ~ The sum of F [J] [I-1] Between K-1. Meets the requirements of the tree Array application. Modify the definition of F [I] [k] so that it is applied to a tree array. Reduced time complexityO (nlogn)

Note:1. The largest group of data should exceed int64, so it should be calculated using a large number. 2. the AI in the input data may have the same elements. You must handle them carefully.

 

1. /*
2. Pku3378 crazy thairs
3. */
5. # Include <stdio. h>
6. # Include <stdlib. h>
7. # Include <string. h>
9. # Define clr (a) memset (a, 0, sizeof ())
10. # Define int64 bignum_t
12. # Define N 50005
14. /*************************************** *************/
16. # Define DIGIT 4 // number of digits stored by an array element
17. # Define DEPTH 10000 // DEPTH = 10 DIGIT
18. # Define MAX 30 // array Length
20. Typedef int bignum_t [MAX + 1];
22. // Assign a value
23. Void value (bignum_t a, char buf []) {
24. Char ch;
25. Int I, j;
26. Memset (void *) a, 0, sizeof (bignum_t ));
28. For (a [0] = strlen (buf), I = a [0]/2-1; I> = 0; I --)
29. Ch = buf [I], buf [I] = buf [a [0]-1-i], buf [a [0]-1-i] = ch;
30. For (a [0] = (a [0] + DIGIT-1)/DIGIT, j = strlen (buf); j <a [0] * DIGIT; buf [j ++] = '0 ');
31. For (I = 1; I <= a [0]; I ++)
32. For (a [I] = 0, j = 0; j <DIGIT; j ++)
33. A [I] = a [I] * 10 + buf [I * DIGIT-1-j]-'0 ';
34. For (;! A [a [0] & a [0]> 1; a [0] --);
35. }
37. // Output
38. Void write (const bignum_t ){
39. Int I, j;
40. For (printf ("% d", a [I = a [0]), I --; I --)
41. For (j = DEPTH/10; j/= 10)
42. Printf ("% d", a [I]/j % 10 );
43. Puts ("");
44. }
46. // Addition
47. Void add (bignum_t A, const bignum_t B) {// high-precision number A + B, the result is in
48. Int I;
49. For (I = 1; I <= B [0]; I ++)
50. If (A [I] + = B [I])> = depth)
51. A [I]-= depth, a [I + 1] ++;
52. If (B [0]> = A [0])
53. A [0] = B [0];
54. Else
55. For (; A [I]> = depth & I <A [0]; A [I]-= depth, I ++, a [I] ++ );
56. A [0] + = (a [0] + 1]> 0 );
57. }
59. /*************************************** *****************/
61. Int n, m;
62. Int A [n], B [N], d [N];
63. Int64 f [N] [5];
65. Int cmp (const void * I, const void * j ){
66. Return a [* (int *) I]-a [* (int *) j];
67. }
69. Void Add (int I, int j, int64 t ){
70. While (I <= m ){
71. Add (f [I] [j], t );
72. I + =-I & I;
73. }
74. }
76. Void Sum (int I, int j, int64 s ){
77. Char c0 [10] = "0 ";
78. Value (s, c0 );
79. While (I> 0 ){
80. Add (s, f [I] [j]);
81. I-=-I & I;
82. }
83. }
85. Int main ()
86. {
87. While (scanf ("% d", & N )! = EOF ){
88. Int I, J, K;
89. // Input
90. For (I = 0; I <n; I ++ ){
91. Scanf ("% d", & A [I]);
92. B [I] = I;
93. }
94. // Order
95. Qsort (B, n, sizeof (B [0]), CMP );
96. M = 1;
97. D [B [0] = 1;
98. For (I = 1; I <n; I ++ ){
99. If (A [B [I]! = A [B [I-1]) m ++;
100. D [B [I] = m;
101. }
103. // DP
104. Int64 V1, T, U;
105. Char C0 [10] = "0 ";
106. Char c1 [10] = "1 ";
107. Value (V1, C1 );
108. For (k = 0; k <= m; k ++) {// CLR
109. For (j = 0; j <5; j ++ ){
110. Value (F [k] [J], C0 );
111. }
112. }
113. For (k = 0; k <n; k ++) {/dp
114. I = d [k];
115. Add (I, 0, V1); // F [I] [0] = 1
116. For (j = 1; j <= 4; j ++ ){
117. Sum (I-1, J-1, T); // F [J] T = sum (I-1)
118. Add (I, j, T); // F [] [J] add (I, T)
119. }
120. }
121. // Total
122. Int64 total;
123. Sum (m, 4, total );
124. // Output
125. Write (total );
126. }
127. Return 0;
128. }