#include "hexagon.h"
#include <bits/stdc++.h>
template <int md>
struct Modular {
int v;
constexpr Modular() : v(0) {}
template <typename T>
static inline int normalize(const T& x) {
int res = -md <= x && x < md ? static_cast<int>(x) : static_cast<int>(x % md);
return res + (res < 0) * md;
}
static constexpr int mod() {
return md;
}
template <typename U>
Modular(const U& x) : v(normalize(x)) {}
const int& operator()() const { return v; }
template <typename U>
explicit operator U() const {
return static_cast<U>(v);
}
using M = Modular;
constexpr static inline M _raw(int x) {
static_assert(x >= 0 && x < md);
M res;
res.v = x;
return res;
}
template <typename U>
friend std::enable_if_t<std::is_integral_v<U>, M> power(M b, U e) {
assert(e >= 0);
M ans = 1;
while (e) {
if (e & 1) ans *= b;
b *= b;
e >>= 1;
}
return ans;
}
M inv() const {
M res = power(*this, md - 2);
return res;
}
M& operator+=(const M& y) { return v += y.v, v -= (v >= md) * md, *this; }
M& operator-=(const M& y) { return v -= y.v, v += (v < 0) * md, *this; }
M& operator*=(const M& y) { return v = (int64_t) v * y.v % md, *this; }
M& operator/=(const M& y) { return *this *= y.inv(); }
M& operator++() { return *this += _raw(1); }
M& operator--() { return *this -= _raw(1); }
M operator++(int) {
M res(*this);
return *this += _raw(1), res;
}
M operator--(int) {
M res(*this);
return *this -= _raw(1), res;
}
M operator-() const { return M(-v); }
friend bool operator==(const M& x, const M& y) { return x.v == y.v; }
friend bool operator<(const M& x, const M& y) { return x.v < y.v; }
friend bool operator>(const M& x, const M& y) { return x.v > y.v; }
friend bool operator<=(const M& x, const M& y) { return x.v <= y.v; }
friend bool operator>=(const M& x, const M& y) { return x.v >= y.v; }
friend bool operator!=(const M& x, const M& y) { return x.v != y.v; }
template <typename Istream>
friend Istream& operator>>(Istream& is, M& y) {
int64_t x;
is >> x;
y.v = y.normalize(x);
return is;
}
template <typename Ostream>
friend Ostream& operator<<(Ostream& os, const M& y) {
return os << y.v;
}
friend M operator+(const M& x, const M& y) { return M(x) += y; }
friend M operator-(const M& x, const M& y) { return M(x) -= y; }
friend M operator*(const M& x, const M& y) { return M(x) *= y; }
friend M operator/(const M& x, const M& y) { return M(x) /= y; }
};
constexpr int md = 1e9 + 7;
using Mint = Modular<md>;
constexpr int A = 4200;
int grid[A][A];
std::bitset<A> is_road[A];
std::pair<int, int> q[A * A];
int sz = 0, fi = 0;
std::bitset<A> vis[A];
int dist[A][A];
const std::vector<std::pair<int, int>> dxy = {
{-1, 0},
{0, 1},
{1, 1},
{1, 0},
{0, -1},
{-1, -1}
};
int draw_territory(int N, int a, int b, std::vector<int> D, std::vector<int> L) {
#define int int64_t
memset(grid, -1, sizeof(grid));
if (N == 3) {
Mint answer = 0;
Mint size = L[0] + 1;
Mint number = size * (size + 1) / 2;
answer = size * (size + 1) * (size * 2 + 1) / 6;
answer -= number;
answer = number * a + b * answer;
return (int) answer;
}
int points_on_edges = 0;
std::vector<std::pair<int, int>> instruction;
for (int i = 0; i < N; i++) {
points_on_edges += L[i];
if (instruction.empty() || instruction.back().first != D[i]) {
instruction.emplace_back(D[i], L[i]);
} else {
instruction.back().second += L[i];
}
}
if (instruction.back().first == instruction.front().first) {
instruction.front().second += instruction.back().second;
instruction.pop_back();
}
std::vector<std::pair<int, int>> points;
points.emplace_back(0, 0);
for (int i = 0; i < N; i++) {
auto [dx, dy] = dxy[instruction[i].first - 1];
int mul = instruction[i].second;
auto [x, y] = points.back();
points.emplace_back(x + dx * mul, y + dy * mul);
}
int S2 = 0;
points.emplace_back(points.front());
for (int i = 0; i + 1 < (int) points.size(); i++) {
S2 += points[i].first * points[i + 1].second - points[i + 1].first * points[i].second;
}
// S2 = 2a + b - 1
// 2a = S2 - b + 1
int a2 = S2 - points_on_edges + 1;
a2 /= 2;
Mint ans = a2;
ans *= a;
return ans;
}
Compilation message
hexagon.cpp: In function 'int draw_territory(int, int, int, std::vector<int>, std::vector<int>)':
hexagon.cpp:180:10: error: cannot convert 'Mint' {aka 'Modular<1000000007>'} to 'int' in return
180 | return ans;
| ^~~
