Mi solución

[Cristian Yones]

Hola! les paso a comentar mi soluci�n, aunque esta lejos de ser la
correcta para este problema particular (lastima que me di cuenta tarde..).
El algoritmo es similar, almacenar todos los conjuntos en una estructura
de datos y en cada inserci�n ver si el conjunto estaba o no. La
estructura de datos que eleg� es un Prefix tree. Esta estructura es un
�rbol que se utiliza generalmente para almacenar cadenas y no conjuntos
(donde el orden de los elementos SI importa). Por eso, para almacenar
los conjuntos antes tenia que ordenarlos. Ac� esta explicado como
funciona esta estructura: http://en.wikipedia.org/wiki/Prefix_tree
El algoritmo es este:

struct nodo {
unsigned int num;
bool existe;
set<nodo> hijos;
nodo(const int& n) : num(n), existe(false), hijos() {};
bool operator <(const nodo& other) const {return this->num <
other.num;};

bool insertar(const vector<int>& v, vector<int>::const_iterator& in) {
if( in == v.end() ) {
if( this->existe )
return false;
else
return (existe=true);
}
const nodo* h = &(*(hijos.insert(nodo(*in))).first);
return (const_cast<nodo*>(h))->insertar( v, ++in );
}
};

struct trie {
set<nodo> hijos;
bool insertar(vector<int>& v) {
sort(v.begin(), v.end());
vector<int>::const_iterator in = v.begin();
const nodo* h = &(*(hijos.insert(nodo(*in))).first);
return (const_cast<nodo*>(h))->insertar( v, ++in );
}

};

int count_sets(const vector<int> &v) {
trie t;
vector<int> s(5);
int j=0, count=0;
while(j<v.size()) {
s.clear();
while (v[j]>=0)
s.push_back(v[j++]);
if(t.insertar(s))
count++;
j++;
}
return count;
}

Aunque para este problema no da los mejores resultados (es mucho mas
lento que un tabla de hash), para problemas parecidos funciona bastante
bien.
Felicitaciones a los organizadores! estuvo entretenido. Si necesitan una
mano para organizar otro estoy a su disposici�n, y si no, mejor as�
puedo participar.. jaja
Saludos!