Language: C++

/**
 * @brief 凸包の構成について扱います
 *
 * @note  点集合Qの各点がその境界上か内部にある最小の凸多角形PをQの凸包(convex hull)と言い、CH(Q)で表す
 *        集合Qの点はすべて異なり、同一直線上にはない3点を少なくとも含むと仮定する
 *        直観的には、Qの各点を板から突き出した釘であると考えることができる. これらすべての釘を取り囲む、強い輪ゴムが作る形状が凸包である
 *
 * @date  2016/03/21
 */


//****************************************
// 必要なヘッダファイルのインクルード
//****************************************

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



//****************************************
// オブジェクト形式マクロの定義
//****************************************

//#define GEOMETRY_BEGIN namespace geom {
//#define GEOMETRY_END }



//****************************************
// 型シノニム
//****************************************

using coord_t    = long double;
using index_t    = std::int32_t;
using indices_t  = std::vector<index_t>;



//****************************************
// 構造体の定義
//****************************************

struct point {
    coord_t x, y;
    point() : x(0), y(0) {}
    point(coord_t x, coord_t y) : x(x), y(y) {}

    point& operator+=(const point& p)  { x += p.x; y += p.y; return *this; }
    point& operator-=(const point& p)  { x -= p.x; y -= p.y; return *this; }
    point& operator*=(const coord_t d) { x *= d; y *= d; return *this;}

    point operator+(const point& p)  const { return point(*this) += p; }
    point operator-(const point& p)  const { return point(*this) -= p; }
    point operator*(const coord_t d) const { return point(*this) *= d; }
};


struct segment {
    point ps;  // 線分の始点
    point pd;  // 線分の終点
};



namespace limits {
    constexpr auto pi  = 3.141592653589793238;
    constexpr auto eps = 1e-10;
    constexpr auto inf = 1e12;
}


/**
 * @brief   与えられた3点a, b, cをa -> b -> cと進むとき、
 * @details a -> bで時計方向に折れてb -> c(cw)
 *          a -> bで反時計方向に折れてb -> c(ccw)
 *          a -> bで逆を向いてaを通り越してb -> c (back)
 *          a -> bでそのままb -> c(front)
 *          a -> bで逆を向いてb -> cまたは、b == c(on)
 */
enum struct orientation {
    cw    = -1,
    ccw   = +1,
    back  = +2,
    front = -2,
    on    = 0,
};



/**
 * @brief 述語オブジェクト
 */
struct cmp_x { bool operator()(const point& pi, const point& pj) { return pi.x < pj.x; } };
struct cmp_y { bool operator()(const point& pi, const point& pj) { return pi.y < pj.y; } };



//****************************************
// 型シノニムその2
//****************************************

using vector_t   = point;
using polygon_t  = std::vector<point>;
using segments_t = std::vector<segment>;



//****************************************
// 関数の定義
//****************************************

/**
 * @brief  2つのベクトルa, bからなる行列A = (a, b)の行列式(determinant)を返します
 * @param  const vector_t& a ベクトルa
 * @param  const vector_t& b ベクトルb
 * @return coord_t det(A)    行列式|(a, b)|
 */
static constexpr coord_t det(const vector_t& a, const vector_t& b)
{
    return a.x * b.y - a.y * b.x;
}


/**
 * @brief  2つのベクトルa, bのクロス積(cross product)a x bを返します
 * @param  const vector_t& a  ベクトルa
 * @param  const vector_t& b  ベクトルb
 * @return coord_t a x b      クロス積a x b
 */
static constexpr coord_t cross(const vector_t& a, const vector_t& b)
{
    return a.x * b.y - a.y * b.x;
    //return det(a, b);
}


/**
 * @brief  2つのベクトルa, bのドット積(dot product)a・bを返します
 * @param  const vector_t& a  ベクトルa
 * @param  const vector_t& b  ベクトルb
 * @return coord_t a・b       ドット積a・b
 */
static constexpr coord_t dot(const vector_t& a, const vector_t& b)
{
    return a.x * b.x + a.y * b.y;
}


/**
 * @brief  ベクトルvのノルム(norm・大きさの2乗)を返します
 * @param  const vector_t& v
 * @return coord_t norm(v);
 */
static constexpr coord_t norm(const vector_t& v)
{
    return v.x * v.x + v.y * v.y;
    // return dot(v, v);
}


/**
 * @brief  ベクトルvの大きさ|v|(原点からの距離)を返します
 * @param  const vector_t& v
 * @return coord_t sqrt(norm(v))
 */
