Stones
------

In general, when you see "longest subsequence" problems, you
should think dynamic programming; this may not always be the
case, but most of the time it is, and it certainly is here.

Dynamic programming works for problems for which an optimal
solution has parts that are themselves optimal.  In this case,
we can iterate through the string character by character,
and consider how each new character may improve the best
result.  If the character under consideration is a 3, then
we can either add it to a previously seen long string that
has not yet had a 3 added to it, or we can add it to a
previously seen long string that ends in 3.  Indeed, we
do not even need to remember the strings themselves; all
we need to remember is, for each combination of sets of
characters that have been used so far, and ending character,
what the longest string so far is.

With only five possible characters, only 2^5 or 32 sets of
characters are possible.  We represent each set by a simple
int, with bit position b representing the inclusion of
character c.  So the final code looks like this:

int nsets = 1<<k ;
best[m][nsets][k] ;
// ... clear best to zero on every new string ...
for (int i=0; i<v.size(); i++) {
   int c = v[i] - 1 ; // try to use zero-based indexing everywhere
   for (int set=0; set<nsets; set++) {
      for (int endchar=0; endchar<k; endchar++) {
         // ignore character i
         best[i+1][set][c] = Math.max(best[i+1][set][c], best[i][set][c]) ;
         // this is the first occurrence of character c:
         if ((set & (1 << c)) == 0)
            best[i+1][set|(1<<c)][c] =
                Math.max(best[i+1][set|(1<<c)][c], best[i][set][endchar] + 1) ;
      }
      // extending a string that ends in c
      best[i+1][set][c] = Math.max(best[i+1][set][c], best[i][set][c] + 1) ;
   }
}


The final result is then just the highest value in best, which will always
be at character m:

int r = 0 ;
for (int set=0; set<nsets; set++) for (int c=0; c<k; c++)
   r = Math.max(r, best[m][set][c]) ;
return r ;

If space is at a premium, instead of using a first index of m (the length
of the input string) we can simply use a value of 2 and ping pong
between 0 and 1 (that is, store to ((i + 1) % 2) instead of (i+1))
because we only ever read the previous entries.