UVa Problem Solution: 10183 - How many fibs?

The close form of fibs does not help in the problem. The input range is too large that the precision of long double won't be sufficient to handle it correctly. Just generate all the fibs up to 100 digits and use string compare to find the bounds.

Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 10183 C++ "How many fibs?" */
8. #include <algorithm>
9. #include <cmath>
10. #include <cstdio>
11. #include <cstring>
12. #include <deque>
13. #include <fstream>
14. #include <iostream>
15. #include <list>
16. #include <map>
17. #include <queue>
18. #include <set>
19. #include <stack>
20. #include <string>
21. #include <vector>
23. using namespace std;
25. struct bignum
26. {
27.   bignum(int v = 0) : start(max_digits)
28.   {
29.     bzero(digits, max_digits);
30.     assign(v);
31.   }
33.   bignum(char const *v) : start(max_digits)
34.   {
35.     bzero(digits, max_digits);
36.     assign(v);
37.   }
39.   void assign(int v)
40.   {
41.     start = max_digits;
42.     for (; v != 0; v /= 10) digits[--start] = v % 10; 
43.   }
45.   void assign(char const *v)
46.   {
47.     start = max_digits - strlen(v);
48.     for (int i = start; i < max_digits; ++i)
49.       digits[i] = *v++ - '0';
50.     remove_leading_zero();
51.   }
53.   void convert(int& v) const
54.   {
55.     v = 0;
56.     for (int i = start; i < max_digits; ++i, v *= 10) v += digits[i]; 
57.   }
59.   void convert(char *v) const
60.   {
61.     for (int i = start; i < max_digits; ++i)
62.       *v++ = digits[i] + '0';
63.     *v = '/0';
64.   }
66.   bignum& operator+=(bignum const& other)
67.   {
68.     start = min(start, other.start) - 1;
69.     for (int i = max_digits - 1, carry = 0; i >= start; --i) {
70.       int s = digits[i] + other.digits[i] + carry;
71.       digits[i] = s % 10;
72.       carry = s / 10;
73.     }
74.     remove_leading_zero();
75.     return *this;
76.   }
78.   bignum operator+(bignum const& other) const
79.   {
80.     bignum tmp(*this);
81.     tmp += other;
82.     return tmp;
83.   }
85.   bool operator<(bignum const& other) const
86.   {
87.     if (start > other.start) return true;
88.     else if (start < other.start) return false; 
89.     return memcmp(digits + start, other.digits + start, max_digits - start) < 0;
90.   }
92.   static int const max_digits = 500;
93.   char digits[max_digits];
94.   int start;
96. private:
97.   void remove_leading_zero()
98.   {
99.     for (; digits[start] == 0 && start < max_digits; ++start) {}
100.   } 
101. };
102.     
103. inline istream& operator>>(istream& is, bignum& n)
104. {
105.   char buf[bignum::max_digits+1];
106.   is >> buf;
107.   n.assign(buf);
108.   return is;
109. }
111. inline ostream& operator<<(ostream& os, bignum const& n)
112. {
113.   char buf[bignum::max_digits+1];
114.   n.convert(buf);
115.   os << buf;
116.   return os;
117. }
119. /*
120.  * generate the fibs
121.  */
122. void gen_fibs(bignum *fibs, int nfibs)
123. {
124.   fibs[0] = 1;
125.   fibs[1] = 2;
126.   for (int i = 2; i < nfibs; ++i)
127.     fibs[i] = fibs[i-1] + fibs[i-2];
128. }
129.         
130. int main(int argc, char *argv[])
131. {
132. #ifndef ONLINE_JUDGE
133.   freopen((string(argv[0]) + ".in").c_str(), "r", stdin);
134.   freopen((string(argv[0]) + ".out").c_str(), "w", stdout);
135. #endif
137.   int const nfibs = 500;
138.   bignum fibs[nfibs];
139.   gen_fibs(fibs, nfibs);
140.   for (string s1, s2; cin >> s1 >> s2 && !(s1 == "0" && s2 == "0"); ) {
141.     bignum a(s1.c_str()), b(s2.c_str());
142.     int count;
143.     if (b < a) {
144.       count = 0;
145.     } else {
146.       bignum *first = lower_bound(fibs, fibs + nfibs, a);
147.       bignum *last = upper_bound(fibs, fibs + nfibs, b);
148.       count = last - first;
149.     }
150.     cout << count << '/n';
151.   }
152.   return 0;
153. }
154.