Etoile

#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
struct Case
{
   int valMax;
   vector<int> rangees;
   vector<int> fixees;

   void init(vector<int> a){
      rangees = a;
   }
};
const int nRangees = 12, nCases = 48, nSituations = (1 << 12), OO = nCases * 9 + 1;
vector<Case> cases(nCases);
vector<int> maxRangee(nRangees);
void construit(){
   cases[0].init({4, 11});
   cases[1].init({4, 10});
   cases[2].init({4, 11});
   cases[3].init({5, 11});
   cases[4].init({0, 8});
   cases[5].init({0, 8});
   cases[6].init({0, 9});
   cases[7].init({0, 4, 9});
   cases[8].init({0, 4, 10});
   cases[9].init({0, 5, 10});
   cases[10].init({0, 5, 11});
   cases[11].init({0, 6, 11});
   cases[12].init({0, 6});
   cases[13].init({0, 7});
   cases[14].init({0, 7});
   cases[15].init({1, 8});
   cases[16].init({1, 4, 8});
   cases[17].init({1, 4, 9});
   cases[18].init({1, 5, 9});
   cases[19].init({1, 5, 10});
   cases[20].init({1, 6, 10});
   cases[21].init({1, 6, 11});
   cases[22].init({1, 7, 11});
   cases[23].init({1, 7});
   cases[24].init({2, 4});
   cases[25].init({2, 4, 8});
   cases[26].init({2, 5, 8});
   cases[27].init({2, 5, 9});
   cases[28].init({2, 6, 9});
   cases[29].init({2, 6, 10});
   cases[30].init({2, 7, 10});
   cases[31].init({2, 7, 11});
   cases[32].init({2, 11});
   cases[33].init({3, 4});
   cases[34].init({3, 4});
   cases[35].init({3, 5});
   cases[36].init({3, 5, 8});
   cases[37].init({3, 6, 8});
   cases[38].init({3, 6, 9});
   cases[39].init({3, 7, 9});
   cases[40].init({3, 7, 10});
   cases[41].init({3, 10});
   cases[42].init({3, 11});
   cases[43].init({3, 11});
   cases[44].init({6, 8});
   cases[45].init({7, 8});
   cases[46].init({7, 9});
   cases[47].init({7, 8});
}
int valMin[nSituations];
int main(){
   construit();
   for (int& maxCur : maxRangee)
      cin >> maxCur;

   int maxSomme = 0;
   for (Case& caseCur : cases){
      int mini = 9;
      for (int iRangee : caseCur.rangees)
         mini = min(mini, maxRangee[iRangee]);
      caseCur.valMax = mini;
      maxSomme += caseCur.valMax;

      for (int iRangee : caseCur.rangees){
         if (maxRangee[iRangee] == mini)
            caseCur.fixees.push_back(iRangee);
      }
   }

   for (int& valCur : valMin)
      valCur = OO;
   valMin[0] = 0;
   for (int repBin = 0; repBin < nSituations; ++repBin){
      for (Case casePrise : cases){
         int totCur = valMin[repBin];
         totCur += casePrise.valMax;

         int arrivee = repBin;
         for (int fixee : casePrise.fixees)
            arrivee |= (1 << fixee);
         valMin[arrivee] = min(valMin[arrivee], totCur);
      }
   }
   if (valMin[nSituations - 1] != OO)
      cout << valMin[nSituations - 1] << " " << maxSomme << endl;
   else
      cout << "NO SOLUTION\n";
   return 0;
}