static inline coord_t abs(const vector_t& v)
{
    return std::sqrt(norm(v));
}


/**
 * @brief  点pから線分sに下ろした垂線と線分sの交点を返します
 * @param  const segment& s 線分s
 * @param  const point& p   点p
 * @return 垂線と線分の交点
 */
static inline point proj(const segment& s, const point& p)
{
    vector_t base = s.pd - s.ps;
    vector_t hypo = p - s.ps;
    coord_t r = dot(hypo, base) / norm(base);
    return s.ps + base * r;
}


/**
 * @brief  点pと線対称の位置に存在する点を返します
 * @param  cosnt segment& s 線分s
 * @param  const point&   p 点p
 * @param  pと線対称な点
 */
static inline point reflect(const segment& s, const point p)
{
    return p + (proj(s, p) - p) * 2.0;
}


/**
 * @brief COMBINED-TOLERANCE-COMPAREより少ない労力で行える近似的な判定
 */
static inline bool approximate_combined_tolerance_compare(coord_t x, coord_t y) noexcept
{
    return std::fabs(x - y) <= limits::eps * (std::fabs(x) + std::fabs(y) + 1.0);
}


/**
 * @brief 手続きAPPROXIMATE-COMBINED-TOLERANCE-COMPAREの短い名前
 */
static inline bool eq(coord_t x, coord_t y)
{
    return approximate_combined_tolerance_compare(x, y);
}


/**
 * @brinf 2点(p1, p2)のp0に関する偏角(polar angle)から、
 *        p0から見た2つのベクトルp0p1↑, p0p2↑の方向を返す
 */
static inline orientation ccw(point p0, point p1, point p2)
{
    p1 -= p0; p2 -= p0;

    if (cross(p1, p2) > limits::eps)  { return orientation::ccw;  }  // クロス積(p1-p0)x(p2-p0)が正の場合、ccw  ...(*1)
    if (cross(p1, p2) < -limits::eps) { return orientation::cw;   }  // クロス積(p1-p0)x(p2-p0)が負の場合、cw   ...(*2)


    // (*1), (*2)に当てはまらないとき、p2は直線p0p1|上(線分p0p1↑上とは限らない)に存在する

    if (dot(p1, p2) < -limits::eps)   { return orientation::back;  }  // ドット積(p1-p0)・(p2-p0)が負の場合、p2->p0->p1(back) ...(*3)

    // (*3)に当てはまらないとき、p2はp0->p1->p2またはp0->p2->p1の位置に存在する

    if (eq(norm(p1), norm(p2)))       { return orientation::front; }  // p0p2↑の大きさがp0p1↑の大きさより大きい場合、p0->p1->p2(front) ...(*4)

    // (*4)に当てはまらないとき、p0->p2->p1(on)
    return orientation::on;
}


//****************************************
// 構造体の定義
//****************************************

struct cmp_xy { bool operator()(const point& pi, const point& pj) { return pi.x < pj.x || (eq(pi.x, pj.x) && pi.y < pj.y); } };



//****************************************
// 関数の定義
//****************************************

polygon_t andrew_scan(polygon_t& P, bool degenerate)
{
    index_t n = P.size(), k = 0;

    // 与えられた点の中からすべての点を左から右に順序付けする
    std::sort(P.begin(), P.end(), cmp_xy());  // NOTE: xが等しい場合、yの昇順とする

    // 上側チェーンと下側チェーンを構成する(それぞれ凸包の上半分と下半分に相当する)
    polygon_t L(2 * n);  // NOTE: Pの点を1点ずつ加えながら解を更新する

    // 縮退を考慮するか否かを決定する述語を設定する
    auto pred = degenerate
        ? std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) != orientation::ccw; })
        : std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) == orientation::cw;  });
                            

    // まず、凸包上の点の中で上部凸包(upper hull)上にあるものだけ求める
    for (index_t i = 0; i < n; i++) {
        while (k >= 2 && pred(i, k)) { k = k - 1; }
        L[k] = P[i]; k = k + 1;
    }

    // 右から左へと実行される2番目の走査で、凸包の残りの部分、すなわち下部凸包(lower hull)を計算する
    for (index_t i = n - 2, t = k + 1; i >= 0; i--) {
        while (k >= t && pred(i, k)) { k = k - 1; }
        L[k] = P[i]; k = k + 1;
    }

    L.resize(k - 1);  // CH(P)の頂点を時計回りの順に並べたリストL
    return L;         // リストLを返す
}



//****************************************
// エントリポイント
//****************************************

