Language: C++

#define _USE_MATH_DEFINES
#include<bits/stdc++.h>
using namespace std;

const int COUNTER_CLOCKWISE = +1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = +2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;

#define EPS 1e-10
#define INF 1e10

typedef complex<double> Point;
typedef complex<double> Vector;
typedef vector<Point> Polygon;

struct Line
{
	Point a, b;
	Line() {}
	Line(Point &_a, Point &_b)
	{
		a = _a; b = _b;
	}
};

//?????????Line??¨??????(??????????????????????????????????????????)
struct Segment
{
	Point a, b;
	Segment() {}
	Segment(Point &_a, Point &_b)
	{
		a = _a; b = _b;
	}
};

struct Circle
{
	Point c;
	double r;

	Circle() {}

	Circle(Point &_c, double &_r)
	{
		c = _c; r = _r;
	}
};

istream& operator >> (istream& is, Point &p)
{
	double x, y;
	is >> x >> y;
	p.real(x); p.imag(y);
	return is;
}

Segment ToSegment(Line l)
{
	return Segment(l.a, l.b);
}

Line ToLine(Segment s)
{
	return Line(s.a, s.b);
}

//???????¨±???==
bool equals(double a, double b)
{
	return abs(a - b) < EPS;
}

//???????¨±???==
bool equals(Vector &a, Vector &b)
{
	return equals(a.real(), b.real()) && equals(a.imag(), b.imag());
}

bool operator < (const Point &a, const Point &b)
{
	return equals(a.real(), b.real()) ? a.imag() < b.imag() : a.real() < b.real();
}

//??????
double dot(Vector &a, Vector &b)
{
	return a.real()*b.real() + a.imag()*b.imag();
}

//??????
double cross(Vector &a, Vector &b)
{
	return a.real()*b.imag() - a.imag()*b.real();
}

//????§???¢?????¢???
double GetArea(Polygon &g)
{
	double res = 0;
	for (int i = 1; i < g.size() - 1; i++)
	{
		res += cross(Vector(g[i] - g[0]), Vector(g[i + 1] - g[0]));
	}
	return abs(res / 2);
}

//???????¨???????(O(1))
//?????¶:????????¨?????°??????
int CCW(Point &p0, Point &p1, Point &p2)
{
	Vector v1 = (Vector)(p1 - p0), v2 = p2 - p0;
	if (cross(v1, v2) > EPS) return COUNTER_CLOCKWISE;
	if (cross(v1, v2) < -EPS) return CLOCKWISE;
	if (dot(v1, v2) < -EPS) return ONLINE_BACK;
	if (abs(v1) < abs(v2)) return ONLINE_FRONT;
	return ON_SEGMENT;
}

//??´?????????(O(1))
//?????¶:????????°??????
bool IsOrthogonal(Vector &a, Vector &b)
{
	return equals(dot(a, b), 0.0);
}

//????????????(O(1))
bool IsParallel(Vector &a, Vector &b)
{
	return equals(cross(a, b), 0.0);
}

//?°???±(O(1))
Point Project(Line &s, Point &p) {
	Vector v1 = s.b - s.a;
	Vector v2 = p - s.a;
	double r = dot(v1, v2)/norm(v1);
	return s.a + v1 * r;
}

//????°?(O(1))
Point Reflect(Line &s, Point &p) {
	return p + (Project(s, p) - p) * 2.0;
}

//??´?????¨?????????????????????(O(1))
bool Intersects(Line &l, Segment &s)
{
	return CCW(l.a, l.b, s.a)*CCW(l.a, l.b, s.b) != 1;
}

//?????????????????????(O(1))
bool Intersects(Segment &l1, Segment &l2)
{
	return CCW(l1.a, l1.b, l2.a)*CCW(l1.a, l1.b, l2.b) <= 0 &&
		CCW(l2.a, l2.b, l1.a)*CCW(l2.a, l2.b, l1.b) <= 0;
}

