Una duda que me preguntaron al final de clase es si bool filtro[16000000] funcionaría. Desafortunadamente el estándar dice que
sizeof(bool) >= sizeof(char) donde sizeof(char) es un byte. Entonces bool gastaría al menos un byte completo. Tendrán que manipular bits individuales 
ya sea a mano o con std::bitset (existe un caso especial con std::vector<bool>, pero es universalmente odiado y más lento que std::bitset).

En otros asuntos, posiblemente cualquiera de las funciones listadas en el primer enlace (RSHash, JSHash, etc) sea suficiente para resolver la tarea 
(y las pueden invocar incluso desde C simplemente pasando el arreglo de la cadena). Por su parte, C++ ya tiene una función hash, aunque es un poco rara de usar.
El algoritmo que GCC usa internamente para std::hash se llama MurmurHash.

#include <functional>      // aquí está std::hash
#include <string>          // aquí está std::string
#include <stdio.h>

int main( ) {
   std::hash<std::string> h;     // h es una variable que puede usarse como función hash y toma std::string
                                 // la especialización std::hash<const char*> hace un hash del apuntador y no de la cadena al estilo C
                                 // por lo que no servirá para lo que queremos
   char cadena[16 + 1];
   scanf("%s", cadena);
   size_t valor = h(cadena);     // invocamos h con la cadena
   printf("%llu", (unsigned long long)valor);        
                                 // oficialmente se usa %z para imprimir un size_t, pero en muchos compiladores no funciona
}

Lo feo de este código es que está leyendo y pasando un arreglo de chars mientras que h pide un std::string, por lo que el lenguaje tiene que 
copiar el arreglo en un std::string (pidiendo memoria dinámica en el proceso) sólo para calcular el hash, tirando el std::string a la basura una vez calculado el hash.
Hacer esto repetidamente puede ser un poquitín lento (para la tarea no importará mucho, pero puede importar en otras circunstancias).

La función scanf no puede leer std::string directamente y <iostream> no está recomendado. 

Existe otra alternativa que consiste en declarar un std::string con capacidad inicial suficiente y luego usar .data( ) para pasarle a scanf el arreglo subyacente. 
Sin embargo, si hacemos esto entonces el cálculo de la longitud del std::string con .size( ) ya no es confiable (aunque esto no importa mucho para la tarea):

#include <functional>      // aquí está std::hash
#include <string>          // aquí está std::string
#include <stdio.h>
#include <string.h>        // aquí está strlen

int main( ) {
   std::hash<std::string> h;

   std::string cadena(16 + 1, '\0');   // apartamamos espacio suficiente lleno del caracter nulo
   scanf("%s", cadena.data( ));        // leemos en la memoria subyacente
   size_t valor = h(cadena);           // invocamos h con la cadena, sin necesidad de hacer una copia porque ya es un std::string
   int t1 = cadena.size( );            // será 17 aunque sólo tecleemos "hola"
   int t2 = strlen(cadena.data( ));    // será 4 si tecleamos "hola"
   printf("%d %d\n", t1, t2);
}

En C++17 existe std::string_view, pero OmegaUp aún no es compatible con eso.