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

int m[N];
int count_triangle = 0;
 
// Для треугольников:
for(int i = 0; i < N; i++)
{   for(int j = 0; j < N; j++)
    {   for(int k = 0; k < N; k++)
        {   if((i == j) || (i == k) || (j == k)) continue;
            if((m[i]>abs(m[j]-m[k]))&&(m[i]<[j]+m[k])) count_triangle++;
        }
    }
}

int m[N];
int count_triangle = 0;
 
// Для треугольников:
for(int i = 0; i < N-2; i++)
{   for(int j = i+1; j < N-1; j++)
    {   for(int k = j+1; k < N; k++)
        { 
            if((m[i]>abs(m[j]-m[k]))&&(m[i]<m[j]+m[k])) count_triangle++; // тут была мелкая описка
        }
    }
}

bool triangl(int a, int b, int c){
   if(a < b + c && a >= b && a >= c) return true;
   return false;
}

if (a < b + c)

bool triangl(int a, int b, int c){
   if(a < b + c && a >= b && a >= c) return true;
   if(b < a + c && b >= a && b >= c) return true;
   if(c < a + b && c >= a && c >= b) return true;
   return false;
}

#include <iostream>
#include <vector>
 
class CTriangle
{
public:
    int m_a, m_b, m_c;
 
public:
    CTriangle(int a, int b, int c) // располагает стороны по возрастанию
    {
        if ((a <= b) && (a <= c))
        {
            m_a = a;
            m_b = (b <= c) ? b : c;
            m_c = (b <= c) ? c : b;
        }
        else if ((b <= a) && (b <= c))
        {
            m_a = b;
            m_b = (a <= c) ? a : c;
            m_c = (a <= c) ? c : a;
        }
        else// if ((c <= a) && (c <= b))
        {
            m_a = c;
            m_b = (a <= b) ? a : b;
            m_c = (a <= b) ? b : a;
        }
    }
 
    bool IsValid() // можно ли это считать треугольником
    {
        return (m_a + m_b) > m_c;
    }
 
    bool IsEqual(CTriangle& t) // равны ли треугольники
    {
        return (m_a == t.m_a) && (m_b == t.m_b) && (m_c == t.m_c);
    }
 
    void Show() // вывести стороны треуголькника в консоль
    {
        std::cout << m_a << ", " << m_b << ", " << m_c << std::endl;
    }
};
 
class CTriangleMap
{
public:
    std::vector<CTriangle> m_array;
 
public:
    void Reset() // очистить
    {
        m_array.clear();
    }
 
    int GetCount() // узнать количество треугольников
    {
        return (int)m_array.size();
    }
 
    bool Append(int a, int b, int c) // добавить треугольник, если он уникальный
    {
        CTriangle t(a, b, c);
        
        if (!t.IsValid())
            return false;
 
        for (size_t i=0; i<m_array.size(); i++)
        {
            if (m_array[i].IsEqual(t))
                return false;
        }
 
        m_array.push_back(t);
        return true;
    }
    
    void Show(bool full) // вывести в консоль количество (и все треугольники)
    {
        std::cout << "count=" << m_array.size() << std::endl;
        
        if (full)
        {
            for (size_t i=0; i<m_array.size(); i++)
            {
                std::cout << (i + 1) << ") ";
                m_array[i].Show();
            }
        }
    }
};
 
void collect_triangle(CTriangleMap & tm, std::vector<int> & lines); // посчитать количество уникальных треугольников
void collect_triangle_combo(CTriangleMap & tm, std::vector<int> & lines);  // посчитать количество уникальных треугольников с учётом объединения сторон
void collect_triangle_combo_lines(CTriangleMap & tm, std::vector<int> & lines, int line1, int line2); // (вспомогательная функция) рекурсивное объединение сторон и подсчёт треугольников
 
int _test[] = { 1, 2, 3, 4, 5, 6, 7};//, 8, 9, 10 }; // тест (больше 7 начинаются тормоза)
 
int main()
{
    std::vector<int> test;
    for (size_t i=0; i<(sizeof(_test) / sizeof(_test[0])); i++)
        test.push_back(_test[i]);
 
    CTriangleMap tmap;
    collect_triangle(tmap, test);
    tmap.Show(false);
 
    tmap.Reset();
    collect_triangle_combo(tmap, test);
    tmap.Show(false);
 
    system("pause");
    return 0;
}
 
void collect_triangle(CTriangleMap & tm, std::vector<int> & lines)
{
    int cnt = (int)lines.size();
 
    for (int i=0; i<cnt-2; i++)
    {
        for (int j=i+1; j<cnt-1; j++)
        {
            for (int k=j+1; k<cnt; k++)
            {
                tm.Append(lines[i], lines[j], lines[k]);
            }
        }
    }
}
 
void collect_triangle_combo(CTriangleMap & tm, std::vector<int> & lines)
{
    collect_triangle(tm, lines);
 
    int cnt = (int)lines.size();
    if (cnt <= 3)
        return;
 
    for (int i=0; i<cnt-1; i++)
    {
        for (int j=i+1; j<cnt; j++)
        {
            collect_triangle_combo_lines(tm, lines, i, j);
        }
    }
}
 
void collect_triangle_combo_lines(CTriangleMap & tm, std::vector<int> & lines, int line1, int line2)
{
    int cnt = (int)lines.size();
    if (cnt <= 3)
        return;
 
    std::vector<int> temp;
    temp.push_back(lines[line1] + lines[line2]);
 
    for (int i=0; i<cnt; i++)
    {
        if ((i != line1) && (i != line2))
            temp.push_back(lines[i]);
    }
    
    collect_triangle(tm, temp);
 
    cnt--;
 
    for (int i=0; i<cnt-1; i++)
    {
        for (int j=i+1; j<cnt; j++)
        {
            collect_triangle_combo_lines(tm, temp, i, j);
        }
    }
}