Программирование на си

 #include 

#include 

#include 



using namespace std;



struct Point { 

    double x; 

    double y;



    Point() : x(0), y(0) {}



    double length(const Point& p)const { 

        return sqrt(pow(p.x - x, 2) + pow(p.y - y, 2)); 

    }



    friend istream& operator>>(istream& inp, Point& p) { 

        return cin >> p.x >> p.y; 

    } 

};



class Triangle { 

public: 

    Triangle(const Point& a, const Point& b, const Point& c)

        : a(a), b(b), c(c) {}



    double area()const { 

        const auto arg = argument(); 

        const auto s = sqrt(arg); 

        return s; 

    }



    double perimetr()const { 

        const auto [ab, bc, ca] = sides(); 

        const auto p = (ab + bc + ca) / 2.0; 

        return p; 

    }



    bool exist()const { 

        return argument() > 0; 

    } 

private: 

    Point a; 

    Point b; 

    Point c;



    tuple sides()const { 

        const auto ab = a.length(b); 

        const auto bc = b.length(c); 

        const auto ca = c.length(a); 

        return { ab, bc, ca }; 

    }



    double argument()const { 

        const auto [ab, bc, ca] = sides(); 

        const auto p = perimetr(); 

        const auto arg = p * (p - ab) * (p - bc) * (p - ca); 

        return arg; 

    } 

};



class ConvexPolygon { 

public: 

    ConvexPolygon(const vector& points) : points(points) {}



    double area()const { 

        const auto length = points.size(); 

        auto s = 0.0; 

        for (size_t i = 0, j = 1; j < length; ++i, ++j) { 

            s += (points[i].x + points[j].x) * (points[i].y - points[j].y); 

        } 

        s = fabs(s); 

        s /= 2.0; 

        return s; 

    } 



    bool includes(const Point& p)const { 

        static const auto eps = 1e-12; 

        const auto length = points.size(); 

        auto s = Triangle{ p, points[length - 1], points[0] }.area(); 

        for (size_t i = 0, j = 1; j < length; ++i, ++j) { 

            s += Triangle{ p, points[i], points[j] }.area(); 

        } 

        const auto scp = area(); 

        return fabs(s - scp) < eps; 

    } 

private: 

    vector points; 

};

 

int main() { 

    size_t n; 

    cin >> n; 

    vector points(n); 

    for (auto& point : points) cin >> point; 

    ConvexPolygon cp(points); 

    Point point; 

    cin >> point; 

    puts(cp.includes(point) ? "YES" : "NO"); 

}