Полностью согласен. Уже пол-лета живу живу от SRM'a до SRM'a (:

Автору бабло не платят

Расскажу свою идею, не хватило времени дописать, вероятно неправильная, у меня вообще туго с опровержением себя)

Считаем дп по маскам, f[i]--максимальный профит от маски i бутылок.
Также препроцессингом за 2^15 просчитаем массив a[i]--профит, если мы разольем маску i бутылок так, чтобы было максимально полных бутылок, одна частично(от 0 до c) заполненная, а остальные пустые.

И как считаем--если у нас есть ответ для маски i, то мы перебираем все остальные маски, не пересекающиеся с i(для оптимизации я считал в новой "цепочке" мы будем всегда использовать самый левый нулевой бит маски i) и обновляем ответ f[mask | newmask]=max(f[mask |newmask],f[mask]+a[newmask])

Вот решение. К сожалению, придумал я его уже после окончания контеста:

Основная идея в том что после переливания из одной бутылки в другую, у нас получится либо одна полная бутылка либо одна пустая. Переливать в пустую или переливать из полной бутылки нет никакого смысла, просто емкости двух бутылок поменяются местами.

Фактически получается мы считаем максимальную прибыль, если мы уже использовали какой-то множество I бутылок и причем в одной активной бутылке из использованных находится K литров сока причем мы еще не посчитали прибыль за эту бутылку, объем сока еще может измениться в ней.
Тогда для пересчета мы просто смотрим бутылку J которую мы не использовали и с ней мы можем сделать несколько операций:
(dm[I][K] мы уже посчитатли. J не принадлежит I)
-просто использовать, т.е. добавить прибыль за эту бутылку
 dm[I+(1 << J)][K] = max(dm[I+(1 << J)][K], prices[bottle[J]] + dm[I][K]);
-сделать ее активной
 dm[I+(1 << J)][bottle[J]] = max(dm[I+(1 << J)][bottle[J]], prices[K] + dm[I][K]);
-перелить в активную бутылку
если bottle[j] + k < C
 dm[I + (1 << J)][botlle[J] + K] = max(dm[I + (1 << J)][botlle[J] + K], dm[I][K] + prices[0]);
иначе
 dm[I + (1 << J)][botlle[J] + K - C] = max(dm[I + (1 << J)][botlle[J] + K], dm[I][K] + prices[C]);

суть в том что у нас каждый раз получаются числи вида: (2^n)*init+(2^n-1)

Я писал bfs+map.

Я так решал:

1) x*4+3 и x*8+7 коммутируют между собой, то есть неважно в каком порядке выполнять операции, можно считать, что сначала мы делаем сколько-то операций первого типа, а потом сколько-то второго.

2) ясно, что мы просто выполняет все операции в кольце вычетов по модулю 10^9+7. это всем известное простое число, ура =) значит мы можем делить на 4 и на 8.

сделаем 100 000 обратных операций первого типа от нуля, запишем в мап, а потом 100 000 операций другого типа от числа init.

В двоичной записи 4*x+3 это добавление двух единиц справа, 8*x+7 это добавление трёх единиц. Посмотрим сколько надо добавить единиц чтобы получить остаток 0, делаем x_new = 2*x+1 где-то 300000 раз. Пусть через K итераций мы получили остаток 0, значит ответ K/3 + (K%3==0?0:1). Только начинать надо сразу с двух итераций.

Ага, только я в шарпе использовал Dictionary
Но я думаю это в принципе аналог)

Звучить заманчиво