//??´????????????(O(1))
//?????¶:??´??????????????§??????
Point GetIntersection(Line &l1, Line &l2)
{
	Vector a1 = l1.b - l1.a, a2 = l2.b - l2.a;
	Vector b1 = l2.a - l1.a, b2 = l1.a - l2.b;
	double s1 = cross(a1, b1) / 2, s2 = cross(a1, b2) / 2;
	return Point(l2.a.real() + a2.real()*s1/(s1 + s2), l2.a.imag() + a2.imag()*s1/(s1 + s2));
}

//????????????(O(1))
//?????¶:????????°??????
vector<Point> GetIntersection(Circle &c1, Circle &c2)
{
	vector<Point> res;
	double d, a, t;
	d = sqrt(norm((c2.c - c1.c)));
	if (d < abs(c1.r - c2.r) || c1.r + c2.r < d) return res; //??¢?????????????????????
	a = acos((c1.r*c1.r + d*d - c2.r*c2.r)/(2*c1.r*d));
	t = atan2(c2.c.imag() - c1.c.imag(), c2.c.real() - c1.c.real());
	res.push_back(Point(c1.c.real() + c1.r*cos(t + a), c1.c.imag() + c1.r*sin(t + a)));
	res.push_back(Point(c1.c.real() + c1.r*cos(t - a), c1.c.imag() + c1.r*sin(t - a)));
	if (equals(res[0], res[1])) res.pop_back(); //?????????1???
	return res;
}

//????§???¢??????????????????(O(n))
//?????????
//	0:?????????????????????
//	1:??????????????????
//	2:?????????
int Contains(Polygon &g, Point &p)
{
	Line l = Line(p, Point(INF, p.imag()));
	int cnt = 0, n = g.size();
	for (int i = 0; i < n; i++)
	{
		Vector a = g[i] - p;
		Vector b = g[(i+1)%n] - p;
		if (CCW(g[i], g[(i+1)%n], p) == 0) return 2; //?????????
		if (a.imag() > b.imag()) swap(a, b);
		if (a.imag() <= EPS && EPS < b.imag() && cross(a, b) > EPS) cnt++;
	}
	if ((cnt&1) == 1) return 1; //??????????????????
	return 0; //?????????????????????
}

//??????(O(n))
Polygon AndrewScan(Polygon &s)
{
	if (s.size() <= 2) return s;
	sort(s.begin(), s.end());
	Polygon g;
	for (int i = 0; i < s.size(); i++)
	{
		for (int n = g.size(); n >= 2 && CCW(g[n - 2], g[n - 1], s[i]) != -1; n--)
		{
			g.pop_back();
		}
		g.push_back(s[i]);
	}
	int upper_n = g.size();
	for (int i = s.size() - 2; i >= 0; i--)
	{
		for (int n = g.size(); n > upper_n && CCW(g[n - 2], g[n - 1], s[i]) != -1; n--)
		{
			g.pop_back();
		}
		g.push_back(s[i]);
	}
	reverse(g.begin(), g.end());
	g.pop_back();
	return g;
}

//????§???¢?????????
vector<Polygon> PolygonCut(Polygon &g, Line &l)
{
	vector<Polygon> res;
	res.push_back(Polygon());
	for (int i = 0; i < g.size(); i++)
	{
		res.back().push_back(g[i]);
		Segment s = Segment(g[i], g[(i + 1) % g.size()]);
		if (Intersects(l, s))
		{
			Point p = GetIntersection(l, ToLine(s));
			res.back().push_back(p);
			res.push_back(Polygon());
			res.back().push_back(p);
		}
	}
	res.front().insert(res.front().begin(), res.back().begin(), res.back().end());
	res.pop_back();
	return res;
}

int N, Q;
Polygon g;

signed main()
{
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		g.push_back(Point());
		cin >> g.back();
	}
	cin >> Q;
	for (int i = 0; i < Q; i++)
	{
		Line l;
		cin >> l.a >> l.b;
		vector<Polygon> v = PolygonCut(g, l);
		int left;
		for (int j = 0; j < v.size(); j++)
		{
			for (int k = 0; k < v[j].size(); k++)
			{
				if (CCW(l.a, l.b, v[j][k]) == 1)
				{
					left = j;
				}
			}
		}
		printf("%.16f\n", GetArea(v[left]));
	}
}

