En informática decimos "recursividad" para referirnos a una función que se llama a sí misma. Pero en el tema de las sucesiones numéricas, la "recursividad" es cuando los términos de la sucesión se generan a partir de los términos anteriores. Por ejemplo la famosa sucesión de Fibonacci a₀, a₁, a₂, ... donde

a₀ = 0, a₁ = 1

y an = a_n-1 + a_n-2 para n>=2 (cada término es la suma de los dos anteriores). Queda entonces:

0,  1,  2,  3,  5,  8,  ...

(ver más en http://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci). Esta es una sucesión por recursividad, mismo método por el que podemos obtener los coeficientes del triangulo de Pascal, pero tenemos prohibido hacerlo por ahí  

Voy con mi propuesta. No se si la intención del problema era usar la clase <vector>, pero yo lo hice en C básico. La fórmula el i-ésimo número en la n-ésima filas del triángulo es:

    n!    
----------
 i! (n-1)!

por lo tanto creé una función que genera los factoriales desde 1! hasta n! (se adopta que 0! = 1 por convencionalismo) en un arreglo de n números del tipo long long. Luego es fácil obtener los binomiales. Queda extenso el código primero porque no se usan plantillas de clase, y segundo porque se verifica la asignación dinámica de memoria:

#include <stdio.h>
#include <stdlib.h>
 
long long * factorial( int );
int * FilaTrianguloPascal( int );
 
int main() {
 
   int *fila;
   int i, n;
 
   n = 10;
   if ( ( fila = FilaTrianguloPascal( n ) ) == NULL )
      return -1;
   i = 0;
   while ( i < n + 1 )
      printf( "%d ", fila[i++] );
 
   return 0;
}
 
/* Calcula los valores de la fila n-esima del triangulo de Pascal */
int * FilaTrianguloPascal( int n ) {
 
   int i, * fila;
   long long * fact;
 
   if ( ( fila = (int *) malloc( (n + 1) *sizeof(int) ) ) == NULL )
      return NULL;
   if ( ( fact = factorial( n ) ) == NULL )
      return NULL;
 
   fila[0] = fila[n] = 1;
   for ( i = 1; i < n; i++ )
      /* fact[k-1] contiene k! */
      fila[i] = fact[n - 1]/ fact[i - 1] / fact[n - i - 1];
 
   return fila;
}
 
/* Devuelve en un arreglo de n+1 elementos los números desde
 * 0! hasta n!.
 * Si no pudo asignar memoria para el arreglo, devuelve NULL.
 */
long long * factorial( int n ) {
 
   int i;
   long long * vector;
 
   if ( ( vector = (long long *) malloc( n * sizeof(long long) ) ) == NULL )
      return NULL;
 
   vector[0] = 1;
   for ( i = 1; i < n; i++ )
      /* vector[i] contiene (i+1)! */
      vector[i] = (i + 1) * vector[i-1];
 
   return vector;
}

NOTA: Amchacon, me gustó este reto porque parece ser muy conciso en sus objetivos. Modifiqué el prototipo de FilaTrianguloPascal para que retornara el vector creado en lugar de recibir el puntero por argumento. Al menos si estamos programando en C me parece más lógico este procedimiento porque la función asigna la memoria dinámicamente y posiblemente relocalice el puntero, entonces ¿qué sentido tiene pasar un puntero como argumento para que la función te devuelva otro? En todo caso se puede pasar el puntero por referencia, un doble puntero long long **, ......... pero ya eso es muy complicado puff, preferí que la función devolviera el puntero final de una vez.

====================================
EDITO:

Hay un detalle con el desbordamiento de los números. Me parece que el tipo long long alcanza para almacenar los números de la fila del triángulo, más no los factoriales requeridos como paso intermedio para el cálculo. Modifiqué el main() para que imprimiera los factoriales solamente:

   n = 25;
   long long * v = factorial( n );
   i = -1;
   while ( ++i < n )
      printf("%02d! = % 20lld\n", i+1, v[i]);
   printf("\n");
 

Véase lo que sucede a partir de 21!:

 15! =        1307674368000
 16! =       20922789888000
 17! =      355687428096000
 18! =     6402373705728000
 19! =   121645100408832000
 20! =  2432902008176640000
 21! = -4249290049419214848
 22! = -1250660718674968576
 23! =  8128291617894825984

A mí me parece desbordamiento ... Y es de recordar que los valores de la función factorial creen muy rápido, incluso más rápido que los valores de la función exponencial eⁿ.
Cambiemos al tipo unsigned long long, a ver qué pasa. Modificando el prototipo de factorial() y la cadena de formato de printf():

15! =        1307674368000
16! =       20922789888000
17! =      355687428096000
18! =     6402373705728000
19! =   121645100408832000
20! =  2432902008176640000
21! = 14197454024290336768
22! = 17196083355034583040
23! =  8128291617894825984
24! = 10611558092380307456
25! =  7034535277573963776

Pasa algo extraño del 22! al 23!. E incluso si pedimos imprimir los binomiales, da números negtivos:

1 -1 -17 -110 -497 -1692 -4513 -9671 -16924 -24446 -29335 -29335 -24446 -16924 -9671 -4513 -1692 -497 -110 -17 -1 1


¿Qué opinan de ésto? 

Claro ivance, pero lo que el autor del tema quiere decir es calcular los números de una fila del triángulo sin usar los valores de las filas anteriores.

El reto era devolver la línea, no el triángulo.

interesantísimo punto el que indicas amchacon, no tomaba la recurrencia matemática como una función recursiva clásica en informática (uno de los puntos si o si presentes es la llamada a sí misma en ella). por lo cual te agradezco la aclaración . saludos

Opino lo mismo que Eferion. Cierto es, que muchas cosas se pueden tratar como recursivas.
Para evitar esto, se pone un límite: Las recursivas son las que se llaman a si mismas.