Una forma de resolver este problema es escribiendo una funcion recursiva 
que calcule de cuantas formas distintas se puede sumar hasta N usando 
sumandos distintos con al menos cierto valor K. Observe que si se escoge 
el sumando I (con K <= I <= N) entonces la suma faltante (N - I) se debe 
lograr con sumandos con valor al menos I + 1. El caso base es N = 0.

   Sumas(N, K) <- al principio escoja K=1
     Si N > 0
       Para cada valor de I desde K hasta N
         Resolver Sumas(N - I, I + 1)
     Si no, contar una solucion

No hay una formula obvia para calcular Sumas(N, 1) pero si existe algo mas 
o menos parecido (http://mathworld.wolfram.com/PartitionFunctionQ.html)

Los valores requeridos son los siguientes:

N	S(N)		N	S(N)
------------		------------
1	1		6	4
2	1		7	5
3	2		8	6
4	2		9	8
5	3		10	10

Yo escribi una funcion en C (la anexo abajo) que se tardo 58.956 seg para 
resolver N = 197 y que se tardo 1 min 2.908 seg para resolver N = 198. 
Unos experimentos mas muestran que el tiempo de ejecucion aproximadamente 
se duplica cada vez que subimos en 10 el valor de N:

N	Sumas(N)	Tiempo(N)
100	   444793	0m0.056s
110	  1004544	0m0.124s
120	  2194432	0m0.248s
130	  4654670	0m0.564s
140	  9617150	0m1.216s
150	 19406016	0m2.516s
160	 38328320	0m5.108s
170	 74236384	0m10.169s
180	141231780	0m19.757s
190	264288462	0m37.690s
200	487067746	1m11.584s

Asi, parece que el tiempo de ejecucion se comporta como T(n) = B*exp(A*N) 
donde A y B son constantes que dependen de mi maquina. Con mi programa 
podemos esperar a resolver hasta N aproximadamente 310 o 320 en una hora.
 
void sumas(int n, int k)
{
  int i;

  if (n > 0) {
    for (i = k; i <= n; i++)
      sumas(n - i, i + 1);
  } else m++;
}

Algunos de ustedes encontraron una forma mas rapida de hacer este calculo 
basada en las siguientes dos observaciones: (1) Si N >= K entonces es 
obvio que solo hay una forma de hacer la suma con un solo sumando, por lo 
que no tiene sentido hacer una llamada recursiva en este caso. (2) Si la 
suma va a tener al menos dos sumandos entonces se debe cumplir que N vale 
al menos K + (K+1) = 2K + 1, por lo que el ciclo es mucho mas corto (en 
lugar de que se detenga cuando I > N se detiene cuando 2I >= N).