На сколько частей делят плоскость прямые

#include <iostream>
#include <cstdlib>
using namespace std;
int a[1001], b[1001], k1[46];
int main ()
{
 
    int n, x[12], y[12], i, j, k = 0, s = 1, kol = 0;
    cin >> n;
    for(i = 1; i <= n; i++)
        cin >> x[i] >> y[i];
    if(n == 2) {
        cout << 2 << endl;
        return 0;
    }
    if(n % 2 == 0)
        s += (n / 2) * (n - 1);
    else
        s += ((n - 1) / 2) * n;
    for(i = 1; i < n; i++)
        for(j = i + 1; j <= n; j++) {
            k++;
            a[k] = y[j] - y[i];
            b[k] = x[i] - x[j];
        }
    for(i = 1; i < k; i++)
        for(j = i + 1; j <= k; j++) {
            if(a[i] * b[j] != a[j] * b[i]) {
                k1[i]++;
                k1[i+1]--;
            }
        }
    for(i = 1; i <= k; i++) {
       // cout << k1[i] << ' ';
        s += abs(k1[i]);
    }
    cout << s << endl;
return 0;
}

a[i] * b[j] != a[j] * b[i]

/////////////////////////////////////////////////////////////////////////////////////////
//Даны N точек на плоскости. Проведем прямые через каждую пару точек. На сколько частей ненулевой площади эти прямые делят плоскость?
//Формат входных данных:
//В первой строке входного файла задано число N - количество точек (2 <= N <= 10). Следующие N строк содержат по два числа X[i] Y[i] - каждая через пробел, координаты i-ой точки (-100 <= X[i], Y[i] <= 100). Никакие две точки не совпадают, никакие три не лежат на одной прямой. Все числа во входном файле целые.
//Формат выходных данных:
//В первой строке выходного файла выведите P - количество частей, на которые полученные прямые делят плоскость.
//Пример:
//Ввод:
//4
//0 0
//0 1
//1 0
//1 1
//Вывод:
//16
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <conio.h>
#include <iostream>
#include <limits>
#include <map>
#include <set>
#include <utility>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef double  T_real;
/////////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  equal_for_real(T a, T b)
{
    const int   coef                    =   16;
 
    const T     epsilon_for_coef        =       coef
                                            *   std::numeric_limits<T>::epsilon();
 
    T           max_abs                 =   std::max
                                            (
                                                abs(a),
                                                abs(b)
                                            );
 
    max_abs                             =   std::max
                                            (
                                                max_abs,
                                                T(1.0)
                                            );
 
    T           epsilon_for_arguments   =       epsilon_for_coef
                                            *   max_abs;
 
    return      abs(a - b) < epsilon_for_arguments;
}
/////////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_for_real(T a, T b)
{
    return      a < b
            &&  !equal_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_for_real(T a, T b) 
{
    return  less_for_real(b, a);
}
/////////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  less_equal_for_real(T a, T b) 
{
    return !greater_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////////
template<class T>
bool  greater_equal_for_real(T a, T b) 
{
    return !less_for_real(a, b);
}
/////////////////////////////////////////////////////////////////////////////////////////
class  T_point
{
    //-----------------------------------------------------------------------------------
    T_real  x_;
    T_real  y_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_point
        (
            T_real  x = 0,
            T_real  y = 0
        )
        :
        x_(x),
        y_(y)
    {}
    //-----------------------------------------------------------------------------------
    void  assign( const T_point&  point )
    {
        *this   =   point;
    }
    //-----------------------------------------------------------------------------------
    T_point  operator- (const T_point&  point)  const
    {
        return  T_point
                    (
                        x_ - point.x_,
                        y_ - point.y_
                    );
    }
    //-----------------------------------------------------------------------------------
    T_point  operator+ (const T_point&  point)  const
    {
        return  T_point
                    (
                        x_ + point.x_,
                        y_ + point.y_
                    );
    }
    //-----------------------------------------------------------------------------------
    bool    operator< (const T_point&  point)   const
    {
        return      less_for_real       (x_, point.x_)
                ||      equal_for_real  (x_, point.x_)
                    &&  less_for_real   (y_, point.y_);
    }
    //-----------------------------------------------------------------------------------
    T_point  operator* (T_real  t)              const
    {
        return  T_point
                    (
                        x_ * t,
                        y_ * t
                    );
    }
    //-----------------------------------------------------------------------------------
    T_real  x()                                 const
    {
        return  x_;
    }
    //-----------------------------------------------------------------------------------
    T_real  y()                                 const
    {
        return  y_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::set<T_point>   T_points;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_line
{
    T_point     point_A_;
    T_point     point_B_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_line
        (
            const T_point&  point_A,
            const T_point&  point_B
        )
        :
        point_A_( point_A ),
        point_B_( point_B )
    {
        if  (
                point_B_ < point_A_
            )
        {
            std::swap
                (
                    point_A_,
                    point_B_
                );
        }//if
    }
    //-----------------------------------------------------------------------------------
    bool  operator<(const T_line&  line)    const
    {
        return      std::make_pair
                        (
                            point_A_,
                            point_B_
                        )
 
                <   std::make_pair
                        (
                            line.point_A_,
                            line.point_B_
                        );
    }
    //-----------------------------------------------------------------------------------
    T_point  get_vector()                   const
    {
        return  point_B_ - point_A_;
    }
    //-----------------------------------------------------------------------------------
    T_point  point_A()                      const
    {
        return  point_A_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_intersection_point: public  T_point
{
    //-----------------------------------------------------------------------------------
    const T_line    line_A_;
    const T_line    line_B_;
    bool            empty_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_intersection_point
        (
            const  T_line&  line_A,
            const  T_line&  line_B
        )
        :
        line_A_( line_A ),
        line_B_( line_B )
    {
        calc_lines_intersection();
    }
    //-----------------------------------------------------------------------------------
    bool  empty()   const
    {
        return  empty_;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  calc_lines_intersection()
    {
        //Найдем точку K пересечения прямых AB и CD.
        //Пусть     AK = AB * p                         (1)
        //и         CK = CD * r.
        //Тогда из уравнения    AK + KC = AC
        //получим:              AB * p + DC * r = AC
        //т.е.                  (B - A) * p + (C - D) * r = C - A.
        //Находим из этого уравнения p по правилу Крамера, тогда из (1) получим:
        //                      K = A + AB * p
        //т.е.                  K = A + (B - A) * p.
 
        T_point     col_1
                        (
                            line_A_.get_vector()
                        );
 
        T_point     col_2
                        (
                            line_B_.get_vector()
                        );
 
        T_point     col_3
                        (
                                line_B_.point_A()
                            -   line_A_.point_A()
                        );
 
        T_real  det     =   calc_det
                                (
                                    col_1,
                                    col_2
                                );
 
        empty_          =   equal_for_real
                                (
                                    det,
                                    T_real()
                                );
 
        if( !empty_ )
        {
            T_real  det_1           =   calc_det
                                            (
                                                col_3,
                                                col_2
                                            );
 
            T_real  factor          =   det_1 / det;
 
            T_point     res_point   =       line_A_.point_A()
                                        +       line_A_.get_vector()
                                            *   factor;
 
            assign( res_point );
        }
    }
    //-----------------------------------------------------------------------------------
    static T_real  calc_det
        (
            const T_point   point_A,
            const T_point   point_B
        )
    {
        return      point_A.x() * point_B.y()
                -   point_B.x() * point_A.y();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef     std::set<T_line>            T_lines;
typedef     std::map<T_point, T_lines>  T_lines_of_point;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_plane_with_lines
{
    const T_points      given_points_;
    T_lines             lines_;
    T_lines_of_point    lines_of_point_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_plane_with_lines(const T_points&  points)
        :
        given_points_( points )
    {
        make_lines              ();
        add_intersection_points ();
    }
    //-----------------------------------------------------------------------------------
    int  get_parts_counter()    const
    {
        int res =   1 + lines_.size();
 
        for (
                auto
                it_point_and_lines  =   lines_of_point_.begin   ();
                it_point_and_lines  !=  lines_of_point_.end     ();
                ++it_point_and_lines
            )
        {
            res +=  it_point_and_lines->second.size() - 1;
        }//for
 
        return  res;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  make_lines()
    {
        for (
                auto
                it_point_A    =   given_points_.begin ();
                it_point_A    !=  given_points_.end   ();
                ++it_point_A
            )
        {
            auto    B_begin     =   it_point_A;
            ++B_begin;
 
            for (
                    auto
                    it_point_B    =   B_begin;
                    it_point_B    !=  given_points_.end();
                    ++it_point_B
                )
            {
                T_line  cur_line
                            (
                                *it_point_A,
                                *it_point_B
                            );
 
                lines_                          .insert( cur_line );
                lines_of_point_[ *it_point_A ]  .insert( cur_line );
                lines_of_point_[ *it_point_B ]  .insert( cur_line );
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  add_intersection_points()
    {
        for (
                auto
                it_line_A   =   lines_.begin    ();
                it_line_A   !=  lines_.end      ();
                ++it_line_A
            )
        {
            auto    line_B_begin    =   it_line_A;
            ++line_B_begin;
 
            for (
                    auto
                    it_line_B   =   line_B_begin;
                    it_line_B   !=  lines_.end();
                    ++it_line_B
                )
            {
                T_intersection_point    intersection_point
                                            (
                                                *it_line_A,
                                                *it_line_B
                                            );
 
                if  (
                        !intersection_point.empty()
                    )
                {
                    lines_of_point_[ intersection_point ].insert( *it_line_A );
                    lines_of_point_[ intersection_point ].insert( *it_line_B );
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    int     points_count    =   0;
    std::cout   <<  "Введите количество точек: ";
 
    std::cin    >>  points_count;
 
    std::cout   <<  "Введите "
                <<  points_count
                <<  " точек:"
                <<  std::endl;
 
    T_points    points;
 
    for(int i = 0; i < points_count; ++i)
    {
        T_real  x = 0;
 
        std::cout   <<  "x"
                    <<  i + 1
                    <<  " = ";
 
        std::cin    >>  x;
 
        T_real  y = 0;
 
        std::cout   <<  "y"
                    <<  i + 1
                    <<  " = ";
 
        std::cin    >>  y;
 
        points.insert
            (
                T_point(x, y)
            );
 
        std::cout   <<  std::endl;
    }//for
 
    T_plane_with_lines  plane_with_lines( points );
 
    std::cout   <<  "Прямые делят плоскость на "
                <<  plane_with_lines.get_parts_counter()
                <<  " частей."
                <<  std::endl;
 
    getch();
}