Monikulmio

input/code.cpp: In function 'int main()':
input/code.cpp:116:15: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
  116 |     for (auto [y, x] : points)
      |               ^
input/code.cpp:132:26: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  132 |         for (ll j = 0; j < points.size() - 1; j++)
      |                        ~~^~~~~~~~~~~~~~~~~~~

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

#define fastio               \
    ios::sync_with_stdio(0); \
    cin.tie(0);              \
    cout.tie(0);
#define ll long long
#define pb push_back
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x).size()

const int MOD = 1e9 + 7;
const ll INF = 1e18;

int main()
{
    fastio;

    int n, m, k;
    cin >> n >> m >> k;
    int q = k - 1;

    vector<vector<char> > matrix(n, vector<char>(m, '.'));

    vector<pair<int, int> > points;

    ll first_y, first_x;
    cin >> first_y >> first_x;

    points.pb(make_pair(first_y, first_x));
    matrix[first_y - 1][first_x - 1] = '*';

    while (q--)
    {
        ll a, b;
        cin >> a >> b;
        matrix[a - 1][b - 1] = '*';
        points.pb(make_pair(a, b));
    }

    points.pb(make_pair(first_y, first_x));

    for (int i = 1; i <= k; i++)
    {
        int y1 = points[i - 1].first;
        int x1 = points[i - 1].second;
        int y2 = points[i].first;
        int x2 = points[i].second;

        if (y2 == y1)
        {
            int s = min(x2, x1);
            int b = max(x2, x1);
            for (int j = s; j < b - 1; j++)
            {
                matrix[y2 - 1][j] = '=';
            }
        }

        if (x2 == x1)
        {
            int s = min(y2, y1);
            int b = max(y2, y1);
            for (int j = s; j < b - 1; j++)
            {
                matrix[j][x2 - 1] = '|';
            }
        }

        if ((y2 - y1) * (x2 - x1) != 0)
        {
            ll steps = abs(x2 - x1) - 1;

            ll x = x1 - 1;
            ll y = y1 - 1;

            ll step_x, step_y;

            if (x2 > x1)
            {
                step_x = 1;
            }
            else
            {
                step_x = -1;
            }
            if (y2 > y1)
            {
                step_y = 1;
            }
            else
            {
                step_y = -1;
            }

            for (ll j = 0; j < steps; j++)
            {
                x += step_x;
                y += step_y;

                if ((step_x > 0 && step_y > 0) || (step_x < 0 && step_y < 0))
                {
                    matrix[y][x] = '\\';
                }
                else
                {
                    matrix[y][x] = '/';
                }
            }
        }
    }

    ll max_y = 0;
    ll min_y = n;
    for (auto [y, x] : points)
    {
        if (y > max_y)
        {
            max_y = y;
        }
        if (y < min_y)
        {
            min_y = y;
        }
    }

    for (ll i = min_y; i <= max_y; i++)
    {
        vector<ll> intersections;

        for (ll j = 0; j < points.size() - 1; j++)
        {
            auto p1 = points[j];
            auto p2 = points[j + 1];
            ll y1 = p1.first;
            ll x1 = p1.second;
            ll y2 = p2.first;
            ll x2 = p2.second;

            if (y1 > y2)
            {
                swap(y1, y2);
                swap(x1, x2);
            }

            if (y1 == y2)
            {
                continue;
            }

            if (y1 <= i && i < y2)
            {
                double x_val = (double)x1 + (double)(i - y1) * (double)(x2 - x1) / (double)(y2 - y1); // Issues with rounding
                intersections.pb((ll)round(x_val));
            }
        }
        sort(all(intersections));

        if ((ll)intersections.size() % 2 != 0) // Issues with indexing? Is this a problem? (TBD)
        {
            intersections.pop_back();
        }

        for (ll j = 0; j < (ll)intersections.size() - 1; j += 2) // (ll) thing needed because if it becomes -1 (which is possible), it will blow up to a big number and cause seg fault. (ll) is safer.
        {
            ll l = intersections[j];
            ll r = intersections[j + 1];
            for (ll k = l + 1; k < r; k++)
            {
                if (i - 1 >= 0 && i - 1 < n && k - 1 >= 0 && k - 1 < m)
                {
                    if (matrix[i - 1][k - 1] == '.')
                    {
                        matrix[i - 1][k - 1] = '#';
                    }
                }
            }
        }
    }

    for (ll i = 0; i < n; i++)
    {
        for (ll j = 0; j < m; j++)
        {
            cout << matrix[i][j];
        }
        cout << "\n";
    }
}

Test 1 (public)

Verdict: ACCEPTED

Test 2 (public)

Verdict: ACCEPTED

Test 3 (public)

Verdict: ACCEPTED

Test 4 (public)

Verdict: ACCEPTED

Test 5 (public)

Verdict: ACCEPTED

Test 6 (public)

Verdict: ACCEPTED

Test 7 (public)

Verdict: ACCEPTED

Test 8 (public)

Verdict: ACCEPTED

Test 9 (public)

Verdict: ACCEPTED

Test 10 (public)

Verdict: ACCEPTED