#include <algorithm>
#include <iostream>
#include <vector>

//////////////////////////////////////////////////////////////////
// Ищем произведение элементов массива, которые расположены между 
// максимальным и минимальным элементами
//
// Дополнительно (чего не уточнено в задании):
// 
// 1. Не ищем в обратном порядке (от минимального к максимальному)
// 2. Возможные варианты заносим в вектор результатов и их 
//    разновсячески сортируем в порядке нужного
//////////////////////////////////////////////////////////////////

typedef std::pair<std::size_t,std::size_t> PairType;
typedef std::vector<PairType> ResType;

void FuncMul(std::vector<int> Vec, ResType &Res) {
  // в векторе длиной меньше 3-х искать нечего  
  if (Vec.size()<3) throw std::runtime_error("ничего не найдено");
  // определяемся с минимумами и максимумами
  auto Min = *std::min_element(Vec.begin(),Vec.end());    
  auto Max = *std::max_element(Vec.begin(),Vec.end());
  // ищем все пары мах-min
  std::size_t I = 0, S = Vec.size(), X;   
  int M = 0;  
  while(I<S) {
    if (M == 0) {
      if (Vec[I]==Max) { M=1; X=I; }    
    } else {
      if (Vec[I]==Min) { 
        if (I>X+1) Res.push_back({X,I}); 
        M=0;
      } else if (Vec[I]==Max) X=I;
    }
    I++;  
  }
  if(Res.size()<1) throw std::runtime_error("ничего не найдено");
}    
   
int main() {
  std::vector<int> Vec = {3,-4,1,3,4,9,1,-4,9,9,2,-3,-4,9,1};
  ResType Res;
  try {  
    FuncMul(Vec,Res);
    // лямбда вывода на печать  
    auto PrnPair = [&](const PairType &P) { 
      std::cout << P.first << ":" << P.second << " = " <<
      std::accumulate(Vec.begin()+P.first+1, Vec.begin()+P.second, 1, std::multiplies<int>()) <<        
      std::endl;  
    };
    // лямбда сортировки по величине произведения
    auto SortMul = [&] (const PairType &P1, const PairType &P2) {
      return std::accumulate(Vec.begin()+P1.first+1, Vec.begin()+P1.second, 1, std::multiplies<int>()) <       
             std::accumulate(Vec.begin()+P2.first+1, Vec.begin()+P2.second, 1, std::multiplies<int>());
    };  
    // лямбда сортировки по количеству множимых  
    auto SortDis = [&] (const PairType &P1, const PairType &P2) {
      return P1.second - P1.first < P2.second-P2.first;
    };  
    // 1) печать "сырого" несортированного результата --------------------------------------------
    for(const auto &i:Res) PrnPair(i); 
    std::cout << "=========================" << std::endl;
    // 2) печать отсортированного результата по возрастанию величины произведения ----------------
    std::sort(Res.begin(),Res.end(),SortMul);
    for(const auto &i:Res) PrnPair(i); 
    std::cout << "=========================" << std::endl;  
    // 3) печать отсортированного результата по убыванию количества элементов в произведении ----
    std::sort(Res.begin(),Res.end(),SortDis);
    for(const auto &i:Res) PrnPair(i); 
    std::cout << "=========================" << std::endl;    
  } catch(std::runtime_error &E) {
    std::cout << "Ошибка: " << E.what() << std::endl;  
  } catch(...) {
    std::cout << "Ошибка: что-то пошло не так!" << std::endl;    
  }
  return 0;
}