Compiler output:
a.cc: In function 'double GetArea(Polygon&)':
a.cc:105:30: error: cannot bind non-const lvalue reference of type 'Vector&' {aka 'std::complex<double>&'} to an rvalue of type 'std::complex<double>'
  105 |                 res += cross(Vector(g[i] - g[0]), Vector(g[i + 1] - g[0]));
      |                              ^~~~~~~~~~~~~~~~~~~
a.cc:94:22: note:   initializing argument 1 of 'double cross(Vector&, Vector&)'
   94 | double cross(Vector &a, Vector &b)
      |              ~~~~~~~~^
a.cc: In function 'int Contains(Polygon&, Point&)':
a.cc:194:26: error: cannot bind non-const lvalue reference of type 'Point&' {aka 'std::complex<double>&'} to an rvalue of type 'Point' {aka 'std::complex<double>'}
  194 |         Line l = Line(p, Point(INF, p.imag()));
      |                          ^~~~~~~~~~~~~~~~~~~~
a.cc:22:32: note:   initializing argument 2 of 'Line::Line(Point&, Point&)'
   22 |         Line(Point &_a, Point &_b)
      |                         ~~~~~~~^~
a.cc: In function 'std::vector<std::vector<std::complex<double> > > PolygonCut(Polygon&, Line&)':
a.cc:247:60: error: cannot bind non-const lvalue reference of type 'Line&' to an rvalue of type 'Line'
  247 |                         Point p = GetIntersection(l, ToLine(s));
      |                                                      ~~~~~~^~~
a.cc:163:39: note:   initializing argument 2 of 'Point GetIntersection(Line&, Line&)'
  163 | Point GetIntersection(Line &l1, Line &l2)
      |                                 ~~~~~~^~
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
                 from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:2:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<std::complex<double>*, std::vector<std::complex<double> > >; _Iterator2 = __gnu_cxx::__normal_iterator<std::complex<double>*, std::vector<std::complex<double> > >]':
/usr/include/c++/14/bits/stl_algo.h:1777:14:   required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1777 |           if (__comp(__i, __first))
      |               ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25:   required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1817 |           std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
      |           ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31:   required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
 1908 |           std::__final_insertion_sort(__first, __last, __comp);
      |           ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18:   required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<complex<double>*, vector<complex<double> > >]'
 4772 |       std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
      |       ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:212:6:   required from here
  212 |         sort(s.begin(), s.end());
      |         ~~~~^~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:45:23: error: no match for 'operator<' (operand types are 'std::complex<double>' and 'std::complex<double>')
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:67:
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
 1241 |     operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
 1249 |     operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/regex:68,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:181:
/usr/include/c++/14/bits/regex.h:1143:5: note: candidate: 'template<class _BiIter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const sub_match<_BiIter>&)'
 1143 |     operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1143:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1224:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator<(__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&, const sub_match<_BiIter>&)'
 1224 |     operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1224:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'std::__cxx11::__sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1317:5: note: candidate: 'template<class _Bi_iter, class _Ch_traits, class _Ch_alloc> bool std::__cxx11::operator<(const sub_match<_BiIter>&, __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>&)'
 1317 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1317:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1391:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const typename std::iterator_traits<_Iter>::value_type*, const sub_match<_BiIter>&)'
 1391 |     operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1391:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1485:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type*)'
 1485 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1485:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1560:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const typename std::iterator_traits<_Iter>::value_type&, const sub_match<_BiIter>&)'
 1560 |     operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1560:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/regex.h:1660:5: note: candidate: 'template<class _Bi_iter> bool std::__cxx11::operator<(const sub_match<_BiIter>&, const typename std::iterator_traits<_Iter>::value_type&)'
 1660 |     operator<(const sub_match<_Bi_iter>& __lhs,
      |     ^~~~~~~~
/usr/include/c++/14/bits/regex.h:1660:5: note:   template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note:   'std::complex<double>' is not derived from 'const std::__cxx11::sub_match<_BiIter>'
   45 |       { return *__it1 < *__it2; }
      |                ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:64:
/usr/include/c++/14/bits/stl_pair.h:1045:5: note: candidate: 'template<class _T1, class _T2> constexpr bool std::operator<(const pair<_T1, _T2>&, const pair<_T1