UVa Problem Solution: 10198 - Counting

 Let f(n) denote the number of ways to make the sum of n. When n > 3, the number of digits is greater than 1. The first digit d used must be one of 1, 2, 3 or 4. Remove the first digit, then the remaining sum is n-d. There are f(n-d) ways to make the sum of n-d, so we've found the recurrence of
   f(n) = 2*f(n-1) + f(n-2) + f(n-3)
and the base cases are
   f(1) = 2, f(2) = 5, f(3) = 13

Code:

1. /*************************************************************************
2.  * Copyright (C) 2008 by liukaipeng                                      *
3.  * liukaipeng at gmail dot com                                           *
4.  *************************************************************************/
6. /* @JUDGE_ID 00000 10198 C++ "Counting" */
8. #include <algorithm>
9. #include <cstdio>
10. #include <cmath>
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.  * Let f(n) denote the number of ways to make the sum of n. When n > 3, the number
121.  * of digits is greater than 1. The first digit d used must be one of 1, 2, 3 or 4.
122.  * Remove the first digit, then the remaining sum is n-d. There are f(n-d) ways to
123.  * make the sum of n-d, so we've found the recurrence of 
124.  *   f(n) = 2*f(n-1) + f(n-2) + f(n-3)
125.  * and the base cases are
     
126.  *   f(1) = 2, f(2) = 5, f(3) = 13
127.  */
128. void gen_numbers(bignum *numbers, int size)
129. {
130.   numbers[1] = 2;
131.   numbers[2] = 5;
132.   numbers[3] = 13;
133.   for (int i = 4; i < size; ++i) {
134.     numbers[i] = numbers[i-1] + numbers[i-1];
135.     numbers[i] += numbers[i-2];
136.     numbers[i] += numbers[i-3];
137.   }
138. }
139.       
140. int main(int argc, char *argv[])
141. {
142. #ifndef ONLINE_JUDGE
143.   freopen((string(argv[0]) + ".in").c_str(), "r", stdin);
144.   freopen((string(argv[0]) + ".out").c_str(), "w", stdout);
145. #endif
147.   int const size = 1001;
148.   bignum numbers[size];
149.   gen_numbers(numbers, size);
150.   for (int n; cin >> n; ) cout << numbers[n] << '/n';
152.   return 0;
153. }
154.