int main()
{
    using namespace std;
    int n;
    cin >> n;

    polygon_t poly(n);
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        poly[i] = point(x, y);
    }

    polygon_t convex_hull = andrew_scan(poly, false);

    cout << convex_hull.size() << endl;
    for (auto& p : convex_hull) {
        cout << p.x << " " << p.y << endl;
    }
    
    return 0;
}

Compiler output:
a.cc:37:25: error: 'int32_t' in namespace 'std' does not name a type
   37 | using index_t    = std::int32_t;
      |                         ^~~~~~~
a.cc:38:32: error: 'index_t' was not declared in this scope
   38 | using indices_t  = std::vector<index_t>;
      |                                ^~~~~~~
a.cc:38:39: error: template argument 1 is invalid
   38 | using indices_t  = std::vector<index_t>;
      |                                       ^
a.cc:38:39: error: template argument 2 is invalid
a.cc: In function 'polygon_t andrew_scan(polygon_t&, bool)':
a.cc:259:5: error: 'index_t' was not declared in this scope
  259 |     index_t n = P.size(), k = 0;
      |     ^~~~~~~
a.cc:265:21: error: 'n' was not declared in this scope
  265 |     polygon_t L(2 * n);  // NOTE: Pの点を1点ずつ加えながら解を更新する
      |                     ^
a.cc:269:16: error: 'function' is not a member of 'std'
  269 |         ? std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) != orientation::ccw; })
      |                ^~~~~~~~
a.cc:20:1: note: 'std::function' is defined in header '<functional>'; this is probably fixable by adding '#include <functional>'
   19 | #include <cmath>
  +++ |+#include <functional>
   20 | 
a.cc:269:46: error: expression list treated as compound expression in functional cast [-fpermissive]
  269 |         ? std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) != orientation::ccw; })
      |                                              ^
a.cc:269:53: error: 'index_t' is not a type
  269 |         ? std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) != orientation::ccw; })
      |                                                     ^~~~~~~
a.cc:269:64: error: 'index_t' is not a type
  269 |         ? std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) != orientation::ccw; })
      |                                                                ^~~~~~~
a.cc:270:16: error: 'function' is not a member of 'std'
  270 |         : std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) == orientation::cw;  });
      |                ^~~~~~~~
a.cc:270:16: note: 'std::function' is defined in header '<functional>'; this is probably fixable by adding '#include <functional>'
a.cc:270:46: error: expression list treated as compound expression in functional cast [-fpermissive]
  270 |         : std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) == orientation::cw;  });
      |                                              ^
a.cc:270:53: error: 'index_t' is not a type
  270 |         : std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) == orientation::cw;  });
      |                                                     ^~~~~~~
a.cc:270:64: error: 'index_t' is not a type
  270 |         : std::function<bool(index_t, index_t)>([&](index_t i, index_t k) -> bool { return ccw(L[k - 2], L[k - 1], P[i]) == orientation::cw;  });
      |                                                                ^~~~~~~
a.cc:274:17: error: expected ';' before 'i'
  274 |     for (index_t i = 0; i < n; i++) {
      |                 ^~
      |                 ;
a.cc:274:25: error: 'i' was not declared in this scope
  274 |     for (index_t i = 0; i < n; i++) {
      |                         ^
a.cc:275:16: error: 'k' was not declared in this scope
  275 |         while (k >= 2 && pred(i, k)) { k = k - 1; }
      |                ^
a.cc:276:11: error: 'k' was not declared in this scope
  276 |         L[k] = P[i]; k = k + 1;
      |           ^
a.cc:280:17: error: expected ';' before 'i'
  280 |     for (index_t i = n - 2, t = k + 1; i >= 0; i--) {
      |                 ^~
      |                 ;
a.cc:280:40: error: 'i' was not declared in this scope
  280 |     for (index_t i = n - 2, t = k + 1; i >= 0; i--) {
      |                                        ^
a.cc:281:16: error: 'k' was not declared in this scope
  281 |         while (k >= t && pred(i, k)) { k = k - 1; }
      |                ^
a.cc:281:21: error: 't' was not declared in this scope
  281 |         while (k >= t && pred(i, k)) { k = k - 1; }
      |                     ^
a.cc:282:11: error: 'k' was not declared in this scope
  282 |         L[k] = P[i]; k = k + 1;
      |           ^
a.cc:285:14: error: 'k' was not declared in this scope
  285 |     L.resize(k - 1);  // CH(P)の頂点を時計回りの順に並べたリストL
      |              ^