北大OJ 1001题

题目：输入一序列的正实数和幂次（正整数）对，然后打印结果（具体的比这个精细）

这道题是关于大数计算的（大数求幂），从开始建立思路，到写代码、调式到最后被AC以及最终的优化，总共用了差不多一天的时间。开始AC时使用空间500K，时间37MS，最后一次AC空间400K，时间0MS，有很大提高。这主要归功于加大了每次的数据处理量，减少了重计算次数以及降低循环代码量。还有就是在使用了二分递归,避免了重复计算。不好的一点是代码量太大，并且使用了太多的变量。

不管怎么样，为这道题付出了很多想法，后来的一些大的优化主要来自对底层的深入理解，代码的整体实现粒度是很细的，阅读起来可能会有些困难，但很是值得推敲的，具体实现代码如下：

[cpp] view plain copy

 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. void add(char *s1, char *s2);
5. char *multi(char *s1, char *s2);
6. char *result(char *s, int n);
7. int main(void) {
8. char ch[100];
9. char *res;
10. int  num, np;
11. char tem, *temp1, *temp2;
12. char *chp;
13. while ( scanf("%s%d", ch, &num) != EOF ) {
14. chp = ch + strspn(ch, "0");           // 去掉前导0
15. temp1 = &ch[strlen(ch)-1];
16. if ( (temp2 = strchr(ch, '.')) != NULL ) {  // 如果有小数点
17. while ( *temp1 == '0' )  // 去掉小数末尾的0
18. *temp1-- = 0;
19. np  = strlen(temp2) - 1;
20. np *= num;                  // 小数位的num倍是最终结果的小数位数
21. memmove(temp2, temp2+1, strlen(temp2));  // 去掉小数点
22. }
23. else
24. np = 0;             // 整数
25. res   = result(chp, num);
26. //        printf("res: %s\n", res);
27. temp1 = res + strspn(res, "0");
28. temp2 = &res[strlen(res) - np];     // 定位小数点
29. if ( temp1 >= temp2 && np != 0 )   // 如果结果小于1
30. printf("%c%s\n", '.', temp2);
31. else if ( np == 0 )              // 如果是整数
32. printf("%s\n", temp1 == temp2 ? 0 : temp1);
33. else {
34. tem   = *temp2;         // 将该放小数点位置的源字符保存
35. *temp2++ = 0;           // 这里将源结果字符串断开，块式输出效率高
36. printf("%s%c%c%s\n", temp1,
37. '.', tem,
38. *temp2 == 0 ? "" : temp2);
39. }
40. free(res);
41. }
42. return 0;
43. }
44. char *result(char *s, int n) {
45. char *res, *ch1, *ch2;
46. if ( n == 1 )
47. return multi(s, "1");  // 返回统一类型的可被free掉的数据空间
48. else if ( n == 2 )
49. return multi(s, s);
50. else if ( n > 2 ) {
51. ch1 = result(s, n >> 1);  // 二分递归计算
52. if ( n % 2 != 0 ) {
53. ch2 = result(s, n - (n >> 1));
54. res = multi(ch1, ch2);
55. free(ch2);   // result函数返回值得释放掉
56. }
57. else   // 如果n是偶数，可避免重复计算
58. res = multi(ch1, ch1);
59. free(ch1);
60. return res;
61. }
62. }
63. char *multi(char *s1, char *s2) {
64. int  i1, i2;
65. char *ch1, *ch2, *cp1, *cp2, *cp3;
66. char chp[18];
67. int  i, j, num, dis;
68. long long j1, j2, j3; // 加大每次计算量
69. i1 = strlen(s1);
70. i2 = strlen(s2);
71. ch1 = (char *)malloc(i1 + i2 + 2);  // 1 bit '\0', 1 carry bit(reserved for)
72. if ( strncmp(s2, "1", 1) == 0 && i2 == 1 ) {
73. memcpy(ch1, s1, i1+1);
74. return ch1;
75. }
76. ch2 = (char *)malloc(i1 + i2 + 1);  // 1 bit '\0'
77. memset(ch1, '0', i1 + i2 + 2);
78. ch1[i1+i2+1] = 0;
79. i = i2;
80. while ( i > 0 ) {
81. if ( i >= 8 )           // 和j，每次各可处理8位
82. dis = 8;
83. else
84. dis = i;
85. i -= dis;
86. memset(ch2, '0', i1 + i2 + 1);  // ch2每次循环都可能被修改
87. ch2[i1+i2] = 0;
88. cp1 = &s1[i1];
89. cp2 = &s2[i2];
90. cp3 = &ch2[i1 + i];  //  i1+i2-(i2-i)=i1+i, 每次循环往左移动dis位，表示和记录进位
91. memcpy(chp, cp2 - i2 + i, dis);
92. chp[dis] = 0;
93. j2     = atoi(chp);
94. j = i1;
95. while ( j > 0 ) {
96. if ( j >= 8 )     // 最多8位迭代处理与j2相乘
97. num = 8;
98. else
99. num = j;
100. cp1 -= num;
101. memcpy(chp, cp1, num);
102. chp[num] = 0;
103. j1       = atoi(chp);
104. memcpy(chp, cp3, dis);  // cp3记录进位，最多有dis位
105. chp[dis] = 0;
106. j3     = atoi(chp);
107. snprintf(chp, 18, "%lld", j1 * j2 + j3);
108. j1 = strlen(chp);
109. memcpy(cp3 -j1 + dis, chp, j1);     // 数据向右对齐
110. cp3 -= num;  // 定位到下次计算进位可能占据空间的开头地址
111. j -= num;
112. }
113. add(ch1, ch2);   // 将新的计算结果与前面的相加，最后可获得最后结果
114. }
115. free(ch2);
116. return ch1;
117. }
118. void add(char *s1, char *s2) {
119. char *cp1, *cp2, *cp3, *ch;
120. char chp[18];
121. int  num, n1, n2;
122. long long i, j, k;
123. s2 += strspn(s2, "0");
124. n1  = strlen(s1);       // make sure n1 > n2
125. if ( (n2  = strlen(s2)) == 0 )
126. return;
127. ch  = (char *)malloc(n1+1);
128. memset(ch, '0', n1);
129. ch[n1] = 0;
130. cp1 = &s1[n1];
131. cp2 = &s2[n2];
132. cp3 = &ch[n1 - 1];
133. while ( n2 > 0 ) {    // must validate enough memory
134. if ( n2 >= 16 )
135. num = 16;
136. else
137. num = n2;
138. cp1 -= num;
139. cp2 -= num;
140. memcpy(chp, cp1, num);
141. chp[num] = 0;
142. i        = atoll(chp);
143. memcpy(chp, cp2, num);
144. chp[num] = 0;
145. j        = atoll(chp);
146. memcpy(chp, cp3, 1);
147. chp[1] = 0;
148. k      = atoll(chp);
149. snprintf(chp, 18, "%lld", i + j + k);
150. i = strlen(chp);
151. cp3 -= i - 1;
152. memcpy(cp3, chp, i);
153. cp3 += i - 1 - num;
154. n2 -= num;
155. }
156. memcpy(s1, ch, n1);
157. free(ch);
158. }

原文转自 http://blog.csdn.net/chiichen/article/details/6685858

原作者为 chiichen. 请尊重原作者版权