Optimization of Kingsoft program Question 2

A few days ago the Kingsoft company to the program problem under, the Code also posted, the original here: http://student.csdn.net/space.php? Uid = 53444 & Do = Blog & id = 16634

Programming 2

Given an array size m and an array Array
M = 10; array = {1, 2, 4, 5, 6, 7, 8, 9, 10}
Obtain the number of n (n <= m) randomly from the array so that the sum of M is obtained. For example, 10, 9, 2, and 5.
Method prototype: int getotalnum (INT [] array, int m );
 

The original code was not optimized very well, so it was rewritten this morning.

There is no change in time complexity. It is still O (SIGMA (1 <I <N, C (n, I), but the pruning effect of the new algorithm is better.

The main method is to rewrite the combine function and move the external call cycle of combine into the combine function. This reduces the redundancy of repeated calculation of some results in the combine function and improves the running efficiency.

The new Code is as follows:

Code:

1. /*************************************** *********************
2. * Name: problem02.c *
3. * Description: n elements in the integer array and M (M> = N) equal to the number of elements )*
4. * Assume that an element cannot be repeated *
5. * Train of Thought: from 1 to M groups and array elements, and sum to determine whether it is equal to M *
6. * Environment: Code: blocks & Windows 7 & x86 *
7. * Note: davelv is from 09-12-06 *
8. **************************************** *********************/
9. # Include <stdio. h>
10. # Include <stdlib. h>
11. # Include <string. h>
12. # Define buf_len 1024.
13. // Comparison function for qsort
14. Int compare (const void * a, const void * B );
15. // There are several methods to obtain Functions
16. Int getotalnum (INT array [], int m );
17. // Numeric combination Function
18. Void combine (INT array [], int result [], int m );
20. Int main (void)
21. {
22. Int Buf [buf_len], M, I;
24. Printf ("Please input no. of INTEGER (s) No more than % d:", buf_len );
25. Scanf ("% d", & M );
26. Printf ("Please input INTEGER (s ):");
27. For (I = 0; I <m; I ++)
28. {
29. Scanf ("% d", BUF + I );
30. }
31. Printf ("totle % d way (s)/n", getotalnum (BUF, m ));
32. Return 0;
33. }
35. Int compare (const void * a, const void * B)
36. {
37. Return * (int *) A-* (int *) B;
38. }
39. // The returned value is the total number of methods. If the value is-1, the function fails.
40. Int getotalnum (INT array [], int m)
41. {
42. Int I, totle;
43. Int * result;
44. Qsort (array, M, sizeof (array [0]), compare); // sort
45. // Exclude numbers larger than m
46. For (I = 0; I <m; I ++)
47. {
48. If (array [I]> m)
49. {
50. M = I;
51. Break;
52. }
53. }
54. Result = (int *) malloc (M * sizeof (INT); // allocate cache space for the combine Function
55. If (result = NULL)
56. Return-1;
57. Combine (array, result, M );
58. Totle = * result;
59. Free (result );
60. Return totle;
61. }
62. // Array: Stores numbers, result: Number of stored results, and M: Number of numbers
63. Void combine (INT array [], int result [], int m)
64. {
65. Int I, T; // counter, the intermediate variable of the begin variable
66. Static int totle = 0, level = 0, begin = 0, num = 0; // combined numbers and, recursive depth, subscript of the starting element of the combination, the number of combinations that meet the requirements
68. For (I = begin; I <= m; I ++)
69. {
70. Totle + = array [I];
71. Result [level] = array [I]; // Save the current number
72. If (Totle <m) // determines whether the current combination number and m limit have been exceeded.
73. {
74. // Determine whether the current number of layers is M-1
75. If (Level m-1)
76. {
77. Level ++;
78. T = begin;
79. Begin = I + 1;
80. Combine (array, result, m); // lower Recursion
81. Begin = T;
82. Level --;
83. }
84. }
85. Else if (Totle> m) // if the value exceeds m, the current loop is exceeded.
86. {
87. Totle-= array [I];
88. Break;
89. }
90. Else
91. {
92. Int J;
93. For (j = 0; j <= level; j ++) // outputs a number if the match exists.
94. Printf ("% d", result [J]);
95. Puts ("");
96. Num ++; // counter plus one
97. }
98. Totle-= array [I];
99. }
101. If (Level = 0)
102. {
103. Result [0] = num;
104. }
105. }

Test the time consumed by the new and old programs getotlenum () using a self-written test program. The results are as follows:

Code:

1. E:/cbwork/testc/bin/release> driver.exe
2. Generate_test_data_file OK!
3. Run tested programs
4. Data old (MS) New (MS)
5. 50 75 2
6. 60 289 5
7. 70 998 15
8. 80 3278 44
9. 90 9409 107
10. 100 26747 261
11. 110 69330 601

GCC (GCC) 3.4.5 (mingw-Vista special), O2 switch optimization, win7, Intel Pentium dual-core 1.8 GHz, 1 GB memory.

To eliminate the noise interference when the time is low, we can draw the following conclusion.

1. When the data volume of the old Program increases by 10, the time is increased by about three times.

2. Each time the data volume of new programs increases by 10, the time increases to about 2 + times that of the original programs.

3. New programs are about 100 times faster than old programs with the same data volume.

The test driver is also provided:

Code:

1. # Include <stdio. h>
2. # Include <stdlib. h>
3. # Include <string. h>
4. # Include <time. h>
6. # Define program_name_type "xxx.exe"
7. # Define in_pipe "<"
9. Void generate_test_data_file (int from, int to, int step );
10. Void run_programs (int from, int to, int step );
11. Int main ()
12. {
13. Int from = 50, to = 110, step = 10;
14. Printf ("generate_test_data_file ");
15. Generate_test_data_file (from, to, step );
16. Puts ("OK! ");
17. Puts ("Run tested programs ");
18. Puts ("Data/T/told (MS)/T/tnew (MS )");
19. Run_programs (from, to, step );
20. Return 0;
21. }
22. Void run_programs (int from, int to, int step)
23. {
24. Char cmd [filename_max];
25. Int Len;
26. For (; from <= to; from + = step)
27. {
28. Len = strlen (program_name_type) + strlen (in_pipe );
29. ITOA (from, CMD + Len, 10 );
30. Printf (CMD + Len );
31. Printf ("/T ");
32. Memcpy (CMD, "old.exe <", strlen ("old.exe <"));
33. System (CMD );
34. Printf ("/T ");
35. Memcpy (CMD, "new.exe <", strlen ("new.exe <"));
36. System (CMD );
37. Puts ("");
38. }
39. }
40. Void generate_test_data_file (int from, int to, int step)
41. {
42. File * FP;
43. Int I;
44. Char filename [filename_max];
45. For (; from <= to; from + = step)
46. {
47. Fp = fopen (ITOA (from, filename, 10), "W ");
48. If (FP = NULL)
49. {
50. Puts ("Generate Test Data File error! ");
51. Exit (1 );
52. }
53. Fprintf (FP, "% d/N", from );
54. For (I = 0; I <from; I ++)
55. {
56. Fprintf (FP, "% d", I );
57. }
58. Fclose (FP );
59. }
61. }

 

Statistical System