problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02986 | C++ | Runtime Error | // need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// etc
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
#define SHOWSTACK(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.top() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define random_shuffle "USE std::shuffle!";
// type/const
// #define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = (1 << 30) - 1; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-10;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
struct Edge {
int from, to, cost, color;
};
struct EulerTour {
std::vector<int> eulerTour, begin, end;
int n, k;
// 頂点vを根とする木gのオイラーツアー
EulerTour(const std::vector<std::vector<Edge>> &g, int v)
: n(g.size()), k(0) {
begin.resize(n, 0);
end.resize(n, 0);
createEulerTour(g, v, -1);
}
// 頂点vを根とする木gのオイラーツアーを構成する
void createEulerTour(const std::vector<std::vector<Edge>> &g, int v,
int par) {
begin[v] = k++;
eulerTour.emplace_back(v);
for (auto e : g[v]) {
if (e.to == par)
continue;
createEulerTour(g, e.to, v);
eulerTour.emplace_back(v);
k++;
}
end[v] = k;
}
};
template <class T> class SparseTable {
size_t N;
std::vector<T> a;
std::vector<size_t> logTable;
std::vector<std::vector<T>> table;
public:
SparseTable(const std::vector<T> &_a) : N(_a.size()), a(_a) {
logTable.resize(N + 1, 0);
for (size_t i = 2; i <= N; ++i) {
logTable[i] = logTable[i >> 1] + 1;
}
table.resize(logTable[N] + 1, std::vector<T>(N));
for (size_t i = 0; i < N; ++i)
table[0][i] = a[i];
for (size_t k = 1; k <= logTable[N]; ++k) {
for (size_t i = 0; i + (1 << k) <= N; ++i) {
table[k][i] =
std::min(table[k - 1][i], table[k - 1][i + (1 << (k - 1))]);
}
}
}
// query in [l, r)
inline T query(int l, int r) {
int lg = logTable[r - l];
return std::min(table[lg][l], table[lg][r - (1 << lg)]);
}
};
constexpr int B = 333;
signed main() {
INIT;
VAR(int, n, Q);
VEC_ROW(int, n - 1, a, b, c, d);
VEC_ROW(int, Q, x, y, u, v);
REP(i, Q)-- x[i], --u[i], --v[i];
std::vector<std::vector<Edge>> g(n);
REP(i, n - 1) {
--a[i];
--b[i];
--c[i];
g[a[i]].emplace_back(Edge{a[i], b[i], d[i], c[i]});
g[b[i]].emplace_back(Edge{b[i], a[i], d[i], c[i]});
}
std::vector<int> depth(n, 0), dist(n, 0);
std::vector<Edge> par(n);
{
auto rec = [&](auto &&f, int v, int para) -> void {
for (auto &e : g[v])
if (e.to != para) {
depth[e.to] = depth[v] + 1;
dist[e.to] = dist[v] + e.cost;
par[e.to] = e;
f(f, e.to, v);
}
};
rec(rec, 0, -1);
}
EulerTour et(g, 0);
std::vector<PAIR> for_sparse_table(et.eulerTour.size());
REP(i, et.eulerTour.size()) {
int v = et.eulerTour[i];
for_sparse_table[i] = PAIR(depth[v], v);
}
SparseTable<PAIR> st(for_sparse_table);
VV<int> sum(n), cnt(n);
{
auto rec = [&](auto &&f, int v, int par, std::vector<int> &tsum,
std::vector<int> &tcnt) -> void {
if (depth[v] % B == 0) {
sum[v] = tsum;
cnt[v] = tcnt;
}
for (auto &e : g[v])
if (e.to != par) {
tsum[e.color] += e.cost;
++tcnt[e.color];
f(f, e.to, v, tsum, tcnt);
tsum[e.color] -= e.cost;
--tcnt[e.color];
}
};
V<int> tsum(n, 0), tcnt(n, 0);
rec(rec, 0, -1, tsum, tcnt);
}
REP(i, Q) {
PAIR lcap;
{
int l = et.begin[u[i]], r = et.begin[v[i]];
if (l > r)
std::swap(l, r);
lcap = st.query(l, r);
}
int lca = lcap.second;
int ans = 0;
while (u[i] != lca && dist[u[i]] % B != 0) {
auto e = par[u[i]];
if (e.color == x[i])
ans += y[i];
else
ans += e.cost;
u[i] = e.from;
}
while (v[i] != lca && dist[v[i]] % B != 0) {
auto e = par[v[i]];
if (e.color == x[i])
ans += y[i];
else
ans += e.cost;
v[i] = e.from;
}
ans += depth[u[i]] + depth[v[i]] - 2 * depth[lca];
ans -= sum[u[i]][x[i]] + sum[v[i]][x[i]] - 2 * sum[lca][x[i]];
ans += y[i] * (cnt[u[i]][x[i]] + cnt[v[i]][x[i]] - 2 * cnt[lca][x[i]]);
OUT(ans) BR;
}
return 0;
} | // need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// etc
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
#define SHOWSTACK(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.top() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define random_shuffle "USE std::shuffle!";
// type/const
// #define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = (1 << 30) - 1; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-10;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
struct Edge {
int from, to, cost, color;
};
struct EulerTour {
std::vector<int> eulerTour, begin, end;
int n, k;
// 頂点vを根とする木gのオイラーツアー
EulerTour(const std::vector<std::vector<Edge>> &g, int v)
: n(g.size()), k(0) {
begin.resize(n, 0);
end.resize(n, 0);
createEulerTour(g, v, -1);
}
// 頂点vを根とする木gのオイラーツアーを構成する
void createEulerTour(const std::vector<std::vector<Edge>> &g, int v,
int par) {
begin[v] = k++;
eulerTour.emplace_back(v);
for (auto e : g[v]) {
if (e.to == par)
continue;
createEulerTour(g, e.to, v);
eulerTour.emplace_back(v);
k++;
}
end[v] = k;
}
};
template <class T> class SparseTable {
size_t N;
std::vector<T> a;
std::vector<size_t> logTable;
std::vector<std::vector<T>> table;
public:
SparseTable(const std::vector<T> &_a) : N(_a.size()), a(_a) {
logTable.resize(N + 1, 0);
for (size_t i = 2; i <= N; ++i) {
logTable[i] = logTable[i >> 1] + 1;
}
table.resize(logTable[N] + 1, std::vector<T>(N));
for (size_t i = 0; i < N; ++i)
table[0][i] = a[i];
for (size_t k = 1; k <= logTable[N]; ++k) {
for (size_t i = 0; i + (1 << k) <= N; ++i) {
table[k][i] =
std::min(table[k - 1][i], table[k - 1][i + (1 << (k - 1))]);
}
}
}
// query in [l, r)
inline T query(int l, int r) {
int lg = logTable[r - l];
return std::min(table[lg][l], table[lg][r - (1 << lg)]);
}
};
constexpr int B = 333;
signed main() {
INIT;
VAR(int, n, Q);
VEC_ROW(int, n - 1, a, b, c, d);
VEC_ROW(int, Q, x, y, u, v);
REP(i, Q)-- x[i], --u[i], --v[i];
std::vector<std::vector<Edge>> g(n);
REP(i, n - 1) {
--a[i];
--b[i];
--c[i];
g[a[i]].emplace_back(Edge{a[i], b[i], d[i], c[i]});
g[b[i]].emplace_back(Edge{b[i], a[i], d[i], c[i]});
}
std::vector<int> depth(n, 0), dist(n, 0);
std::vector<Edge> par(n);
{
auto rec = [&](auto &&f, int v, int para) -> void {
for (auto &e : g[v])
if (e.to != para) {
depth[e.to] = depth[v] + 1;
dist[e.to] = dist[v] + e.cost;
par[e.to] = e;
f(f, e.to, v);
}
};
rec(rec, 0, -1);
}
EulerTour et(g, 0);
std::vector<PAIR> for_sparse_table(et.eulerTour.size());
REP(i, et.eulerTour.size()) {
int v = et.eulerTour[i];
for_sparse_table[i] = PAIR(depth[v], v);
}
SparseTable<PAIR> st(for_sparse_table);
VV<int> sum(n), cnt(n);
{
auto rec = [&](auto &&f, int v, int par, std::vector<int> &tsum,
std::vector<int> &tcnt) -> void {
if (depth[v] % B == 0) {
sum[v] = tsum;
cnt[v] = tcnt;
}
for (auto &e : g[v])
if (e.to != par) {
tsum[e.color] += e.cost;
++tcnt[e.color];
f(f, e.to, v, tsum, tcnt);
tsum[e.color] -= e.cost;
--tcnt[e.color];
}
};
V<int> tsum(n, 0), tcnt(n, 0);
rec(rec, 0, -1, tsum, tcnt);
}
REP(i, Q) {
PAIR lcap;
{
int l = et.begin[u[i]], r = et.begin[v[i]];
if (l > r)
std::swap(l, r);
lcap = st.query(l, r);
}
int lca = lcap.second;
auto calc = [&](int p) {
int res = 0;
while (depth[p] % B != 0) {
auto e = par[p];
if (e.color == x[i])
res += y[i];
else
res += e.cost;
p = e.from;
}
res += dist[p];
res -= sum[p][x[i]];
res += cnt[p][x[i]] * y[i];
return res;
};
int ans = calc(u[i]) + calc(v[i]) - 2 * calc(lca);
OUT(ans) BR;
}
return 0;
} | replace | 312 | 332 | 312 | 329 | 0 | |
p02986 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
const int MAXN = 1e5 + 5;
map<int, pair<int, int>> curColours;
vector<map<int, pair<int, int>>> colourData;
vector<pair<int, int>> v1[MAXN];
int level[MAXN];
int parent[MAXN];
int parentedge[MAXN];
int dist[MAXN];
vector<pair<int, int>> edgedata;
int dp[MAXN][24];
bool special[MAXN];
bool checkedi[MAXN];
void dfs1(int curr, int par) {
for (auto z : v1[curr]) {
int x = z.first;
if (x == par) {
continue;
}
level[x] = level[curr] + 1;
parent[x] = curr;
parentedge[x] = z.second;
dist[x] = dist[curr] + edgedata[parentedge[x]].second;
dfs1(x, curr);
}
}
void dfs2(int curr, int par) {
if (special[curr]) {
colourData[curr] = curColours;
}
for (auto x : v1[curr]) {
if (x.first == par) {
continue;
}
int ind = x.second;
// cout<<curr<<" "<<x.first<<" "<<ind<<endl;
int col = edgedata[ind].first;
int dist = edgedata[ind].second;
if (!curColours.count(col)) {
curColours.insert(make_pair(col, make_pair(0, 0)));
}
curColours[col].first++;
curColours[col].second += dist;
dfs2(x.first, curr);
curColours[col].first--;
curColours[col].second -= dist;
if (curColours[col].first == 0) {
curColours.erase(col);
}
}
}
int lca(int u, int v) {
if (level[u] < level[v]) {
swap(u, v);
}
for (int i = 20; i >= 0; i--) {
if (level[u] - (1 << i) >= level[v]) {
u = dp[u][i];
}
}
if (u == v) {
return u;
}
for (int i = 20; i >= 0; i--) {
if (dp[u][i] != dp[v][i] && dp[u][i] != -1 && dp[v][i] != -1) {
u = dp[u][i];
v = dp[v][i];
}
}
return parent[u];
}
pair<int, int> getdata(int v, int colour) {
if (v == -1) {
cout << 1234567 << endl;
return make_pair(0, 0);
}
// cout<<v<<" "<<parent[v]<<" "<<special[v]<<endl;
if (special[v]) {
if (!colourData[v].count(colour)) {
return make_pair(0, 0);
} else {
return colourData[v][colour];
}
}
pair<int, int> prev = getdata(parent[v], colour);
int ind = parentedge[v];
if (edgedata[ind].first == colour) {
prev.first++;
prev.second += edgedata[ind].second;
}
return prev;
}
int rootdist(int curr, pair<int, int> data, int newLen) {
return dist[curr] - data.second + (data.first * newLen);
}
int main() {
int n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
edgedata.push_back(make_pair(c, d));
v1[a].push_back(make_pair(b, i));
v1[b].push_back(make_pair(a, i));
}
parent[1] = -1;
level[1] = 0;
dist[1] = 0;
dfs1(1, -1);
priority_queue<pair<int, int>> pq;
for (int i = 1; i <= n; i++) {
pq.push(make_pair(level[i], i));
}
for (int i = 0; i <= n; i++) {
special[i] = false;
checkedi[i] = false;
}
int cnt = 1;
special[1] = true;
checkedi[1] = true;
while (!pq.empty()) {
int curr = pq.top().second;
pq.pop();
if (checkedi[curr]) {
continue;
}
for (int i = 0; i < 350; i++) {
curr = parent[curr];
if (special[curr]) {
break;
}
checkedi[curr] = true;
}
special[curr] = true;
}
for (int i = 0; i <= n; i++) {
map<int, pair<int, int>> blank;
colourData.push_back(blank);
}
dfs2(1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 20; j++) {
dp[i][j] = -1;
}
}
for (int i = 1; i <= n; i++) {
dp[i][0] = parent[i];
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= n; i++) {
if (dp[i][j - 1] == -1) {
dp[i][j] = -1;
} else {
dp[i][j] = max(dp[i][j], dp[dp[i][j - 1]][j - 1]);
}
}
}
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int e = lca(c, d);
// cout<<e<<endl;
cout << rootdist(c, getdata(c, a), b) + rootdist(d, getdata(d, a), b) -
2 * rootdist(e, getdata(e, a), b)
<< "\n";
}
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
const int MAXN = 1e5 + 5;
map<int, pair<int, int>> curColours;
vector<map<int, pair<int, int>>> colourData;
vector<pair<int, int>> v1[MAXN];
int level[MAXN];
int parent[MAXN];
int parentedge[MAXN];
int dist[MAXN];
vector<pair<int, int>> edgedata;
int dp[MAXN][24];
bool special[MAXN];
bool checkedi[MAXN];
void dfs1(int curr, int par) {
for (auto z : v1[curr]) {
int x = z.first;
if (x == par) {
continue;
}
level[x] = level[curr] + 1;
parent[x] = curr;
parentedge[x] = z.second;
dist[x] = dist[curr] + edgedata[parentedge[x]].second;
dfs1(x, curr);
}
}
void dfs2(int curr, int par) {
if (special[curr]) {
colourData[curr] = curColours;
}
for (auto x : v1[curr]) {
if (x.first == par) {
continue;
}
int ind = x.second;
// cout<<curr<<" "<<x.first<<" "<<ind<<endl;
int col = edgedata[ind].first;
int dist = edgedata[ind].second;
if (!curColours.count(col)) {
curColours.insert(make_pair(col, make_pair(0, 0)));
}
curColours[col].first++;
curColours[col].second += dist;
dfs2(x.first, curr);
curColours[col].first--;
curColours[col].second -= dist;
if (curColours[col].first == 0) {
curColours.erase(col);
}
}
}
int lca(int u, int v) {
if (level[u] < level[v]) {
swap(u, v);
}
for (int i = 20; i >= 0; i--) {
if (level[u] - (1 << i) >= level[v]) {
u = dp[u][i];
}
}
if (u == v) {
return u;
}
for (int i = 20; i >= 0; i--) {
if (dp[u][i] != dp[v][i] && dp[u][i] != -1 && dp[v][i] != -1) {
u = dp[u][i];
v = dp[v][i];
}
}
return parent[u];
}
pair<int, int> getdata(int v, int colour) {
if (v == -1) {
cout << 1234567 << endl;
return make_pair(0, 0);
}
// cout<<v<<" "<<parent[v]<<" "<<special[v]<<endl;
if (special[v]) {
if (!colourData[v].count(colour)) {
return make_pair(0, 0);
} else {
return colourData[v][colour];
}
}
pair<int, int> prev = getdata(parent[v], colour);
int ind = parentedge[v];
if (edgedata[ind].first == colour) {
prev.first++;
prev.second += edgedata[ind].second;
}
return prev;
}
int rootdist(int curr, pair<int, int> data, int newLen) {
return dist[curr] - data.second + (data.first * newLen);
}
int main() {
int n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
edgedata.push_back(make_pair(c, d));
v1[a].push_back(make_pair(b, i));
v1[b].push_back(make_pair(a, i));
}
parent[1] = -1;
level[1] = 0;
dist[1] = 0;
dfs1(1, -1);
priority_queue<pair<int, int>> pq;
for (int i = 1; i <= n; i++) {
pq.push(make_pair(level[i], i));
}
for (int i = 0; i <= n; i++) {
special[i] = false;
checkedi[i] = false;
}
int cnt = 1;
special[1] = true;
checkedi[1] = true;
while (!pq.empty()) {
int curr = pq.top().second;
pq.pop();
if (checkedi[curr]) {
continue;
}
for (int i = 0; i < 350; i++) {
curr = parent[curr];
if (special[curr]) {
break;
}
checkedi[curr] = true;
}
special[curr] = true;
}
for (int i = 0; i <= n; i++) {
map<int, pair<int, int>> blank;
colourData.push_back(blank);
}
dfs2(1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 20; j++) {
dp[i][j] = -1;
}
}
for (int i = 1; i <= n; i++) {
dp[i][0] = parent[i];
}
for (int j = 1; j <= 20; j++) {
for (int i = 1; i <= n; i++) {
if (dp[i][j - 1] == -1) {
dp[i][j] = -1;
} else {
dp[i][j] = max(dp[i][j], dp[dp[i][j - 1]][j - 1]);
}
}
}
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int e = lca(c, d);
// cout<<e<<endl;
cout << rootdist(c, getdata(c, a), b) + rootdist(d, getdata(d, a), b) -
2 * rootdist(e, getdata(e, a), b)
<< "\n";
}
} | replace | 165 | 166 | 165 | 166 | TLE | |
p02986 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
using namespace std;
#define N 100005
int st[N], nd[N], a[N];
int pos[N], dfn[2 * N], cnt, sum[N][2], s1;
int fa[N][20], dep[N], ans[N], n, m, an;
int g1[N][2];
bool f[N];
struct mzls {
int l, r, id, aa, bb;
bool p;
} a1[N];
struct node {
int to, co, ct;
node() {}
node(int xx, int yy, int zz) { to = xx, co = yy, ct = zz; }
};
vector<node> g[N];
bool operator<(mzls a, mzls b) {
return pos[a.l] == pos[b.l] ? a.r < b.r : a.l < b.l;
}
inline void dfs(int x) {
dfn[++cnt] = x;
st[x] = cnt;
dep[x] = dep[fa[x][0]] + 1;
for (int i = 1; i < 20; i++)
fa[x][i] = fa[fa[x][i - 1]][i - 1];
int l1 = g[x].size();
for (int i = 0; i < l1; i++) {
int v = g[x][i].to, co = g[x][i].co, ct = g[x][i].ct;
if (v == fa[x][0])
continue;
fa[v][0] = x;
g1[v][0] = co, g1[v][1] = ct;
dfs(v);
}
dfn[++cnt] = x;
nd[x] = cnt;
}
inline int LCA(int x, int y) {
if (dep[x] < dep[y])
swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y])
x = fa[x][i];
if (x == y)
return x;
for (int i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
inline void modify(int x) {
if (!f[x]) {
sum[g1[x][0]][0]++;
sum[g1[x][0]][1] += g1[x][1];
s1 += g1[x][1];
f[x] = 1;
} else {
sum[g1[x][0]][0]--;
sum[g1[x][0]][1] -= g1[x][1];
s1 -= g1[x][1];
f[x] = 0;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y, x1, y1;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
g[x].push_back(node(y, x1, y1));
g[y].push_back(node(x, x1, y1));
}
dfs(1);
int d = sqrt(n);
for (int i = 1; i <= n; i++)
pos[i] = i / d;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d%d%d", &a1[i].aa, &a1[i].bb, &a1[i].l, &a1[i].r);
int lc = LCA(a1[i].l, a1[i].r);
if (lc == a1[i].l || lc == a1[i].r) {
if (lc == a1[i].r)
swap(a1[i].l, a1[i].r);
x = st[a1[i].l] + 1;
y = st[a1[i].r];
a1[i].p = 0;
} else {
if (st[a1[i].l] > st[a1[i].r])
swap(a1[i].l, a1[i].r);
x = nd[a1[i].l];
y = st[a1[i].r];
a1[i].p = 1;
}
a1[i].l = x;
a1[i].r = y;
a1[i].id = i;
}
sort(a1 + 1, a1 + m + 1);
int l1 = 1, r1 = 0;
for (int i = 1; i <= m; i++) {
while (l1 > a1[i].l)
modify(dfn[--l1]);
while (l1 < a1[i].l)
modify(dfn[l1++]);
while (r1 < a1[i].r)
modify(dfn[++r1]);
while (r1 > a1[i].r)
modify(dfn[r1--]);
// int lc=LCA(dfn[l1],dfn[r1]);
// if(a1[i].p)
// modify(lc);
ans[a1[i].id] = s1 - sum[a1[i].aa][1] + sum[a1[i].aa][0] * a1[i].bb;
// if(a1[i].p)
// modify(lc);
}
for (int i = 1; i <= m; i++)
printf("%d\n", ans[i]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
using namespace std;
#define N 100005
int st[N], nd[N], a[N];
int pos[N], dfn[2 * N], cnt, sum[N][2], s1;
int fa[N][20], dep[N], ans[N], n, m, an;
int g1[N][2];
bool f[N];
struct mzls {
int l, r, id, aa, bb;
bool p;
} a1[N];
struct node {
int to, co, ct;
node() {}
node(int xx, int yy, int zz) { to = xx, co = yy, ct = zz; }
};
vector<node> g[N];
bool operator<(mzls a, mzls b) {
return pos[a.l] == pos[b.l] ? a.r < b.r : a.l < b.l;
}
inline void dfs(int x) {
dfn[++cnt] = x;
st[x] = cnt;
dep[x] = dep[fa[x][0]] + 1;
for (int i = 1; i < 20; i++)
fa[x][i] = fa[fa[x][i - 1]][i - 1];
int l1 = g[x].size();
for (int i = 0; i < l1; i++) {
int v = g[x][i].to, co = g[x][i].co, ct = g[x][i].ct;
if (v == fa[x][0])
continue;
fa[v][0] = x;
g1[v][0] = co, g1[v][1] = ct;
dfs(v);
}
dfn[++cnt] = x;
nd[x] = cnt;
}
inline int LCA(int x, int y) {
if (dep[x] < dep[y])
swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y])
x = fa[x][i];
if (x == y)
return x;
for (int i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
inline void modify(int x) {
if (!f[x]) {
sum[g1[x][0]][0]++;
sum[g1[x][0]][1] += g1[x][1];
s1 += g1[x][1];
f[x] = 1;
} else {
sum[g1[x][0]][0]--;
sum[g1[x][0]][1] -= g1[x][1];
s1 -= g1[x][1];
f[x] = 0;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y, x1, y1;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
g[x].push_back(node(y, x1, y1));
g[y].push_back(node(x, x1, y1));
}
dfs(1);
int d = sqrt(n);
for (int i = 1; i <= 2 * n; i++)
pos[i] = i / d;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d%d%d", &a1[i].aa, &a1[i].bb, &a1[i].l, &a1[i].r);
int lc = LCA(a1[i].l, a1[i].r);
if (lc == a1[i].l || lc == a1[i].r) {
if (lc == a1[i].r)
swap(a1[i].l, a1[i].r);
x = st[a1[i].l] + 1;
y = st[a1[i].r];
a1[i].p = 0;
} else {
if (st[a1[i].l] > st[a1[i].r])
swap(a1[i].l, a1[i].r);
x = nd[a1[i].l];
y = st[a1[i].r];
a1[i].p = 1;
}
a1[i].l = x;
a1[i].r = y;
a1[i].id = i;
}
sort(a1 + 1, a1 + m + 1);
int l1 = 1, r1 = 0;
for (int i = 1; i <= m; i++) {
while (l1 > a1[i].l)
modify(dfn[--l1]);
while (l1 < a1[i].l)
modify(dfn[l1++]);
while (r1 < a1[i].r)
modify(dfn[++r1]);
while (r1 > a1[i].r)
modify(dfn[r1--]);
// int lc=LCA(dfn[l1],dfn[r1]);
// if(a1[i].p)
// modify(lc);
ans[a1[i].id] = s1 - sum[a1[i].aa][1] + sum[a1[i].aa][0] * a1[i].bb;
// if(a1[i].p)
// modify(lc);
}
for (int i = 1; i <= m; i++)
printf("%d\n", ans[i]);
return 0;
} | replace | 80 | 81 | 80 | 81 | TLE | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct disjoint_set {
vector<int> p;
disjoint_set(int n) : p(n, -1) {}
int root(int u) { return p[u] < 0 ? u : p[u] = root(p[u]); }
bool merge(int u, int v) {
if ((u = root(u)) == (v = root(v)))
return false;
if (p[u] > p[v])
swap(u, v);
p[u] += p[v];
p[v] = u;
return true;
}
};
vector<int> lca_offline(const vector<vector<int>> &tree, int root,
const vector<pair<int, int>> &queries) {
const int n = tree.size();
vector<vector<int>> queries_id(n);
for (int i = 0; i < (int)queries.size(); ++i) {
queries_id[queries[i].first].emplace_back(i);
if (queries[i].first != queries[i].second)
queries_id[queries[i].second].emplace_back(i);
}
vector<int> anc(n), color(n), ans(queries.size());
disjoint_set ds(n);
function<void(int)> dfs = [&](int u) {
anc[u] = u;
color[u] = -1;
for (int v : tree[u])
if (!color[v]) {
dfs(v);
ds.merge(u, v);
anc[ds.root(u)] = u;
}
color[u] = 1;
for (int q : queries_id[u]) {
int other = queries[q].first + queries[q].second - u;
if (color[other] == 1)
ans[q] = anc[ds.root(other)];
}
};
dfs(root);
return ans;
}
int main() {
#ifdef jcg
assert(freopen("input.in", "r", stdin));
// assert(freopen("output.out", "w", stdout));
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, Q;
cin >> N >> Q;
vector<int> a(N - 1), b(N - 1), c(N - 1), d(N - 1);
for (int i = 0; i < N - 1; ++i) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
--a[i], --b[i];
}
vector<int> x(Q), y(Q), u(Q), v(Q);
for (int i = 0; i < Q; ++i) {
cin >> x[i] >> y[i] >> u[i] >> v[i];
--u[i], --v[i];
}
vector<int> lca;
{
vector<vector<int>> g(N);
vector<pair<int, int>> lca_queries;
for (int i = 0; i < N - 1; ++i) {
g[a[i]].emplace_back(b[i]);
g[b[i]].emplace_back(a[i]);
}
for (int i = 0; i < Q; ++i)
lca_queries.emplace_back(u[i], v[i]);
lca = lca_offline(g, 0, lca_queries);
}
vector<pair<int, int>> queries;
vector<vector<int>> queries_id(N);
for (int i = 0; i < Q; ++i) {
queries_id[u[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
queries_id[v[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
queries_id[lca[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
}
vector<vector<tuple<int, int, int>>> tree(N);
for (int i = 0; i < N - 1; ++i) {
tree[a[i]].emplace_back(b[i], c[i], d[i]);
tree[b[i]].emplace_back(a[i], c[i], d[i]);
}
vector<int> ans(Q), color_sum(N), freq(N);
function<void(int, int, int)> dfs = [&](int u, int p, int d) {
for (int q : queries_id[u]) {
int xq, yq;
tie(xq, yq) = queries[q];
ans[q] = d + freq[xq] * yq - color_sum[xq];
}
for (auto e : tree[u]) {
int v, xe, ye;
tie(v, xe, ye) = e;
if (v == p)
continue;
++freq[xe];
color_sum[xe] += ye;
dfs(v, u, d + ye);
--freq[xe];
color_sum[xe] -= ye;
}
};
dfs(0, 0, 0);
for (int i = 0; i < 3 * Q; i += 3)
cout << (ans[i] - ans[i + 2]) + (ans[i + 1] - ans[i + 2]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct disjoint_set {
vector<int> p;
disjoint_set(int n) : p(n, -1) {}
int root(int u) { return p[u] < 0 ? u : p[u] = root(p[u]); }
bool merge(int u, int v) {
if ((u = root(u)) == (v = root(v)))
return false;
if (p[u] > p[v])
swap(u, v);
p[u] += p[v];
p[v] = u;
return true;
}
};
vector<int> lca_offline(const vector<vector<int>> &tree, int root,
const vector<pair<int, int>> &queries) {
const int n = tree.size();
vector<vector<int>> queries_id(n);
for (int i = 0; i < (int)queries.size(); ++i) {
queries_id[queries[i].first].emplace_back(i);
if (queries[i].first != queries[i].second)
queries_id[queries[i].second].emplace_back(i);
}
vector<int> anc(n), color(n), ans(queries.size());
disjoint_set ds(n);
function<void(int)> dfs = [&](int u) {
anc[u] = u;
color[u] = -1;
for (int v : tree[u])
if (!color[v]) {
dfs(v);
ds.merge(u, v);
anc[ds.root(u)] = u;
}
color[u] = 1;
for (int q : queries_id[u]) {
int other = queries[q].first + queries[q].second - u;
if (color[other] == 1)
ans[q] = anc[ds.root(other)];
}
};
dfs(root);
return ans;
}
int main() {
#ifdef jcg
assert(freopen("input.in", "r", stdin));
// assert(freopen("output.out", "w", stdout));
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, Q;
cin >> N >> Q;
vector<int> a(N - 1), b(N - 1), c(N - 1), d(N - 1);
for (int i = 0; i < N - 1; ++i) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
--a[i], --b[i];
}
vector<int> x(Q), y(Q), u(Q), v(Q);
for (int i = 0; i < Q; ++i) {
cin >> x[i] >> y[i] >> u[i] >> v[i];
--u[i], --v[i];
}
vector<int> lca;
{
vector<vector<int>> g(N);
vector<pair<int, int>> lca_queries;
for (int i = 0; i < N - 1; ++i) {
g[a[i]].emplace_back(b[i]);
g[b[i]].emplace_back(a[i]);
}
for (int i = 0; i < Q; ++i)
lca_queries.emplace_back(u[i], v[i]);
lca = lca_offline(g, 0, lca_queries);
}
vector<pair<int, int>> queries;
vector<vector<int>> queries_id(N);
for (int i = 0; i < Q; ++i) {
queries_id[u[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
queries_id[v[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
queries_id[lca[i]].emplace_back(queries.size());
queries.emplace_back(x[i], y[i]);
}
vector<vector<tuple<int, int, int>>> tree(N);
for (int i = 0; i < N - 1; ++i) {
tree[a[i]].emplace_back(b[i], c[i], d[i]);
tree[b[i]].emplace_back(a[i], c[i], d[i]);
}
vector<int> ans(3 * Q), color_sum(N), freq(N);
function<void(int, int, int)> dfs = [&](int u, int p, int d) {
for (int q : queries_id[u]) {
int xq, yq;
tie(xq, yq) = queries[q];
ans[q] = d + freq[xq] * yq - color_sum[xq];
}
for (auto e : tree[u]) {
int v, xe, ye;
tie(v, xe, ye) = e;
if (v == p)
continue;
++freq[xe];
color_sum[xe] += ye;
dfs(v, u, d + ye);
--freq[xe];
color_sum[xe] -= ye;
}
};
dfs(0, 0, 0);
for (int i = 0; i < 3 * Q; i += 3)
cout << (ans[i] - ans[i + 2]) + (ans[i + 1] - ans[i + 2]) << endl;
return 0;
}
| replace | 110 | 111 | 110 | 111 | 0 | |
p02986 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
const int K = 20;
const int N = 100 + 9;
struct Query {
int v;
int c;
int color;
int index;
Query(int v_, int c_, int color_, int index_) {
v = v_;
c = c_;
color = color_;
index = index_;
}
};
vector<tuple<int, int, int>> g[N];
int cnt[N];
int sm[N];
int cans[N];
int qcnt[N];
int qsm[N];
int qd[N];
vector<Query> q[N];
void dfs(int cur, int p) {
for (auto qr : q[cur]) {
qcnt[qr.index] += qr.c * cnt[qr.color];
qsm[qr.index] += qr.c * sm[qr.color];
}
for (auto t : g[cur]) {
int u, cl, w;
tie(u, cl, w) = t;
if (u != p) {
cnt[cl]++;
sm[cl] += w;
dfs(u, cur);
cnt[cl]--;
sm[cl] -= w;
}
}
}
int alls[N];
int pr[N];
int up[K][N];
int tin[N];
int tout[N];
int timer = 0;
void jfs(int cur, int p, int len) {
tin[cur] = timer++;
pr[cur] = p;
alls[cur] = len;
for (auto t : g[cur]) {
int u, cl, w;
tie(u, cl, w) = t;
if (u != p) {
jfs(u, cur, len + w);
}
}
tout[cur] = timer++;
}
void init(int n) {
for (int i = 0; i < n; i++) {
up[0][i] = pr[i];
}
for (int i = 0; i + 1 < K; i++) {
for (int j = 0; j < n; j++) {
int mid = up[i][j];
if (mid == -1) {
up[i + 1][j] = mid;
} else {
up[i + 1][j] = up[i][mid];
}
}
}
}
int anc(int u, int v) { return tin[u] <= tin[v] && tout[v] <= tout[u]; }
int lca(int u, int v) {
if (anc(u, v)) {
return u;
} else if (anc(v, u)) {
return v;
} else {
for (int i = K - 1; i >= 0; i--) {
if (up[i][u] != -1 && !anc(up[i][u], v)) {
u = up[i][u];
}
}
return pr[u];
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, qc;
cin >> n >> qc;
for (int i = 0; i + 1 < n; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
u--, v--;
g[u].push_back(make_tuple(v, c, w));
g[v].push_back(make_tuple(u, c, w));
}
jfs(0, -1, 0);
init(n);
for (int i = 0; i < qc; i++) {
int cl, nd, u, v;
cin >> cl >> nd >> u >> v;
u--, v--;
q[u].push_back(Query(u, 1, cl, i));
q[v].push_back(Query(v, 1, cl, i));
int l = lca(u, v);
q[l].push_back(Query(l, -2, cl, i));
qd[i] = nd;
cans[i] = alls[u] + alls[v] - 2 * alls[l];
}
dfs(0, -1);
for (int i = 0; i < qc; i++) {
cans[i] -= qsm[i];
cans[i] += qcnt[i] * qd[i];
cout << cans[i] << '\n';
}
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
const int K = 20;
const int N = 1e5 + 9;
struct Query {
int v;
int c;
int color;
int index;
Query(int v_, int c_, int color_, int index_) {
v = v_;
c = c_;
color = color_;
index = index_;
}
};
vector<tuple<int, int, int>> g[N];
int cnt[N];
int sm[N];
int cans[N];
int qcnt[N];
int qsm[N];
int qd[N];
vector<Query> q[N];
void dfs(int cur, int p) {
for (auto qr : q[cur]) {
qcnt[qr.index] += qr.c * cnt[qr.color];
qsm[qr.index] += qr.c * sm[qr.color];
}
for (auto t : g[cur]) {
int u, cl, w;
tie(u, cl, w) = t;
if (u != p) {
cnt[cl]++;
sm[cl] += w;
dfs(u, cur);
cnt[cl]--;
sm[cl] -= w;
}
}
}
int alls[N];
int pr[N];
int up[K][N];
int tin[N];
int tout[N];
int timer = 0;
void jfs(int cur, int p, int len) {
tin[cur] = timer++;
pr[cur] = p;
alls[cur] = len;
for (auto t : g[cur]) {
int u, cl, w;
tie(u, cl, w) = t;
if (u != p) {
jfs(u, cur, len + w);
}
}
tout[cur] = timer++;
}
void init(int n) {
for (int i = 0; i < n; i++) {
up[0][i] = pr[i];
}
for (int i = 0; i + 1 < K; i++) {
for (int j = 0; j < n; j++) {
int mid = up[i][j];
if (mid == -1) {
up[i + 1][j] = mid;
} else {
up[i + 1][j] = up[i][mid];
}
}
}
}
int anc(int u, int v) { return tin[u] <= tin[v] && tout[v] <= tout[u]; }
int lca(int u, int v) {
if (anc(u, v)) {
return u;
} else if (anc(v, u)) {
return v;
} else {
for (int i = K - 1; i >= 0; i--) {
if (up[i][u] != -1 && !anc(up[i][u], v)) {
u = up[i][u];
}
}
return pr[u];
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, qc;
cin >> n >> qc;
for (int i = 0; i + 1 < n; i++) {
int u, v, c, w;
cin >> u >> v >> c >> w;
u--, v--;
g[u].push_back(make_tuple(v, c, w));
g[v].push_back(make_tuple(u, c, w));
}
jfs(0, -1, 0);
init(n);
for (int i = 0; i < qc; i++) {
int cl, nd, u, v;
cin >> cl >> nd >> u >> v;
u--, v--;
q[u].push_back(Query(u, 1, cl, i));
q[v].push_back(Query(v, 1, cl, i));
int l = lca(u, v);
q[l].push_back(Query(l, -2, cl, i));
qd[i] = nd;
cans[i] = alls[u] + alls[v] - 2 * alls[l];
}
dfs(0, -1);
for (int i = 0; i < qc; i++) {
cans[i] -= qsm[i];
cans[i] += qcnt[i] * qd[i];
cout << cans[i] << '\n';
}
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02986 | C++ | Runtime Error | #include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
class Edge {
public:
explicit Edge(int src, int dst, int color, int len)
: src(src), dst(dst), color(color), len(len) {}
int src, dst, color, len;
};
class Query {
public:
explicit Query(int x, int y, int u, int v)
: x(x), y(y), u(u), v(v), lca(-1) {}
int x, y, u, v, lca;
};
class Solver {
public:
explicit Solver(int N) : parents(N), depth(N), dist(N), needs(N), info(N) {}
void makeParents(const vector<vector<Edge>> &g) { travel(g, 0, -1); }
void readQueries(const vector<Query> &query) {
for (auto &q : query) {
int lca = getLCA(q.u, q.v);
needs[q.u].insert(q.x);
needs[q.v].insert(q.x);
needs[lca].insert(q.x);
}
}
void prepare(const vector<vector<Edge>> &g) {
vector<pair<int, int>> colors(g.size(), make_pair(0, 0));
prepareImpl_(g, 0, -1, 0, colors);
}
void solve(const vector<Query> &query) {
for (auto &q : query) {
int lca = getLCA(q.u, q.v);
int d = dist[q.u] + dist[q.v] - 2 * dist[lca];
int num = info[q.u][q.x].first + info[q.v][q.x].first -
2 * info[lca][q.x].first;
int pd = info[q.u][q.x].second + info[q.v][q.x].second -
2 * info[lca][q.x].second;
cout << (d - pd + num * q.y) << endl;
}
}
private:
void travel(const vector<vector<Edge>> &g, int pos, int prev) {
depth[pos] = (prev == -1 ? 0 : depth[prev] + 1);
int check = prev;
while (check != -1) {
parents[pos].push_back(check);
if (parents[check].size() <= parents[pos].size())
break;
check = parents[check][parents[pos].size() - 1];
}
for (auto &e : g[pos]) {
if (e.dst == prev)
continue;
travel(g, e.dst, pos);
}
}
void prepareImpl_(const vector<vector<Edge>> &g, int pos, int prev, int d,
vector<pair<int, int>> &colors) {
dist[pos] = d;
for (auto t : needs[pos]) {
info[pos][t] = colors[t];
}
for (auto &e : g[pos]) {
if (e.dst == prev)
continue;
++colors[e.color].first;
colors[e.color].second += e.len;
prepareImpl_(g, e.dst, pos, d + e.len, colors);
--colors[e.color].first;
colors[e.color].second -= e.len;
}
}
int toParents(int pos, int step) {
for (int d = 0; step; d++) {
if (step % 2)
pos = parents[pos][d];
step /= 2;
}
return pos;
}
int getLCA(int a, int b) {
if (depth[a] > depth[b])
swap(a, b);
b = toParents(b, depth[b] - depth[a]);
if (a == b)
return a;
for (int i = parents[a].size() - 1; i >= 0; i--) {
if (parents[a].size() <= i)
continue;
if (parents[a][i] != parents[b][i]) {
a = parents[a][i];
b = parents[b][i];
}
}
return parents[a][0];
}
private:
vector<vector<int>> parents;
vector<int> depth;
vector<int> dist;
vector<set<int>> needs;
vector<map<int, pair<int, int>>> info;
};
int main() {
int N, Q;
while (cin >> N >> Q) {
vector<vector<Edge>> g(N);
for (int i = 0; i < N - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
--a;
--b;
g[a].emplace_back(a, b, c, d);
g[b].emplace_back(b, a, c, d);
}
vector<Query> query;
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
--u;
--v;
query.emplace_back(x, y, u, v);
}
Solver solver(N);
solver.makeParents(g);
solver.readQueries(query);
solver.prepare(g);
solver.solve(query);
}
} | #include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
class Edge {
public:
explicit Edge(int src, int dst, int color, int len)
: src(src), dst(dst), color(color), len(len) {}
int src, dst, color, len;
};
class Query {
public:
explicit Query(int x, int y, int u, int v)
: x(x), y(y), u(u), v(v), lca(-1) {}
int x, y, u, v, lca;
};
class Solver {
public:
explicit Solver(int N) : parents(N), depth(N), dist(N), needs(N), info(N) {}
void makeParents(const vector<vector<Edge>> &g) { travel(g, 0, -1); }
void readQueries(const vector<Query> &query) {
for (auto &q : query) {
int lca = getLCA(q.u, q.v);
needs[q.u].insert(q.x);
needs[q.v].insert(q.x);
needs[lca].insert(q.x);
}
}
void prepare(const vector<vector<Edge>> &g) {
vector<pair<int, int>> colors(g.size(), make_pair(0, 0));
prepareImpl_(g, 0, -1, 0, colors);
}
void solve(const vector<Query> &query) {
for (auto &q : query) {
int lca = getLCA(q.u, q.v);
int d = dist[q.u] + dist[q.v] - 2 * dist[lca];
int num = info[q.u][q.x].first + info[q.v][q.x].first -
2 * info[lca][q.x].first;
int pd = info[q.u][q.x].second + info[q.v][q.x].second -
2 * info[lca][q.x].second;
cout << (d - pd + num * q.y) << endl;
}
}
private:
void travel(const vector<vector<Edge>> &g, int pos, int prev) {
depth[pos] = (prev == -1 ? 0 : depth[prev] + 1);
int check = prev;
while (check != -1) {
parents[pos].push_back(check);
if (parents[check].size() < parents[pos].size())
break;
check = parents[check][parents[pos].size() - 1];
}
for (auto &e : g[pos]) {
if (e.dst == prev)
continue;
travel(g, e.dst, pos);
}
}
void prepareImpl_(const vector<vector<Edge>> &g, int pos, int prev, int d,
vector<pair<int, int>> &colors) {
dist[pos] = d;
for (auto t : needs[pos]) {
info[pos][t] = colors[t];
}
for (auto &e : g[pos]) {
if (e.dst == prev)
continue;
++colors[e.color].first;
colors[e.color].second += e.len;
prepareImpl_(g, e.dst, pos, d + e.len, colors);
--colors[e.color].first;
colors[e.color].second -= e.len;
}
}
int toParents(int pos, int step) {
for (int d = 0; step; d++) {
if (step % 2)
pos = parents[pos][d];
step /= 2;
}
return pos;
}
int getLCA(int a, int b) {
if (depth[a] > depth[b])
swap(a, b);
b = toParents(b, depth[b] - depth[a]);
if (a == b)
return a;
for (int i = parents[a].size() - 1; i >= 0; i--) {
if (parents[a].size() <= i)
continue;
if (parents[a][i] != parents[b][i]) {
a = parents[a][i];
b = parents[b][i];
}
}
return parents[a][0];
}
private:
vector<vector<int>> parents;
vector<int> depth;
vector<int> dist;
vector<set<int>> needs;
vector<map<int, pair<int, int>>> info;
};
int main() {
int N, Q;
while (cin >> N >> Q) {
vector<vector<Edge>> g(N);
for (int i = 0; i < N - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
--a;
--b;
g[a].emplace_back(a, b, c, d);
g[b].emplace_back(b, a, c, d);
}
vector<Query> query;
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
--u;
--v;
query.emplace_back(x, y, u, v);
}
Solver solver(N);
solver.makeParents(g);
solver.readQueries(query);
solver.prepare(g);
solver.solve(query);
}
} | replace | 55 | 56 | 55 | 56 | 0 | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
using ll = long long;
struct HLD {
const vector<vector<int>> &g;
vector<int> size, label, parent, head;
int k;
HLD(const vector<vector<int>> &g_)
: g(g_), size(g_.size()), label(g_.size()), parent(g_.size()),
head(g_.size()) {
dfs(0, -1);
dfs2(0, -1, 0);
}
void dfs(int u, int p) {
size[u] = 1;
for (int v : g[u])
if (v != p) {
dfs(v, u);
size[u] += size[v];
}
}
void dfs2(int u, int p, int h) {
label[u] = k++;
head[u] = h;
parent[u] = p;
for (int v : g[u])
if (v != p && size[v] * 2 > size[u])
dfs2(v, u, h);
for (int v : g[u])
if (v != p && size[v] * 2 <= size[u])
dfs2(v, u, v);
}
template <class F> void each_edge(int u, int v, F f) {
for (;;) {
if (label[u] > label[v])
swap(u, v);
if (head[u] == head[v]) {
if (label[u] + 1 <= label[v]) {
f(label[u] + 1, label[v]);
}
return;
}
f(label[head[v]], label[v]);
v = parent[head[v]];
}
}
};
struct RMQ {
int N;
vector<int> dat;
RMQ(int n) : N(n), dat(n * 2, 0) {}
void update(int k, int v) {
k += N;
dat[k] = v;
while (k > 1) {
k >>= 1;
dat[k] = dat[k * 2] + dat[k * 2 + 1];
}
}
int query(int l, int r) {
l += N;
r += N;
int res = 0;
while (l <= r) {
if ((l & 1) == 1)
res += dat[l++];
if ((r & 1) == 0)
res += dat[r--];
l >>= 1;
r >>= 1;
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<vector<int>> g(n);
struct edge {
int v, w, c;
};
vector<vector<edge>> g2(n);
rep(i, n - 1) {
int u, v, c, w;
cin >> u >> v >> c >> w;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
g2[u].push_back((edge){v, w, c});
g2[v].push_back((edge){u, w, c});
}
HLD hld(g);
vector<int> ws(n);
vector<int> cs(n);
map<int, vector<int>> mp2;
auto dfs = [&](auto dfs, int u, int p) -> void {
for (edge e : g2[u])
if (e.v != p) {
ws[e.v] = e.w;
cs[e.v] = e.c;
dfs(dfs, e.v, u);
}
};
dfs(dfs, 0, -1);
for (int i = 1; i < n; i++) {
mp2[cs[i]].push_back(i);
}
RMQ rmq(n);
for (int i = 1; i < n; i++) {
rmq.update(hld.label[i], ws[i]);
}
vector<ll> ans(q);
vector<int> xs(q), ys(q), us(q), vs(q);
rep(i, q) {
cin >> xs[i] >> ys[i] >> us[i] >> vs[i];
us[i]--;
vs[i]--;
hld.each_edge(us[i], vs[i],
[&](int l, int r) { ans[i] += rmq.query(l, r); });
}
map<int, vector<int>> mp;
rep(i, q) { mp[xs[i]].push_back(i); }
RMQ rmq2(n);
RMQ rmq3(n);
for (auto kv : mp) {
for (int i : mp2[kv.first]) {
rmq2.update(hld.label[i], ws[i]);
rmq3.update(hld.label[i], 1);
}
for (int i : kv.second) {
hld.each_edge(us[i], vs[i], [&](int l, int r) {
ans[i] -= rmq2.query(l, r);
ans[i] += rmq3.query(l, r) * ys[i];
});
}
for (int i : mp2[kv.first]) {
rmq2.update(hld.label[i], 0);
rmq3.update(hld.label[i], 0);
}
}
rep(i, q) { cout << ans[i] << '\n'; }
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n)-1; i >= 0; i--)
using namespace std;
using ll = long long;
struct HLD {
const vector<vector<int>> &g;
vector<int> size, label, parent, head;
int k;
HLD(const vector<vector<int>> &g_)
: g(g_), size(g_.size()), label(g_.size()), parent(g_.size()),
head(g_.size()) {
k = 0;
dfs(0, -1);
dfs2(0, -1, 0);
}
void dfs(int u, int p) {
size[u] = 1;
for (int v : g[u])
if (v != p) {
dfs(v, u);
size[u] += size[v];
}
}
void dfs2(int u, int p, int h) {
label[u] = k++;
head[u] = h;
parent[u] = p;
for (int v : g[u])
if (v != p && size[v] * 2 > size[u])
dfs2(v, u, h);
for (int v : g[u])
if (v != p && size[v] * 2 <= size[u])
dfs2(v, u, v);
}
template <class F> void each_edge(int u, int v, F f) {
for (;;) {
if (label[u] > label[v])
swap(u, v);
if (head[u] == head[v]) {
if (label[u] + 1 <= label[v]) {
f(label[u] + 1, label[v]);
}
return;
}
f(label[head[v]], label[v]);
v = parent[head[v]];
}
}
};
struct RMQ {
int N;
vector<int> dat;
RMQ(int n) : N(n), dat(n * 2, 0) {}
void update(int k, int v) {
k += N;
dat[k] = v;
while (k > 1) {
k >>= 1;
dat[k] = dat[k * 2] + dat[k * 2 + 1];
}
}
int query(int l, int r) {
l += N;
r += N;
int res = 0;
while (l <= r) {
if ((l & 1) == 1)
res += dat[l++];
if ((r & 1) == 0)
res += dat[r--];
l >>= 1;
r >>= 1;
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<vector<int>> g(n);
struct edge {
int v, w, c;
};
vector<vector<edge>> g2(n);
rep(i, n - 1) {
int u, v, c, w;
cin >> u >> v >> c >> w;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
g2[u].push_back((edge){v, w, c});
g2[v].push_back((edge){u, w, c});
}
HLD hld(g);
vector<int> ws(n);
vector<int> cs(n);
map<int, vector<int>> mp2;
auto dfs = [&](auto dfs, int u, int p) -> void {
for (edge e : g2[u])
if (e.v != p) {
ws[e.v] = e.w;
cs[e.v] = e.c;
dfs(dfs, e.v, u);
}
};
dfs(dfs, 0, -1);
for (int i = 1; i < n; i++) {
mp2[cs[i]].push_back(i);
}
RMQ rmq(n);
for (int i = 1; i < n; i++) {
rmq.update(hld.label[i], ws[i]);
}
vector<ll> ans(q);
vector<int> xs(q), ys(q), us(q), vs(q);
rep(i, q) {
cin >> xs[i] >> ys[i] >> us[i] >> vs[i];
us[i]--;
vs[i]--;
hld.each_edge(us[i], vs[i],
[&](int l, int r) { ans[i] += rmq.query(l, r); });
}
map<int, vector<int>> mp;
rep(i, q) { mp[xs[i]].push_back(i); }
RMQ rmq2(n);
RMQ rmq3(n);
for (auto kv : mp) {
for (int i : mp2[kv.first]) {
rmq2.update(hld.label[i], ws[i]);
rmq3.update(hld.label[i], 1);
}
for (int i : kv.second) {
hld.each_edge(us[i], vs[i], [&](int l, int r) {
ans[i] -= rmq2.query(l, r);
ans[i] += rmq3.query(l, r) * ys[i];
});
}
for (int i : mp2[kv.first]) {
rmq2.update(hld.label[i], 0);
rmq3.update(hld.label[i], 0);
}
}
rep(i, q) { cout << ans[i] << '\n'; }
} | insert | 16 | 16 | 16 | 17 | -11 | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
// #define double long double
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a); i > (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define VECCIN(x) \
for (auto &youso_ : (x)) \
cin >> youso_
#define bitcnt(x) __builtin_popcount(x)
#define lbit(x) __builtin_ffsll(x)
#define rbit(x) __builtin_clzll(x)
#define SZ(x) ((long long)(x).size())
#define fi first
#define se second
#define All(a) (a).begin(), (a).end()
#define rAll(a) (a).rbegin(), (a).rend()
#define cinfast() cin.tie(0), ios::sync_with_stdio(false)
#define PERM(c) \
sort(All(c)); \
for (bool cp = true; cp; cp = next_permutation(All(c)))
#define MKORDER(n) \
vector<int> od(n); \
iota(All(od), 0LL);
template <typename T = long long> inline T IN() {
T x;
cin >> x;
return (x);
}
inline void CIN() {}
template <class Head, class... Tail>
inline void CIN(Head &&head, Tail &&...tail) {
cin >> head;
CIN(move(tail)...);
}
#define CCIN(...) \
char __VA_ARGS__; \
CIN(__VA_ARGS__)
#define DCIN(...) \
double __VA_ARGS__; \
CIN(__VA_ARGS__)
#define LCIN(...) \
long long __VA_ARGS__; \
CIN(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CIN(__VA_ARGS__)
#define Yes(a) cout << (a ? "Yes" : "No") << "\n"
#define YES(a) cout << (a ? "YES" : "NO") << "\n"
#define Printv(v) \
{ \
FOREACH(x, v) { cout << x << " "; } \
cout << "\n"; \
}
template <typename T = string> inline void eputs(T s) {
cout << s << "\n";
exit(0);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> using PQG = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using PQ = priority_queue<T>;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<ll, ll> PL;
typedef vector<PL> VPL;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<string> VS;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD = 998244353;
const ll LINF = 1e18;
const double PI = atan(1.0) * 4.0;
const ll dw[] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dh[] = {0, 1, 1, 1, 0, -1, -1, -1};
#define PI 3.141592653589793238
ll N, M;
struct edge {
ll to, col, len;
};
vector<vector<edge>> g;
VL d;
// doubling build:n query:logn
struct LCA {
int n, h;
vector<vector<int>> G, par;
vector<int> dep;
LCA() {}
LCA(int n) : n(n), G(n), dep(n) {
h = 1;
while ((1 << h) <= n)
h++;
par.assign(h, vector<int>(n, -1));
}
void add_edge(int u, int v) {
G[u].emplace_back(v);
G[v].emplace_back(u);
}
void dfs(int v, int p, int d) {
par[0][v] = p;
dep[v] = d;
for (int u : G[v])
if (u != p)
dfs(u, v, d + 1);
}
void build(int r = 0) {
dfs(r, -1, 0);
for (int k = 0; k + 1 < h; k++)
for (int v = 0; v < n; v++)
if (~par[k][v])
par[k + 1][v] = par[k][par[k][v]];
}
int lca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
REP(k, h) {
if (((dep[v] - dep[u]) >> k) & 1)
v = par[k][v];
}
if (u == v)
return u;
for (int k = h - 1; k >= 0; k--)
if (par[k][u] != par[k][v])
u = par[k][u], v = par[k][v];
return par[0][u];
}
int distance(int u, int v) { return dep[u] + dep[v] - dep[lca(u, v)] * 2; }
};
ll ans[100100], clen[100100], ccnt[100100], x[100100], y[100100], u[100100],
v[100100];
using tp = tuple<ll, ll, ll, ll>;
vector<vector<tp>> qs;
vector<map<ll, ll>> dist;
void dfs(ll now, ll par, ll d) {
FOREACH(dd, dist[now]) {
ll q = dd.fi;
dd.se = d - clen[x[q]] + ccnt[x[q]] * y[q];
}
FOREACH(e, g[now]) {
ll to = e.to, col = e.col, len = e.len;
if (to == par)
continue;
clen[col] += len;
ccnt[col]++;
dfs(to, now, d + len);
clen[col] -= len;
ccnt[col]--;
}
}
signed main() {
cinfast();
LCIN(N, Q);
LCA lca(N);
g.resize(N);
REP(i, N - 1) {
LCIN(a, b, c, d);
a--, b--;
g[a].push_back({b, c, d});
g[b].push_back({a, c, d});
lca.add_edge(a, b);
}
lca.build();
qs.resize(N);
dist.resize(N);
VL com(N);
REP(i, Q) {
cin >> x[i] >> y[i] >> u[i] >> v[i];
u[i]--, v[i]--;
dist[u[i]][i] = 0;
dist[v[i]][i] = 0;
com[i] = lca.lca(u[i], v[i]);
dist[com[i]][i] = 0;
}
dfs(0, -1, 0);
REP(i, Q) {
cout << dist[u[i]][i] + dist[v[i]][i] - 2 * dist[com[i]][i] << "\n";
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
// #define double long double
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a); i > (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
#define VECCIN(x) \
for (auto &youso_ : (x)) \
cin >> youso_
#define bitcnt(x) __builtin_popcount(x)
#define lbit(x) __builtin_ffsll(x)
#define rbit(x) __builtin_clzll(x)
#define SZ(x) ((long long)(x).size())
#define fi first
#define se second
#define All(a) (a).begin(), (a).end()
#define rAll(a) (a).rbegin(), (a).rend()
#define cinfast() cin.tie(0), ios::sync_with_stdio(false)
#define PERM(c) \
sort(All(c)); \
for (bool cp = true; cp; cp = next_permutation(All(c)))
#define MKORDER(n) \
vector<int> od(n); \
iota(All(od), 0LL);
template <typename T = long long> inline T IN() {
T x;
cin >> x;
return (x);
}
inline void CIN() {}
template <class Head, class... Tail>
inline void CIN(Head &&head, Tail &&...tail) {
cin >> head;
CIN(move(tail)...);
}
#define CCIN(...) \
char __VA_ARGS__; \
CIN(__VA_ARGS__)
#define DCIN(...) \
double __VA_ARGS__; \
CIN(__VA_ARGS__)
#define LCIN(...) \
long long __VA_ARGS__; \
CIN(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CIN(__VA_ARGS__)
#define Yes(a) cout << (a ? "Yes" : "No") << "\n"
#define YES(a) cout << (a ? "YES" : "NO") << "\n"
#define Printv(v) \
{ \
FOREACH(x, v) { cout << x << " "; } \
cout << "\n"; \
}
template <typename T = string> inline void eputs(T s) {
cout << s << "\n";
exit(0);
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> using PQG = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using PQ = priority_queue<T>;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<ll, ll> PL;
typedef vector<PL> VPL;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<string> VS;
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD = 998244353;
const ll LINF = 1e18;
const double PI = atan(1.0) * 4.0;
const ll dw[] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dh[] = {0, 1, 1, 1, 0, -1, -1, -1};
#define PI 3.141592653589793238
ll N, M;
struct edge {
ll to, col, len;
};
vector<vector<edge>> g;
VL d;
// doubling build:n query:logn
struct LCA {
int n, h;
vector<vector<int>> G, par;
vector<int> dep;
LCA() {}
LCA(int n) : n(n), G(n), dep(n) {
h = 1;
while ((1 << h) <= n)
h++;
par.assign(h, vector<int>(n, -1));
}
void add_edge(int u, int v) {
G[u].emplace_back(v);
G[v].emplace_back(u);
}
void dfs(int v, int p, int d) {
par[0][v] = p;
dep[v] = d;
for (int u : G[v])
if (u != p)
dfs(u, v, d + 1);
}
void build(int r = 0) {
dfs(r, -1, 0);
for (int k = 0; k + 1 < h; k++)
for (int v = 0; v < n; v++)
if (~par[k][v])
par[k + 1][v] = par[k][par[k][v]];
}
int lca(int u, int v) {
if (dep[u] > dep[v])
swap(u, v);
REP(k, h) {
if (((dep[v] - dep[u]) >> k) & 1)
v = par[k][v];
}
if (u == v)
return u;
for (int k = h - 1; k >= 0; k--)
if (par[k][u] != par[k][v])
u = par[k][u], v = par[k][v];
return par[0][u];
}
int distance(int u, int v) { return dep[u] + dep[v] - dep[lca(u, v)] * 2; }
};
ll ans[100100], clen[100100], ccnt[100100], x[100100], y[100100], u[100100],
v[100100];
using tp = tuple<ll, ll, ll, ll>;
vector<vector<tp>> qs;
vector<map<ll, ll>> dist;
void dfs(ll now, ll par, ll d) {
FOREACH(dd, dist[now]) {
ll q = dd.fi;
dd.se = d - clen[x[q]] + ccnt[x[q]] * y[q];
}
FOREACH(e, g[now]) {
ll to = e.to, col = e.col, len = e.len;
if (to == par)
continue;
clen[col] += len;
ccnt[col]++;
dfs(to, now, d + len);
clen[col] -= len;
ccnt[col]--;
}
}
signed main() {
cinfast();
LCIN(N, Q);
LCA lca(N);
g.resize(N);
REP(i, N - 1) {
LCIN(a, b, c, d);
a--, b--;
g[a].push_back({b, c, d});
g[b].push_back({a, c, d});
lca.add_edge(a, b);
}
lca.build();
qs.resize(N);
dist.resize(N);
VL com(Q);
REP(i, Q) {
cin >> x[i] >> y[i] >> u[i] >> v[i];
u[i]--, v[i]--;
dist[u[i]][i] = 0;
dist[v[i]][i] = 0;
com[i] = lca.lca(u[i], v[i]);
dist[com[i]][i] = 0;
}
dfs(0, -1, 0);
REP(i, Q) {
cout << dist[u[i]][i] + dist[v[i]][i] - 2 * dist[com[i]][i] << "\n";
}
}
| replace | 189 | 190 | 189 | 190 | 0 | |
p02986 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
a = abs(a), b = abs(b);
while (b > 0) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
// mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
constexpr long long mod = 1000000007LL;
// constexpr long long mod = 998244353LL;
struct HLD {
vector<int> sz, in, out, head, par;
vector<vector<int>> g;
HLD() {}
HLD(vector<vector<int>> &_g)
: g(_g), sz(_g.size()), in(_g.size()), out(_g.size()), head(_g.size()),
par(_g.size()) {}
void dfs_sz(int cur, int pre) {
sz[cur] = 1;
for (int &next : g[cur]) {
if (next == pre)
continue;
dfs_sz(next, cur);
par[next] = cur;
sz[cur] += sz[next];
if (sz[next] > sz[g[cur][0]])
swap(next, g[cur][0]);
}
}
void dfs_hld(int cur, int pre, int &idx) {
in[cur] = idx++;
for (int &next : g[cur]) {
if (next == pre)
continue;
if (next == g[cur][0])
head[next] = head[cur];
else
head[next] = next;
dfs_hld(next, cur, idx);
}
out[cur] = idx;
}
void build() {
dfs_sz(0, -1);
int idx = 0;
dfs_hld(0, -1, idx);
}
void build(vector<vector<int>> &_g) {
g = _g;
sz.resize(g.size());
in.resize(g.size());
out.resize(g.size());
head.resize(g.size());
par.resize(g.size());
dfs_sz(0, -1);
int idx = 0;
dfs_hld(0, -1, idx);
}
int lca(int u, int v) {
for (;; v = par[head[v]]) {
if (in[u] > in[v])
swap(u, v);
if (head[u] == head[v])
return u;
}
}
};
template <typename T> struct BIT {
int n;
vector<T> bit;
BIT() : n(0) {}
BIT(int _n) : n(_n) { bit = vector<T>(n + 1); }
void add1(int idx, T val) {
for (int i = idx; i <= n; i += i & -i)
bit[i] += val;
}
T sum1(int idx) {
T res = 0;
for (int i = idx; i > 0; i -= i & -i)
res += bit[i];
return res;
}
// 0-indexed
void add(int idx, T val) { add1(idx + 1, val); }
// 0-indexed [left, right)
T sum(int left, int right) { return sum1(right) - sum1(left); }
int lower_bound(T x) {
int res = 0;
int k = 1;
while (2 * k <= n)
k <<= 1;
for (; k > 0; k >>= 1) {
if (res + k <= n and bit[res + k] < x) {
x -= bit[res + k];
res += k;
}
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, Q;
cin >> n >> Q;
vector<vector<int>> g(n);
vector<vector<tuple<int, int, int>>> vt(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
g[a].emplace_back(b);
g[b].emplace_back(a);
vt[c].emplace_back(a, b, d);
}
HLD hld(g);
hld.build();
// q[x] = y, u, v, id
vector<vector<tuple<int, int, int, int>>> query(n);
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
x--;
u--;
v--;
query[x].emplace_back(y, u, v, i);
}
vector<ll> res(n);
BIT<ll> bit(n + 1), bc(n + 1);
for (int i = 0; i < n; i++) {
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], d);
}
}
for (int i = 0; i < n; i++) {
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], -d);
bc.add(hld.in[v], 1);
}
for (auto [y, u, v, id] : query[i]) {
ll ans = 0;
ll cnt = 0;
for (;; v = hld.par[hld.head[v]]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
if (hld.head[u] == hld.head[v]) {
ans += bit.sum(hld.in[u] + 1, hld.in[v] + 1);
cnt += bc.sum(hld.in[u] + 1, hld.in[v] + 1);
break;
} else {
ans += bit.sum(hld.in[hld.head[v]], hld.in[v] + 1);
cnt += bc.sum(hld.in[hld.head[v]], hld.in[v] + 1);
}
}
ans += cnt * y;
res[id] = ans;
}
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], +d);
bc.add(hld.in[v], -1);
}
}
for (int i = 0; i < Q; i++)
cout << res[i] << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> T gcd(T a, T b) {
a = abs(a), b = abs(b);
while (b > 0) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
// mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
constexpr long long INF = 1LL << 60;
constexpr int inf = 1000000007;
constexpr long long mod = 1000000007LL;
// constexpr long long mod = 998244353LL;
struct HLD {
vector<int> sz, in, out, head, par;
vector<vector<int>> g;
HLD() {}
HLD(vector<vector<int>> &_g)
: g(_g), sz(_g.size()), in(_g.size()), out(_g.size()), head(_g.size()),
par(_g.size()) {}
void dfs_sz(int cur, int pre) {
sz[cur] = 1;
for (int &next : g[cur]) {
if (next == pre)
continue;
dfs_sz(next, cur);
par[next] = cur;
sz[cur] += sz[next];
if (sz[next] > sz[g[cur][0]])
swap(next, g[cur][0]);
}
}
void dfs_hld(int cur, int pre, int &idx) {
in[cur] = idx++;
for (int &next : g[cur]) {
if (next == pre)
continue;
if (next == g[cur][0])
head[next] = head[cur];
else
head[next] = next;
dfs_hld(next, cur, idx);
}
out[cur] = idx;
}
void build() {
dfs_sz(0, -1);
int idx = 0;
dfs_hld(0, -1, idx);
}
void build(vector<vector<int>> &_g) {
g = _g;
sz.resize(g.size());
in.resize(g.size());
out.resize(g.size());
head.resize(g.size());
par.resize(g.size());
dfs_sz(0, -1);
int idx = 0;
dfs_hld(0, -1, idx);
}
int lca(int u, int v) {
for (;; v = par[head[v]]) {
if (in[u] > in[v])
swap(u, v);
if (head[u] == head[v])
return u;
}
}
};
template <typename T> struct BIT {
int n;
vector<T> bit;
BIT() : n(0) {}
BIT(int _n) : n(_n) { bit = vector<T>(n + 1); }
void add1(int idx, T val) {
for (int i = idx; i <= n; i += i & -i)
bit[i] += val;
}
T sum1(int idx) {
T res = 0;
for (int i = idx; i > 0; i -= i & -i)
res += bit[i];
return res;
}
// 0-indexed
void add(int idx, T val) { add1(idx + 1, val); }
// 0-indexed [left, right)
T sum(int left, int right) { return sum1(right) - sum1(left); }
int lower_bound(T x) {
int res = 0;
int k = 1;
while (2 * k <= n)
k <<= 1;
for (; k > 0; k >>= 1) {
if (res + k <= n and bit[res + k] < x) {
x -= bit[res + k];
res += k;
}
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, Q;
cin >> n >> Q;
vector<vector<int>> g(n);
vector<vector<tuple<int, int, int>>> vt(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
g[a].emplace_back(b);
g[b].emplace_back(a);
vt[c].emplace_back(a, b, d);
}
HLD hld(g);
hld.build();
// q[x] = y, u, v, id
vector<vector<tuple<int, int, int, int>>> query(n);
for (int i = 0; i < Q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
x--;
u--;
v--;
query[x].emplace_back(y, u, v, i);
}
vector<ll> res(Q);
BIT<ll> bit(n + 1), bc(n + 1);
for (int i = 0; i < n; i++) {
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], d);
}
}
for (int i = 0; i < n; i++) {
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], -d);
bc.add(hld.in[v], 1);
}
for (auto [y, u, v, id] : query[i]) {
ll ans = 0;
ll cnt = 0;
for (;; v = hld.par[hld.head[v]]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
if (hld.head[u] == hld.head[v]) {
ans += bit.sum(hld.in[u] + 1, hld.in[v] + 1);
cnt += bc.sum(hld.in[u] + 1, hld.in[v] + 1);
break;
} else {
ans += bit.sum(hld.in[hld.head[v]], hld.in[v] + 1);
cnt += bc.sum(hld.in[hld.head[v]], hld.in[v] + 1);
}
}
ans += cnt * y;
res[id] = ans;
}
for (auto [u, v, d] : vt[i]) {
if (hld.in[u] > hld.in[v])
swap(u, v);
bit.add(hld.in[v], +d);
bc.add(hld.in[v], -1);
}
}
for (int i = 0; i < Q; i++)
cout << res[i] << "\n";
return 0;
}
| replace | 188 | 189 | 188 | 189 | 0 | |
p02986 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cstdio>
#include <functional>
#include <tuple>
#include <vector>
using namespace std;
using int64 = long long int;
struct UnionFind {
vector<int> node, anc, color;
UnionFind(int n) : node(n, -1), anc(n), color(n) {}
int find(int k) { return node[k] < 0 ? k : find(node[k]); }
int size(int k) { return -node[find(k)]; }
bool unite(int u, int v) {
u = find(u), v = find(v);
if (u == v)
return false;
if (node[u] < node[v])
swap(u, v);
node[u] += node[v];
node[v] = u;
return true;
}
};
int main() {
int N, Q;
scanf("%d%d", &N, &Q);
vector<vector<tuple<int, int, int>>> G(N);
for (int i = 0; i < N - 1; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a--;
b--;
c--;
G[a].emplace_back(b, c, d);
G[b].emplace_back(a, c, d);
}
vector<int64> ans(Q), neg(Q);
vector<vector<tuple<int, int, int, int>>> info(N), tmp(N);
for (int i = 0; i < Q; i++) {
int x, y, u, v;
scanf("%d%d%d%d", &x, &y, &u, &v);
x--;
u--;
v--;
info[u].emplace_back(x, y, i, v);
info[v].emplace_back(x, y, i, u);
}
UnionFind uf(N);
function<void(int, int)> find_lca = [&](int cur, int par) {
uf.anc[cur] = cur;
for (auto e : G[cur]) {
int to = get<0>(e);
if (to == par)
continue;
find_lca(to, cur);
uf.unite(to, cur);
uf.anc[uf.find(cur)] = cur;
}
uf.color[cur] = 1;
for (auto e : info[cur]) {
int col, d, idx, to;
tie(col, d, idx, to) = e;
if (to < 0)
continue;
if (uf.color[to] == 1 and neg[idx]++ == 0) {
int lca = uf.anc[uf.find(to)];
tmp[lca].emplace_back(col, d, idx, -1);
}
}
};
vector<int64> sum(N), cnt(N);
int64 cost = 0;
function<void(int, int)> go = [&](int cur, int par) {
for (auto e : info[cur]) {
int col, d, idx, p;
tie(col, d, idx, p) = e;
int64 diff = cost + cnt[col] * d - sum[col];
if (p < 0) {
ans[idx] -= 2 * diff;
} else {
ans[idx] += diff;
}
}
for (auto e : G[cur]) {
int to, col, dist;
tie(to, col, dist) = e;
if (to == par)
continue;
sum[col] += dist;
cnt[col]++;
cost += dist;
go(to, cur);
sum[col] -= dist;
cnt[col]--;
cost -= dist;
}
};
find_lca(0, -1);
for (int i = 0; i < N; i++)
for (auto e : tmp[i])
info[i].push_back(e);
go(0, -1);
for (auto a : ans)
printf("%lld\n", a);
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cstdio>
#include <functional>
#include <tuple>
#include <vector>
using namespace std;
using int64 = long long int;
struct UnionFind {
vector<int> node, anc, color;
UnionFind(int n) : node(n, -1), anc(n), color(n) {}
int find(int k) { return node[k] < 0 ? k : find(node[k]); }
int size(int k) { return -node[find(k)]; }
bool unite(int u, int v) {
u = find(u), v = find(v);
if (u == v)
return false;
if (size(u) < size(v))
swap(u, v);
node[u] += node[v];
node[v] = u;
return true;
}
};
int main() {
int N, Q;
scanf("%d%d", &N, &Q);
vector<vector<tuple<int, int, int>>> G(N);
for (int i = 0; i < N - 1; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a--;
b--;
c--;
G[a].emplace_back(b, c, d);
G[b].emplace_back(a, c, d);
}
vector<int64> ans(Q), neg(Q);
vector<vector<tuple<int, int, int, int>>> info(N), tmp(N);
for (int i = 0; i < Q; i++) {
int x, y, u, v;
scanf("%d%d%d%d", &x, &y, &u, &v);
x--;
u--;
v--;
info[u].emplace_back(x, y, i, v);
info[v].emplace_back(x, y, i, u);
}
UnionFind uf(N);
function<void(int, int)> find_lca = [&](int cur, int par) {
uf.anc[cur] = cur;
for (auto e : G[cur]) {
int to = get<0>(e);
if (to == par)
continue;
find_lca(to, cur);
uf.unite(to, cur);
uf.anc[uf.find(cur)] = cur;
}
uf.color[cur] = 1;
for (auto e : info[cur]) {
int col, d, idx, to;
tie(col, d, idx, to) = e;
if (to < 0)
continue;
if (uf.color[to] == 1 and neg[idx]++ == 0) {
int lca = uf.anc[uf.find(to)];
tmp[lca].emplace_back(col, d, idx, -1);
}
}
};
vector<int64> sum(N), cnt(N);
int64 cost = 0;
function<void(int, int)> go = [&](int cur, int par) {
for (auto e : info[cur]) {
int col, d, idx, p;
tie(col, d, idx, p) = e;
int64 diff = cost + cnt[col] * d - sum[col];
if (p < 0) {
ans[idx] -= 2 * diff;
} else {
ans[idx] += diff;
}
}
for (auto e : G[cur]) {
int to, col, dist;
tie(to, col, dist) = e;
if (to == par)
continue;
sum[col] += dist;
cnt[col]++;
cost += dist;
go(to, cur);
sum[col] -= dist;
cnt[col]--;
cost -= dist;
}
};
find_lca(0, -1);
for (int i = 0; i < N; i++)
for (auto e : tmp[i])
info[i].push_back(e);
go(0, -1);
for (auto a : ans)
printf("%lld\n", a);
return 0;
}
| replace | 18 | 19 | 18 | 19 | TLE | |
p02986 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int M = 1e5 + 5;
const int MB = 19;
int n, q;
struct TN {
int ls, rs;
int cnt, sum;
TN(int ls = 0, int rs = 0, int cnt = 0, int sum = 0)
: ls(ls), rs(rs), cnt(cnt), sum(sum) {}
};
struct PSegT {
TN tn[M * MB];
int nn; // number of node
int P, V;
void init(int n) {
nn = 0;
int root;
build(root, 0, n);
}
void build(int &o, int l, int r) {
o = ++nn;
// cout<<o<<" "<<l<<" "<<r<<endl;
if (l == r) {
tn[o].ls = tn[o].rs = tn[o].cnt = tn[o].sum = 0;
return;
}
int mid = (l + r) >> 1;
build(tn[o].ls, l, mid);
build(tn[o].rs, mid + 1, r);
}
TN query(int o, int l, int r) {
if (l == r)
return tn[o];
int mid = (l + r) >> 1;
if (P <= mid)
return query(tn[o].ls, l, mid);
else
return query(tn[o].rs, mid + 1, r);
}
int add(int &o, int l, int r) {
int no = ++nn;
tn[no] = tn[o];
o = no;
tn[o].cnt++;
tn[o].sum += V;
if (l == r)
return o;
int mid = (l + r) >> 1;
if (P <= mid)
add(tn[o].ls, l, mid);
else
add(tn[o].rs, mid + 1, r);
return o;
}
void show(int u) {
cout << endl << "show tree " << u << endl;
for (int i = 0; i <= n; i++) {
P = i;
TN node = query(u, 0, n);
cout << i << " " << node.cnt << " " << node.sum << endl;
}
cout << endl;
}
} psegt;
int vis[M];
int sum[M];
int root[M];
struct Edge {
int v, c, d;
Edge(int v = 0, int c = 0, int d = 0) : v(v), c(c), d(d) {}
};
vector<Edge> g[M];
void dfs(int u, int fa, int c, int d, int nsum) {
sum[u] = nsum;
psegt.P = c;
psegt.V = d;
root[u] = root[fa];
psegt.add(root[u], 0, n);
for (auto e : g[u]) {
int v = e.v;
if (v == fa)
continue;
dfs(v, u, e.c, e.d, nsum + e.d);
}
}
struct LCA {
int fa[M][MB], dep[M];
void dfs_fa(int u, int f, int depth) {
// cout<<u<<endl;
dep[u] = depth;
for (Edge e : g[u]) {
int v = e.v;
if (v == f)
continue;
if (!fa[v][0]) {
fa[v][0] = u;
dfs_fa(v, u, depth + 1);
}
}
}
void init_lca(int root) {
memset(fa, 0, sizeof(fa));
dfs_fa(root, 0, 0);
// cout<<"here"<<endl;
for (int j = 1; j < MB; j++) {
for (int i = 1; i <= n; i++) {
// cout<<i<<" "<<fa[i][j-1]<<" "<<fa[fa[i][j-1]][j-1]<<endl;
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
// cout<<j<<endl;
}
}
int lca(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
int k = dep[b] - dep[a];
for (int i = 0; (1 << i) <= k; i++)
if (k & (1 << i))
b = fa[b][i];
if (a == b)
return a;
for (int i = MB - 1; i >= 0; i--) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
return fa[a][0];
}
} lca;
int getsum(int u, int c, int d) {
psegt.P = c;
// cout<<u<<" c = "<<c<<" d = "<<d<<endl;
// psegt.show(root[u]);
TN node = psegt.query(root[u], 0, n);
int ans = sum[u] - node.sum + node.cnt * d;
// cout<<u<<" "<<sum[u]<<" "<<node.cnt<<" "<<node.sum;
// cout<<" "<<ans<<endl;
return ans;
}
int main() {
// freopen("F_in.txt","r",stdin);
scanf("%d%d", &n, &q);
int u, v, c, d;
for (int i = 1; i < n; i++) {
scanf("%d%d%d%d", &u, &v, &c, &d);
g[u].emplace_back(v, c, d);
g[v].emplace_back(u, c, d);
}
root[0] = 1;
psegt.init(n);
// cout<<"init ok1"<<endl;
dfs(1, 0, 0, 0, 0);
// cout<<"init ok2"<<endl;
lca.init_lca(1);
// cout<<"init ok3"<<endl;
while (q--) {
scanf("%d%d%d%d", &c, &d, &u, &v);
int l = lca.lca(u, v);
// cout<<l<<endl;
printf("%d\n", getsum(u, c, d) + getsum(v, c, d) - 2 * getsum(l, c, d));
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int M = 1e5 + 5;
const int MB = 20;
int n, q;
struct TN {
int ls, rs;
int cnt, sum;
TN(int ls = 0, int rs = 0, int cnt = 0, int sum = 0)
: ls(ls), rs(rs), cnt(cnt), sum(sum) {}
};
struct PSegT {
TN tn[M * MB];
int nn; // number of node
int P, V;
void init(int n) {
nn = 0;
int root;
build(root, 0, n);
}
void build(int &o, int l, int r) {
o = ++nn;
// cout<<o<<" "<<l<<" "<<r<<endl;
if (l == r) {
tn[o].ls = tn[o].rs = tn[o].cnt = tn[o].sum = 0;
return;
}
int mid = (l + r) >> 1;
build(tn[o].ls, l, mid);
build(tn[o].rs, mid + 1, r);
}
TN query(int o, int l, int r) {
if (l == r)
return tn[o];
int mid = (l + r) >> 1;
if (P <= mid)
return query(tn[o].ls, l, mid);
else
return query(tn[o].rs, mid + 1, r);
}
int add(int &o, int l, int r) {
int no = ++nn;
tn[no] = tn[o];
o = no;
tn[o].cnt++;
tn[o].sum += V;
if (l == r)
return o;
int mid = (l + r) >> 1;
if (P <= mid)
add(tn[o].ls, l, mid);
else
add(tn[o].rs, mid + 1, r);
return o;
}
void show(int u) {
cout << endl << "show tree " << u << endl;
for (int i = 0; i <= n; i++) {
P = i;
TN node = query(u, 0, n);
cout << i << " " << node.cnt << " " << node.sum << endl;
}
cout << endl;
}
} psegt;
int vis[M];
int sum[M];
int root[M];
struct Edge {
int v, c, d;
Edge(int v = 0, int c = 0, int d = 0) : v(v), c(c), d(d) {}
};
vector<Edge> g[M];
void dfs(int u, int fa, int c, int d, int nsum) {
sum[u] = nsum;
psegt.P = c;
psegt.V = d;
root[u] = root[fa];
psegt.add(root[u], 0, n);
for (auto e : g[u]) {
int v = e.v;
if (v == fa)
continue;
dfs(v, u, e.c, e.d, nsum + e.d);
}
}
struct LCA {
int fa[M][MB], dep[M];
void dfs_fa(int u, int f, int depth) {
// cout<<u<<endl;
dep[u] = depth;
for (Edge e : g[u]) {
int v = e.v;
if (v == f)
continue;
if (!fa[v][0]) {
fa[v][0] = u;
dfs_fa(v, u, depth + 1);
}
}
}
void init_lca(int root) {
memset(fa, 0, sizeof(fa));
dfs_fa(root, 0, 0);
// cout<<"here"<<endl;
for (int j = 1; j < MB; j++) {
for (int i = 1; i <= n; i++) {
// cout<<i<<" "<<fa[i][j-1]<<" "<<fa[fa[i][j-1]][j-1]<<endl;
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
// cout<<j<<endl;
}
}
int lca(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
int k = dep[b] - dep[a];
for (int i = 0; (1 << i) <= k; i++)
if (k & (1 << i))
b = fa[b][i];
if (a == b)
return a;
for (int i = MB - 1; i >= 0; i--) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
return fa[a][0];
}
} lca;
int getsum(int u, int c, int d) {
psegt.P = c;
// cout<<u<<" c = "<<c<<" d = "<<d<<endl;
// psegt.show(root[u]);
TN node = psegt.query(root[u], 0, n);
int ans = sum[u] - node.sum + node.cnt * d;
// cout<<u<<" "<<sum[u]<<" "<<node.cnt<<" "<<node.sum;
// cout<<" "<<ans<<endl;
return ans;
}
int main() {
// freopen("F_in.txt","r",stdin);
scanf("%d%d", &n, &q);
int u, v, c, d;
for (int i = 1; i < n; i++) {
scanf("%d%d%d%d", &u, &v, &c, &d);
g[u].emplace_back(v, c, d);
g[v].emplace_back(u, c, d);
}
root[0] = 1;
psegt.init(n);
// cout<<"init ok1"<<endl;
dfs(1, 0, 0, 0, 0);
// cout<<"init ok2"<<endl;
lca.init_lca(1);
// cout<<"init ok3"<<endl;
while (q--) {
scanf("%d%d%d%d", &c, &d, &u, &v);
int l = lca.lca(u, v);
// cout<<l<<endl;
printf("%d\n", getsum(u, c, d) + getsum(v, c, d) - 2 * getsum(l, c, d));
}
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p02986 | C++ | Runtime Error | #include <cstdio>
#include <vector>
// CONSTRAINTS
const int MN = 1e5 + 100;
const int MS = 2e6;
int N, Q;
struct node {
public:
int l, r;
int c, d;
};
node seg[MS];
int X = MN;
void upd(int n, int l, int r, int ql, int qr, int xd) {
if (ql <= l && r <= qr)
++seg[n].c, seg[n].d += xd;
else {
int m = l + (r - l) / 2;
if (ql < m)
upd(seg[n].l ? seg[n].l : seg[n].l = X++, l, m, ql, qr, xd);
if (m < qr)
upd(seg[n].r ? seg[n].r : seg[n].r = X++, m, r, ql, qr, xd);
}
}
int C, D;
void qry(int n, int l, int r, int q) {
if (!n)
return;
C += seg[n].c, D += seg[n].d;
if (r - l > 1) {
int m = l + (r - l) / 2;
if (q < m)
qry(seg[n].l, l, m, q);
else
qry(seg[n].r, m, r, q);
}
}
struct edg {
public:
int n, c, d;
};
std::vector<edg> a[MN];
int p[MN][20], d[MN], l[MN], pre[MN], post[MN], t;
void dfs(int n = 1) {
pre[n] = t++;
for (int i = 0; p[n][i] && p[p[n][i]][i]; ++i)
p[n][i + 1] = p[p[n][i]][i];
for (auto x : a[n])
if (x.n != p[n][0]) {
d[x.n] = d[n] + 1;
l[x.n] = l[n] + x.d;
p[x.n][0] = n;
dfs(x.n);
upd(x.c, 0, N, pre[x.n], post[x.n], x.d);
}
post[n] = t;
}
int lca(int a, int b) {
if (a == b)
return a;
if (d[b] < d[a])
std::swap(a, b);
for (int i = 0, j = d[b] - d[a]; (1 << i) <= j; ++i)
if (j >> i & 1)
b = p[b][i];
if (a == b)
return a;
for (int i = 31 - __builtin_clz(d[a]); i >= 0; --i)
if (p[a][i] && p[a][i] != p[b][i])
a = p[a][i], b = p[b][i];
return p[a][0];
}
int main(void) {
scanf("%d%d", &N, &Q);
for (int i = 0; i + 1 < N; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
::a[a].push_back({b, c, d});
::a[b].push_back({a, c, d});
}
dfs();
for (int i = 0, x, y, u, v, c, d; i < Q; ++i) {
scanf("%d%d%d%d", &x, &y, &u, &v);
int z = lca(u, v);
C = D = 0;
qry(x, 0, N, pre[u]);
qry(x, 0, N, pre[v]);
c = C, d = D;
C = D = 0;
qry(x, 0, N, pre[z]);
c -= 2 * C, d -= 2 * D;
printf("%d\n", c * y + (l[u] + l[v] - 2 * l[z]) - d);
}
return 0;
}
| #include <cstdio>
#include <vector>
// CONSTRAINTS
const int MN = 1e5 + 100;
const int MS = 4e6;
int N, Q;
struct node {
public:
int l, r;
int c, d;
};
node seg[MS];
int X = MN;
void upd(int n, int l, int r, int ql, int qr, int xd) {
if (ql <= l && r <= qr)
++seg[n].c, seg[n].d += xd;
else {
int m = l + (r - l) / 2;
if (ql < m)
upd(seg[n].l ? seg[n].l : seg[n].l = X++, l, m, ql, qr, xd);
if (m < qr)
upd(seg[n].r ? seg[n].r : seg[n].r = X++, m, r, ql, qr, xd);
}
}
int C, D;
void qry(int n, int l, int r, int q) {
if (!n)
return;
C += seg[n].c, D += seg[n].d;
if (r - l > 1) {
int m = l + (r - l) / 2;
if (q < m)
qry(seg[n].l, l, m, q);
else
qry(seg[n].r, m, r, q);
}
}
struct edg {
public:
int n, c, d;
};
std::vector<edg> a[MN];
int p[MN][20], d[MN], l[MN], pre[MN], post[MN], t;
void dfs(int n = 1) {
pre[n] = t++;
for (int i = 0; p[n][i] && p[p[n][i]][i]; ++i)
p[n][i + 1] = p[p[n][i]][i];
for (auto x : a[n])
if (x.n != p[n][0]) {
d[x.n] = d[n] + 1;
l[x.n] = l[n] + x.d;
p[x.n][0] = n;
dfs(x.n);
upd(x.c, 0, N, pre[x.n], post[x.n], x.d);
}
post[n] = t;
}
int lca(int a, int b) {
if (a == b)
return a;
if (d[b] < d[a])
std::swap(a, b);
for (int i = 0, j = d[b] - d[a]; (1 << i) <= j; ++i)
if (j >> i & 1)
b = p[b][i];
if (a == b)
return a;
for (int i = 31 - __builtin_clz(d[a]); i >= 0; --i)
if (p[a][i] && p[a][i] != p[b][i])
a = p[a][i], b = p[b][i];
return p[a][0];
}
int main(void) {
scanf("%d%d", &N, &Q);
for (int i = 0; i + 1 < N; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
::a[a].push_back({b, c, d});
::a[b].push_back({a, c, d});
}
dfs();
for (int i = 0, x, y, u, v, c, d; i < Q; ++i) {
scanf("%d%d%d%d", &x, &y, &u, &v);
int z = lca(u, v);
C = D = 0;
qry(x, 0, N, pre[u]);
qry(x, 0, N, pre[v]);
c = C, d = D;
C = D = 0;
qry(x, 0, N, pre[z]);
c -= 2 * C, d -= 2 * D;
printf("%d\n", c * y + (l[u] + l[v] - 2 * l[z]) - d);
}
return 0;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAGIC = 512;
struct edge {
int u, v, col, len;
edge() = default;
edge(int u, int v, int c, int l) : u(u), v(v), col(c), len(l) {}
};
int n, q, t = 0;
int L[N], R[N];
int up[20][N];
vector<pair<long long, int>> sum[N];
vector<edge> g[N];
vector<edge> E[N];
bool read() {
if (!(cin >> n >> q))
return false;
sum[n].resize(n);
for (int i = 0; i < n - 1; ++i) {
int u, v, col, len;
cin >> u >> v >> col >> len;
g[u - 1].emplace_back(u - 1, v - 1, col, len);
g[v - 1].emplace_back(v - 1, u - 1, col, len);
E[col - 1].emplace_back(u - 1, v - 1, col, len);
}
return true;
}
pair<long long, int> operator+(const pair<long long, int> &a,
const pair<long long, int> &b) {
return {a.first + b.first, a.second + b.second};
}
void predfs(int v, int pr) {
up[v][0] = pr;
L[v] = t++;
for (const auto &e : g[v])
if (e.v != pr)
predfs(e.v, v);
R[v] = t - 1;
}
void dfs(int v, int pr, int id) {
for (const auto &e : g[v])
if (e.v != pr) {
if (id != n)
sum[id][e.v] = sum[id][e.v] + sum[id][v];
else
sum[id][e.v] = sum[id][v] + make_pair(e.len, 1);
dfs(e.v, v, id);
}
}
bool isanc(int u, int v) { return L[u] <= L[v] && R[v] <= R[u]; }
bool btwn(int u, int v, int U, int V) {
if (!isanc(u, U) || !isanc(V, u))
return false;
if (!isanc(v, U) || !isanc(V, v))
return false;
return true;
}
int lca(int u, int v) {
if (isanc(u, v))
return u;
if (isanc(v, u))
return v;
for (int i = 19; i >= 0; --i)
if (!isanc(up[u][i], v))
u = up[u][i];
return up[u][0];
}
void solve() {
predfs(0, 0);
for (int i = 0; i < n; ++i)
if (E[i].size() >= MAGIC) {
sum[i].resize(n);
for (const auto &e : E[i])
sum[i][isanc(e.u, e.v) ? e.v : e.u] = {e.len, 1};
dfs(0, 0, i);
}
sum[n].resize(n);
dfs(0, 0, n);
for (int k = 1; k < 20; ++k)
for (int i = 0; i < n; ++i)
up[i][k] = up[up[i][k - 1]][k - 1];
while (q-- > 0) {
int col, w, u, v;
cin >> col >> w >> u >> v;
--col, --u, --v;
auto anc = lca(u, v);
auto res = sum[n][u].first + sum[n][v].first - 2 * sum[n][anc].first;
if (E[col].size() >= MAGIC) {
res -= sum[col][u].first + sum[col][v].first - 2 * sum[col][anc].first;
res += w * (sum[col][u].second + sum[col][v].second -
2 * sum[col][anc].second);
} else {
for (const auto &e : E[col])
if (btwn(e.u, e.v, u, anc) || btwn(e.u, e.v, v, anc))
res += w - e.len;
}
cout << res << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAGIC = 512;
struct edge {
int u, v, col, len;
edge() = default;
edge(int u, int v, int c, int l) : u(u), v(v), col(c), len(l) {}
};
int n, q, t = 0;
int L[N], R[N];
int up[N][20];
vector<pair<long long, int>> sum[N];
vector<edge> g[N];
vector<edge> E[N];
bool read() {
if (!(cin >> n >> q))
return false;
sum[n].resize(n);
for (int i = 0; i < n - 1; ++i) {
int u, v, col, len;
cin >> u >> v >> col >> len;
g[u - 1].emplace_back(u - 1, v - 1, col, len);
g[v - 1].emplace_back(v - 1, u - 1, col, len);
E[col - 1].emplace_back(u - 1, v - 1, col, len);
}
return true;
}
pair<long long, int> operator+(const pair<long long, int> &a,
const pair<long long, int> &b) {
return {a.first + b.first, a.second + b.second};
}
void predfs(int v, int pr) {
up[v][0] = pr;
L[v] = t++;
for (const auto &e : g[v])
if (e.v != pr)
predfs(e.v, v);
R[v] = t - 1;
}
void dfs(int v, int pr, int id) {
for (const auto &e : g[v])
if (e.v != pr) {
if (id != n)
sum[id][e.v] = sum[id][e.v] + sum[id][v];
else
sum[id][e.v] = sum[id][v] + make_pair(e.len, 1);
dfs(e.v, v, id);
}
}
bool isanc(int u, int v) { return L[u] <= L[v] && R[v] <= R[u]; }
bool btwn(int u, int v, int U, int V) {
if (!isanc(u, U) || !isanc(V, u))
return false;
if (!isanc(v, U) || !isanc(V, v))
return false;
return true;
}
int lca(int u, int v) {
if (isanc(u, v))
return u;
if (isanc(v, u))
return v;
for (int i = 19; i >= 0; --i)
if (!isanc(up[u][i], v))
u = up[u][i];
return up[u][0];
}
void solve() {
predfs(0, 0);
for (int i = 0; i < n; ++i)
if (E[i].size() >= MAGIC) {
sum[i].resize(n);
for (const auto &e : E[i])
sum[i][isanc(e.u, e.v) ? e.v : e.u] = {e.len, 1};
dfs(0, 0, i);
}
sum[n].resize(n);
dfs(0, 0, n);
for (int k = 1; k < 20; ++k)
for (int i = 0; i < n; ++i)
up[i][k] = up[up[i][k - 1]][k - 1];
while (q-- > 0) {
int col, w, u, v;
cin >> col >> w >> u >> v;
--col, --u, --v;
auto anc = lca(u, v);
auto res = sum[n][u].first + sum[n][v].first - 2 * sum[n][anc].first;
if (E[col].size() >= MAGIC) {
res -= sum[col][u].first + sum[col][v].first - 2 * sum[col][anc].first;
res += w * (sum[col][u].second + sum[col][v].second -
2 * sum[col][anc].second);
} else {
for (const auto &e : E[col])
if (btwn(e.u, e.v, u, anc) || btwn(e.u, e.v, v, anc))
res += w - e.len;
}
cout << res << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| replace | 16 | 17 | 16 | 17 | 0 | |
p02986 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define IO_OP \
std::ios::sync_with_stdio(0); \
std::cin.tie(0);
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define endl '\n'
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int INF = 1e9 + 7, N = 1e5 + 8, M = 300;
vector<pair<int, pi>> G[N];
int d[N], p[20][N], pc[N], pd[N], n, q, dis[N];
unordered_map<int, int> s[N], ct[N];
bool yes[N];
void dfs(int u = 1, int pa = 1, int dp = 0, int c = -1, int pdp = 0) {
d[u] = dp;
p[0][u] = pa;
pc[u] = c;
pd[u] = pdp;
dis[u] = dis[pa] + pdp;
for (auto &e : G[u])
if (e.F != pa)
dfs(e.F, u, dp + 1, e.S.F, e.S.S);
if (dp % M == 0) {
int t = u;
while (p[0][t] != t && !yes[t]) {
s[pc[t]][u] += pd[t];
ct[pc[t]][u]++;
t = p[0][t];
}
if (yes[t])
for (int i = 1; i <= n - 1; i++)
s[i][u] += s[i][t], ct[i][u] += ct[i][t];
yes[u] = true;
}
}
int lca(int x, int y) {
if (d[x] < d[y])
swap(x, y);
for (int i = 19; i >= 0; --i)
if (d[p[i][x]] >= d[y])
x = p[i][x];
if (x == y)
return x;
for (int i = 19; i >= 0; --i) {
if (p[i][x] != p[i][y]) {
x = p[i][x];
y = p[i][y];
}
}
return p[0][x];
}
pi qry(int u, int x) {
pi ret = {0, 0};
while (p[0][u] != u && !yes[u]) {
ret.F += (pc[u] == x) * pd[u];
ret.S += (pc[u] == x);
u = p[0][u];
}
if (yes[u])
ret.F += s[x][u], ret.S += ct[x][u];
return ret;
}
int qry(int u, int x, int y) {
int ret = dis[u];
pi pp = qry(u, x);
ret -= pp.F;
ret += pp.S * y;
return ret;
}
int main() {
IO_OP;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
G[a].PB({b, {c, d}});
G[b].PB({a, {c, d}});
}
dfs();
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= n; ++j)
p[i][j] = p[i - 1][p[i - 1][j]];
}
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
cout << qry(u, x, y) + qry(v, x, y) - 2 * qry(lca(u, v), x, y) << endl;
}
}
| #include <bits/stdc++.h>
#define IO_OP \
std::ios::sync_with_stdio(0); \
std::cin.tie(0);
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define endl '\n'
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int INF = 1e9 + 7, N = 1e5 + 8, M = 400;
vector<pair<int, pi>> G[N];
int d[N], p[20][N], pc[N], pd[N], n, q, dis[N];
unordered_map<int, int> s[N], ct[N];
bool yes[N];
void dfs(int u = 1, int pa = 1, int dp = 0, int c = -1, int pdp = 0) {
d[u] = dp;
p[0][u] = pa;
pc[u] = c;
pd[u] = pdp;
dis[u] = dis[pa] + pdp;
for (auto &e : G[u])
if (e.F != pa)
dfs(e.F, u, dp + 1, e.S.F, e.S.S);
if (dp % M == 0) {
int t = u;
while (p[0][t] != t && !yes[t]) {
s[pc[t]][u] += pd[t];
ct[pc[t]][u]++;
t = p[0][t];
}
if (yes[t])
for (int i = 1; i <= n - 1; i++)
s[i][u] += s[i][t], ct[i][u] += ct[i][t];
yes[u] = true;
}
}
int lca(int x, int y) {
if (d[x] < d[y])
swap(x, y);
for (int i = 19; i >= 0; --i)
if (d[p[i][x]] >= d[y])
x = p[i][x];
if (x == y)
return x;
for (int i = 19; i >= 0; --i) {
if (p[i][x] != p[i][y]) {
x = p[i][x];
y = p[i][y];
}
}
return p[0][x];
}
pi qry(int u, int x) {
pi ret = {0, 0};
while (p[0][u] != u && !yes[u]) {
ret.F += (pc[u] == x) * pd[u];
ret.S += (pc[u] == x);
u = p[0][u];
}
if (yes[u])
ret.F += s[x][u], ret.S += ct[x][u];
return ret;
}
int qry(int u, int x, int y) {
int ret = dis[u];
pi pp = qry(u, x);
ret -= pp.F;
ret += pp.S * y;
return ret;
}
int main() {
IO_OP;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
G[a].PB({b, {c, d}});
G[b].PB({a, {c, d}});
}
dfs();
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= n; ++j)
p[i][j] = p[i - 1][p[i - 1][j]];
}
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
cout << qry(u, x, y) + qry(v, x, y) - 2 * qry(lca(u, v), x, y) << endl;
}
}
| replace | 17 | 18 | 17 | 18 | TLE | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fastIO ios_base::sync_with_stdio(false), cin.tie(NULL)
struct LCA {
vector<int> height, euler, first, logs;
vector<bool> visited;
vector<vector<int>> st;
int min_height(int a, int b) {
if (height[a] < height[b])
return a;
return b;
}
void build_sparse(int maxN) {
st = vector<vector<int>>(maxN, vector<int>(30));
logs = vector<int>(maxN + 1);
logs[1] = 0;
for (int i = 2; i <= maxN; i++) {
logs[i] = logs[i / 2] + 1;
}
for (int i = 0; i < maxN; i++) {
st[i][0] = euler[i];
}
for (int j = 1; j <= 30; j++) {
for (int i = 0; i + (1 << j) <= maxN; i++) {
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
}
int lca(int u, int v) {
u = first[u];
v = first[v];
if (u > v)
swap(u, v);
int lg = logs[v - u + 1];
return min_height(st[u][lg], st[v - (1 << lg) + 1][lg]);
}
void dfs(vector<int> *g, int n, int depth) {
visited[n] = 1;
height[n] = depth;
first[n] = euler.size();
euler.push_back(n);
for (auto i : g[n]) {
if (!visited[i]) {
dfs(g, i, depth + 1);
euler.push_back(n);
}
}
}
LCA(vector<int> *g, int n) {
height = vector<int>(n);
visited = vector<bool>(n);
first = vector<int>(n);
dfs(g, 1, 0);
build_sparse(euler.size());
}
};
const int N = 1e5 + 7;
vector<int> conn[N];
vector<pair<int, pair<ll, ll>>> g[N];
pair<ll, ll> colors[N];
unordered_map<int, unordered_map<int, pair<ll, ll>>> mp;
ll dists[N];
bool visited[N];
struct query {
int u, v, x, y;
query(int u, int v, int x, int y) {
this->u = u;
this->v = v;
this->x = x;
this->y = y;
}
};
void dfs(int n, int cost = 0) {
dists[n] = cost;
visited[n] = 1;
for (auto c : mp[n]) {
mp[n][c.first] = colors[c.first];
}
for (auto i : g[n]) {
if (visited[i.first])
continue;
colors[i.second.first].first++;
colors[i.second.first].second += i.second.second;
dfs(i.first, cost + i.second.second);
colors[i.second.first].first--;
colors[i.second.first].second -= i.second.second;
}
}
int main() {
fastIO;
int n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, d;
cin >> u >> v >> c >> d;
conn[u].push_back(v);
conn[v].push_back(u);
g[u].push_back({v, {c, d}});
g[v].push_back({u, {c, d}});
}
LCA lca(conn, n + 1);
vector<query> queries;
while (q--) {
int u, v, x, y;
cin >> x >> y >> u >> v;
mp[u][x] = {0, 0};
mp[v][x] = {0, 0};
mp[lca.lca(u, v)][x] = {0, 0};
queries.push_back(query(u, v, x, y));
}
dfs(1, 0);
for (auto i : queries) {
ll dist = dists[i.u] + dists[i.v] - 2 * dists[lca.lca(i.u, i.v)];
ll frq = mp[i.u][i.x].first + mp[i.v][i.x].first -
2 * mp[lca.lca(i.u, i.v)][i.x].first;
ll weight = mp[i.u][i.x].second + mp[i.v][i.x].second -
2 * mp[lca.lca(i.u, i.v)][i.x].second;
assert(weight <= dist);
cout << dist - weight + frq * i.y << '\n';
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fastIO ios_base::sync_with_stdio(false), cin.tie(NULL)
struct LCA {
vector<int> height, euler, first, logs;
vector<bool> visited;
vector<vector<int>> st;
int min_height(int a, int b) {
if (height[a] < height[b])
return a;
return b;
}
void build_sparse(int maxN) {
st = vector<vector<int>>(maxN, vector<int>(30));
logs = vector<int>(maxN + 1);
logs[1] = 0;
for (int i = 2; i <= maxN; i++) {
logs[i] = logs[i / 2] + 1;
}
for (int i = 0; i < maxN; i++) {
st[i][0] = euler[i];
}
for (int j = 1; j <= 30; j++) {
for (int i = 0; i + (1 << j) <= maxN; i++) {
st[i][j] = min_height(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
}
int lca(int u, int v) {
u = first[u];
v = first[v];
if (u > v)
swap(u, v);
int lg = logs[v - u + 1];
return min_height(st[u][lg], st[v - (1 << lg) + 1][lg]);
}
void dfs(vector<int> *g, int n, int depth) {
visited[n] = 1;
height[n] = depth;
first[n] = euler.size();
euler.push_back(n);
for (auto i : g[n]) {
if (!visited[i]) {
dfs(g, i, depth + 1);
euler.push_back(n);
}
}
}
LCA(vector<int> *g, int n) {
height = vector<int>(n);
visited = vector<bool>(n);
first = vector<int>(n);
dfs(g, 1, 0);
build_sparse(euler.size());
}
};
const int N = 1e5 + 7;
vector<int> conn[N];
vector<pair<int, pair<ll, ll>>> g[N];
pair<ll, ll> colors[N];
unordered_map<int, unordered_map<int, pair<ll, ll>>> mp;
ll dists[N];
bool visited[N];
struct query {
int u, v, x, y;
query(int u, int v, int x, int y) {
this->u = u;
this->v = v;
this->x = x;
this->y = y;
}
};
void dfs(int n, int cost = 0) {
dists[n] = cost;
visited[n] = 1;
for (auto c : mp[n]) {
mp[n][c.first] = colors[c.first];
}
for (auto i : g[n]) {
if (visited[i.first])
continue;
colors[i.second.first].first++;
colors[i.second.first].second += i.second.second;
dfs(i.first, cost + i.second.second);
colors[i.second.first].first--;
colors[i.second.first].second -= i.second.second;
}
}
int main() {
fastIO;
int n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < n - 1; i++) {
int u, v, c, d;
cin >> u >> v >> c >> d;
conn[u].push_back(v);
conn[v].push_back(u);
g[u].push_back({v, {c, d}});
g[v].push_back({u, {c, d}});
}
LCA lca(conn, n + 1);
vector<query> queries;
while (q--) {
int u, v, x, y;
cin >> x >> y >> u >> v;
mp[u][x] = {0, 0};
mp[v][x] = {0, 0};
mp[lca.lca(u, v)][x] = {0, 0};
queries.push_back(query(u, v, x, y));
}
dfs(1, 0);
for (auto i : queries) {
ll dist = dists[i.u] + dists[i.v] - 2 * dists[lca.lca(i.u, i.v)];
ll frq = mp[i.u][i.x].first + mp[i.v][i.x].first -
2 * mp[lca.lca(i.u, i.v)][i.x].first;
ll weight = mp[i.u][i.x].second + mp[i.v][i.x].second -
2 * mp[lca.lca(i.u, i.v)][i.x].second;
assert(weight <= dist);
cout << dist - weight + frq * i.y << '\n';
}
}
| replace | 29 | 30 | 29 | 30 | 0 | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
// #define endl "\n"
typedef long long ll;
using namespace std;
const int N = 2e5 + 10;
int n;
vector<int> g[N];
vector<int> e[N];
int sz[N], in[N], out[N], top[N], t, son[N];
;
int dep[N], par[N];
struct {
int u, v, w, c;
} edge[N];
int val[N]; // 本来是记录点权，此处改为记录点对应的边的编号
int wei[N];
int col[N];
struct T {
int val;
map<int, int> mp0;
map<int, int> mp1;
} tree[N];
void build(int k, int l, int r) {
if (l == r) {
tree[k].val = wei[l];
tree[k].mp0[col[l]]++;
tree[k].mp1[col[l]] += wei[l];
return;
}
int mid = (l + r) >> 1;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
tree[k].val = tree[2 * k].val + tree[2 * k + 1].val;
for (auto p : tree[2 * k].mp0)
tree[k].mp0[p.first] += p.second;
for (auto p : tree[2 * k + 1].mp0)
tree[k].mp0[p.first] += p.second;
for (auto p : tree[2 * k].mp1)
tree[k].mp1[p.first] += p.second;
for (auto p : tree[2 * k + 1].mp1)
tree[k].mp1[p.first] += p.second;
}
struct P {
int a, b, c;
};
P query(int k, int l, int r, int lef, int rig, int color) {
if (lef <= l && r <= rig) {
if (tree[k].mp0.count(color))
return {tree[k].val, tree[k].mp0[color], tree[k].mp1[color]};
else
return {tree[k].val, 0, 0};
}
P ans = {0, 0, 0};
int mid = (l + r) >> 1;
if (lef <= mid) {
auto t = query(k * 2, l, mid, lef, rig, color);
ans.a += t.a;
ans.b += t.b;
ans.c += t.c;
}
if (rig > mid) {
auto t = query(k * 2 + 1, mid + 1, r, lef, rig, color);
ans.a += t.a;
ans.b += t.b;
ans.c += t.c;
}
return ans;
}
// 注意v是引用！因为要swap
void dfs_sz(int u, int from) {
sz[u] = 1;
son[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int &v = g[u][i], &w = e[u][i];
if (v == from)
continue;
dep[v] = dep[u] + 1, par[v] = u;
dfs_sz(v, u);
sz[u] += sz[v];
val[v] = w;
if (sz[v] > sz[son[u]])
son[u] = v;
}
}
void dfs_hld(int u, int from) {
in[u] = ++t;
if (!son[u])
return;
top[son[u]] = top[u];
dfs_hld(son[u], u);
for (auto v : g[u]) {
if (v == from || v == son[u])
continue;
top[v] = v;
dfs_hld(v, u);
}
out[u] = t;
}
P querys(int x, int y, int color) {
P s = {0, 0, 0};
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]])
swap(x, y);
// 此处把区间映射到[in[top[x]],in[x]]!
auto p = query(1, 1, t, in[top[x]], in[x], color);
s.a += p.a;
s.b += p.b;
s.c += p.c;
x = par[top[x]];
}
if (in[x] > in[y])
swap(x, y);
// 此处把区间映射到[in[x],in[y]]!
// 因为这道题是对边的权值求解，然后处理方式是把边权映射到点下面的点上
// 所以最上面的点对应的边不在路径里，所以此处把区间映射到[in[x]+1,in[y]]
auto p = query(1, 1, t, in[x] + 1, in[y], color);
s.a += p.a;
s.b += p.b;
s.c += p.c;
return s;
}
void init(int root) {
top[root] = root, dep[root] = 1;
dfs_sz(root, -1), dfs_hld(root, -1);
}
int q;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n - 1; i++) {
int u, v, w, c;
cin >> u >> v >> c >> w;
g[u].push_back(v), g[v].push_back(u);
e[u].push_back(i), e[v].push_back(i);
edge[i] = {u, v, w, c};
}
init(1);
for (int i = 2; i <= n; i++) {
wei[in[i]] = edge[val[i]].w;
col[in[i]] = edge[val[i]].c;
}
build(1, 1, t);
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
auto p = querys(u, v, x);
cout << p.a - p.c + p.b * y << endl;
}
} | #include <bits/stdc++.h>
// #define endl "\n"
typedef long long ll;
using namespace std;
const int N = 2e5 + 10;
int n;
vector<int> g[N];
vector<int> e[N];
int sz[N], in[N], out[N], top[N], t, son[N];
;
int dep[N], par[N];
struct {
int u, v, w, c;
} edge[N];
int val[N]; // 本来是记录点权，此处改为记录点对应的边的编号
int wei[N];
int col[N];
struct T {
int val;
map<int, int> mp0;
map<int, int> mp1;
} tree[N * 4];
void build(int k, int l, int r) {
if (l == r) {
tree[k].val = wei[l];
tree[k].mp0[col[l]]++;
tree[k].mp1[col[l]] += wei[l];
return;
}
int mid = (l + r) >> 1;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
tree[k].val = tree[2 * k].val + tree[2 * k + 1].val;
for (auto p : tree[2 * k].mp0)
tree[k].mp0[p.first] += p.second;
for (auto p : tree[2 * k + 1].mp0)
tree[k].mp0[p.first] += p.second;
for (auto p : tree[2 * k].mp1)
tree[k].mp1[p.first] += p.second;
for (auto p : tree[2 * k + 1].mp1)
tree[k].mp1[p.first] += p.second;
}
struct P {
int a, b, c;
};
P query(int k, int l, int r, int lef, int rig, int color) {
if (lef <= l && r <= rig) {
if (tree[k].mp0.count(color))
return {tree[k].val, tree[k].mp0[color], tree[k].mp1[color]};
else
return {tree[k].val, 0, 0};
}
P ans = {0, 0, 0};
int mid = (l + r) >> 1;
if (lef <= mid) {
auto t = query(k * 2, l, mid, lef, rig, color);
ans.a += t.a;
ans.b += t.b;
ans.c += t.c;
}
if (rig > mid) {
auto t = query(k * 2 + 1, mid + 1, r, lef, rig, color);
ans.a += t.a;
ans.b += t.b;
ans.c += t.c;
}
return ans;
}
// 注意v是引用！因为要swap
void dfs_sz(int u, int from) {
sz[u] = 1;
son[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int &v = g[u][i], &w = e[u][i];
if (v == from)
continue;
dep[v] = dep[u] + 1, par[v] = u;
dfs_sz(v, u);
sz[u] += sz[v];
val[v] = w;
if (sz[v] > sz[son[u]])
son[u] = v;
}
}
void dfs_hld(int u, int from) {
in[u] = ++t;
if (!son[u])
return;
top[son[u]] = top[u];
dfs_hld(son[u], u);
for (auto v : g[u]) {
if (v == from || v == son[u])
continue;
top[v] = v;
dfs_hld(v, u);
}
out[u] = t;
}
P querys(int x, int y, int color) {
P s = {0, 0, 0};
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]])
swap(x, y);
// 此处把区间映射到[in[top[x]],in[x]]!
auto p = query(1, 1, t, in[top[x]], in[x], color);
s.a += p.a;
s.b += p.b;
s.c += p.c;
x = par[top[x]];
}
if (in[x] > in[y])
swap(x, y);
// 此处把区间映射到[in[x],in[y]]!
// 因为这道题是对边的权值求解，然后处理方式是把边权映射到点下面的点上
// 所以最上面的点对应的边不在路径里，所以此处把区间映射到[in[x]+1,in[y]]
auto p = query(1, 1, t, in[x] + 1, in[y], color);
s.a += p.a;
s.b += p.b;
s.c += p.c;
return s;
}
void init(int root) {
top[root] = root, dep[root] = 1;
dfs_sz(root, -1), dfs_hld(root, -1);
}
int q;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n - 1; i++) {
int u, v, w, c;
cin >> u >> v >> c >> w;
g[u].push_back(v), g[v].push_back(u);
e[u].push_back(i), e[v].push_back(i);
edge[i] = {u, v, w, c};
}
init(1);
for (int i = 2; i <= n; i++) {
wei[in[i]] = edge[val[i]].w;
col[in[i]] = edge[val[i]].c;
}
build(1, 1, t);
while (q--) {
int x, y, u, v;
cin >> x >> y >> u >> v;
auto p = querys(u, v, x);
cout << p.a - p.c + p.b * y << endl;
}
} | replace | 22 | 23 | 22 | 23 | 0 | |
p02986 | C++ | Runtime Error | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
const double EPS = 1e-8;
const int MAX = 1250;
int N, M, K, H, W, L, R;
// long long int N, M, K, H, W, L, R;
struct Edge {
int to, color, cost;
Edge(int c, int e, int f) { to = c, color = e, cost = f; }
};
int depth[100005];
int parent[100005][17];
class Lowest_Common_Ancestor {
vector<vector<int>> edge;
int height = 0;
int node;
public:
Lowest_Common_Ancestor(int num) {
num++;
node = num;
while (num) {
height++;
num /= 2;
}
edge.resize(node);
}
void Add_Edge(int a, int b) {
edge[a].push_back(b);
edge[b].push_back(a);
return;
}
void Update(int rtnode) {
queue<int> QQ;
for (int i = 0; i < node; i++)
depth[i] = INT_MAX;
depth[rtnode] = 0;
QQ.push(rtnode);
while (!QQ.empty()) {
int c = QQ.front();
for (auto i : edge[c]) {
if (depth[i] > depth[c] + 1) {
depth[i] = depth[c] + 1;
QQ.push(i);
}
}
QQ.pop();
}
parent[rtnode][0] = -1;
for (int i = 1; i < node; i++) {
for (auto j : edge[i]) {
if (depth[i] - 1 == depth[j]) {
parent[i][0] = j;
break;
}
}
}
for (int i = 0; i < height - 1; i++) {
for (int j = 0; j < node; j++) {
if (parent[j][i] < 0)
parent[j][i + 1] = -1;
else
parent[j][i + 1] = parent[parent[j][i]][i];
}
}
return;
}
inline int LCA(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int i = 0; i < height; i++) {
if ((depth[v] - depth[u]) >> i & 1) {
v = parent[v][i];
if (depth[v] == depth[u])
break;
}
}
if (u == v)
return u;
for (int i = height - 1; i >= 0; i--) {
if (parent[v][i] != parent[u][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[u][0];
}
int Dist(int u, int v) { return depth[u] + depth[v] - depth[LCA(u, v)] * 2; }
};
struct CEdge {
int from, to, cost;
CEdge(int a, int b, int d) { from = a, to = b, cost = d; }
};
struct Query {
int color, cost, l, r;
Query(int a, int b, int c, int d) { color = a, cost = b, l = c, r = d; }
};
int num[100000][MAX];
int dis[100000][MAX];
int converter[100000];
int all_dis[100000];
int qnum[100000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
for (int i = 0; i < N; i++)
converter[i] = -1;
vector<pair<long long int, int>> e_num(N - 1);
vector<vector<Edge>> edge(N);
vector<vector<CEdge>> cedge(N);
Lowest_Common_Ancestor lca(N);
for (int i = 1; i < N; i++) {
cin >> L >> R >> H >> W;
L--, R--, H--;
lca.Add_Edge(L, R);
edge[L].push_back(Edge(R, H, W));
edge[R].push_back(Edge(L, H, W));
}
vector<Query> q;
for (int i = 0; i < K; i++) {
cin >> H >> W >> L >> R;
H--, L--, R--;
qnum[H]++;
q.push_back(Query(H, W, L, R));
}
lca.Update(0);
for (int i = 0; i < N; i++) {
for (auto j : edge[i]) {
if (depth[i] < depth[j.to]) {
cedge[j.color].push_back(CEdge(i, j.to, j.cost));
}
}
}
for (int i = 0; i < N; i++) {
e_num[i].second = i;
e_num[i].first = (long long int)cedge[i].size();
e_num[i].first *= qnum[i];
}
sort(e_num.begin(), e_num.end());
reverse(e_num.begin(), e_num.end());
int prec = 0;
for (int i = 0; i < N; i++) {
converter[e_num[i].second] = i;
if (i >= min(MAX, N) || !e_num[i].first) {
converter[e_num[i].second] -= 10000000;
} else
prec = i;
}
queue<int> Q;
Q.push(0);
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto j : edge[cn]) {
if (depth[cn] > depth[j.to])
continue;
Q.push(j.to);
for (int i = 0; i <= prec; i++) {
dis[j.to][i] = dis[cn][i];
num[j.to][i] = num[cn][i];
}
if (converter[j.color] >= 0) {
dis[j.to][converter[j.color]] += j.cost;
num[j.to][converter[j.color]]++;
}
}
}
Q.push(0);
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto i : edge[cn]) {
if (depth[cn] > depth[i.to])
continue;
all_dis[i.to] = all_dis[cn] + i.cost;
Q.push(i.to);
}
}
for (int i = 0; i < K; i++) {
H = q[i].color;
W = q[i].cost;
L = q[i].l;
R = q[i].r;
if (converter[H] < 0) {
int c = lca.LCA(L, R);
int ans = all_dis[L] + all_dis[R];
ans -= all_dis[c] * 2;
for (int i = 0; i < cedge[H].size(); i++) {
if (lca.LCA(cedge[H][i].to, L) == cedge[H][i].to &&
(lca.LCA(cedge[H][i].to, c)) == c)
ans += W - cedge[H][i].cost;
else if (lca.LCA(cedge[H][i].to, R) == cedge[H][i].to &&
(lca.LCA(cedge[H][i].to, c)) == c)
ans += W - cedge[H][i].cost;
}
cout << ans << "\n";
} else {
int c = lca.LCA(L, R);
int ans = all_dis[L] + all_dis[R];
ans -= all_dis[c] * 2;
int index = converter[H];
int add = num[L][index] + num[R][index] - num[c][index] * 2;
add *= W;
ans += add;
ans -= dis[L][index] + dis[R][index] - dis[c][index] * 2;
cout << ans << "\n";
}
}
}
| #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
// const long long int MOD = 1000000007;
const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
const double EPS = 1e-8;
const int MAX = 1250;
int N, M, K, H, W, L, R;
// long long int N, M, K, H, W, L, R;
struct Edge {
int to, color, cost;
Edge(int c, int e, int f) { to = c, color = e, cost = f; }
};
int depth[100005];
int parent[100005][17];
class Lowest_Common_Ancestor {
vector<vector<int>> edge;
int height = 0;
int node;
public:
Lowest_Common_Ancestor(int num) {
num++;
node = num;
while (num) {
height++;
num /= 2;
}
edge.resize(node);
}
void Add_Edge(int a, int b) {
edge[a].push_back(b);
edge[b].push_back(a);
return;
}
void Update(int rtnode) {
queue<int> QQ;
for (int i = 0; i < node; i++)
depth[i] = INT_MAX;
depth[rtnode] = 0;
QQ.push(rtnode);
while (!QQ.empty()) {
int c = QQ.front();
for (auto i : edge[c]) {
if (depth[i] > depth[c] + 1) {
depth[i] = depth[c] + 1;
QQ.push(i);
}
}
QQ.pop();
}
parent[rtnode][0] = -1;
for (int i = 1; i < node; i++) {
for (auto j : edge[i]) {
if (depth[i] - 1 == depth[j]) {
parent[i][0] = j;
break;
}
}
}
for (int i = 0; i < height - 1; i++) {
for (int j = 0; j < node; j++) {
if (parent[j][i] < 0)
parent[j][i + 1] = -1;
else
parent[j][i + 1] = parent[parent[j][i]][i];
}
}
return;
}
inline int LCA(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int i = 0; i < height; i++) {
if ((depth[v] - depth[u]) >> i & 1) {
v = parent[v][i];
if (depth[v] == depth[u])
break;
}
}
if (u == v)
return u;
for (int i = height - 1; i >= 0; i--) {
if (parent[v][i] != parent[u][i]) {
u = parent[u][i];
v = parent[v][i];
}
}
return parent[u][0];
}
int Dist(int u, int v) { return depth[u] + depth[v] - depth[LCA(u, v)] * 2; }
};
struct CEdge {
int from, to, cost;
CEdge(int a, int b, int d) { from = a, to = b, cost = d; }
};
struct Query {
int color, cost, l, r;
Query(int a, int b, int c, int d) { color = a, cost = b, l = c, r = d; }
};
int num[100000][MAX];
int dis[100000][MAX];
int converter[100000];
int all_dis[100000];
int qnum[100000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
for (int i = 0; i < N; i++)
converter[i] = -1;
vector<pair<long long int, int>> e_num(N);
vector<vector<Edge>> edge(N);
vector<vector<CEdge>> cedge(N);
Lowest_Common_Ancestor lca(N);
for (int i = 1; i < N; i++) {
cin >> L >> R >> H >> W;
L--, R--, H--;
lca.Add_Edge(L, R);
edge[L].push_back(Edge(R, H, W));
edge[R].push_back(Edge(L, H, W));
}
vector<Query> q;
for (int i = 0; i < K; i++) {
cin >> H >> W >> L >> R;
H--, L--, R--;
qnum[H]++;
q.push_back(Query(H, W, L, R));
}
lca.Update(0);
for (int i = 0; i < N; i++) {
for (auto j : edge[i]) {
if (depth[i] < depth[j.to]) {
cedge[j.color].push_back(CEdge(i, j.to, j.cost));
}
}
}
for (int i = 0; i < N; i++) {
e_num[i].second = i;
e_num[i].first = (long long int)cedge[i].size();
e_num[i].first *= qnum[i];
}
sort(e_num.begin(), e_num.end());
reverse(e_num.begin(), e_num.end());
int prec = 0;
for (int i = 0; i < N; i++) {
converter[e_num[i].second] = i;
if (i >= min(MAX, N) || !e_num[i].first) {
converter[e_num[i].second] -= 10000000;
} else
prec = i;
}
queue<int> Q;
Q.push(0);
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto j : edge[cn]) {
if (depth[cn] > depth[j.to])
continue;
Q.push(j.to);
for (int i = 0; i <= prec; i++) {
dis[j.to][i] = dis[cn][i];
num[j.to][i] = num[cn][i];
}
if (converter[j.color] >= 0) {
dis[j.to][converter[j.color]] += j.cost;
num[j.to][converter[j.color]]++;
}
}
}
Q.push(0);
while (!Q.empty()) {
int cn = Q.front();
Q.pop();
for (auto i : edge[cn]) {
if (depth[cn] > depth[i.to])
continue;
all_dis[i.to] = all_dis[cn] + i.cost;
Q.push(i.to);
}
}
for (int i = 0; i < K; i++) {
H = q[i].color;
W = q[i].cost;
L = q[i].l;
R = q[i].r;
if (converter[H] < 0) {
int c = lca.LCA(L, R);
int ans = all_dis[L] + all_dis[R];
ans -= all_dis[c] * 2;
for (int i = 0; i < cedge[H].size(); i++) {
if (lca.LCA(cedge[H][i].to, L) == cedge[H][i].to &&
(lca.LCA(cedge[H][i].to, c)) == c)
ans += W - cedge[H][i].cost;
else if (lca.LCA(cedge[H][i].to, R) == cedge[H][i].to &&
(lca.LCA(cedge[H][i].to, c)) == c)
ans += W - cedge[H][i].cost;
}
cout << ans << "\n";
} else {
int c = lca.LCA(L, R);
int ans = all_dis[L] + all_dis[R];
ans -= all_dis[c] * 2;
int index = converter[H];
int add = num[L][index] + num[R][index] - num[c][index] * 2;
add *= W;
ans += add;
ans -= dis[L][index] + dis[R][index] - dis[c][index] * 2;
cout << ans << "\n";
}
}
}
| replace | 141 | 142 | 141 | 142 | -11 | |
p02986 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 100001; // check the limits, dummy
vector<vpi> graph;
int level[MX];
int parent[MX];
bool special[MX];
bool checked[MX];
vpi edgeData;
vi parentEdge;
vector<map<int, pi>> colorData;
map<int, pi> curColors;
int lcaData[MX][18];
int dist[MX];
void dfs1(int v, int p) {
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
level[nxt] = level[v] + 1;
parent[nxt] = v;
parentEdge[nxt] = graph[v][i].s;
dist[nxt] = dist[v] + edgeData[parentEdge[nxt]].s;
dfs1(nxt, v);
}
}
void dfs2(int v, int p) {
if (special[v]) {
colorData[v] = curColors;
}
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
int ind = graph[v][i].s;
int col = edgeData[ind].f;
int dist = edgeData[ind].s;
if (!curColors.count(col)) {
curColors.insert(mp(col, mp(0, 0)));
}
curColors[col].f++;
curColors[col].s += dist;
dfs2(nxt, v);
curColors[col].f--;
curColors[col].s -= dist;
if (curColors[col].f == 0) {
curColors.erase(col);
}
}
}
void dfs3(int v, int p) {
lcaData[v][0] = p;
FOR(i, 1, 18) {
if (lcaData[v][i - 1] != -1) {
lcaData[v][i] = lcaData[lcaData[v][i - 1]][i - 1];
}
}
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
dfs3(nxt, v);
}
}
int lca(int u, int v) {
if (level[u] < level[v]) {
swap(u, v);
}
F0Rd(i, 18) {
if (level[u] - (1 << i) >= level[v]) {
u = lcaData[u][i];
}
}
if (u == v)
return u;
F0Rd(i, 18) {
if (lcaData[u][i] != -1 && lcaData[v][i] != -1 &&
lcaData[u][i] != lcaData[v][i]) {
u = lcaData[u][i];
v = lcaData[v][i];
}
}
return lcaData[u][0];
}
pi getData(int v, int color) {
if (special[v]) {
if (!colorData[v].count(color)) {
return mp(0, 0);
} else {
return colorData[v][color];
}
}
pi prev = getData(parent[v], color);
int ind = parentEdge[v];
if (edgeData[ind].f == color) {
prev.f++;
prev.s += edgeData[ind].s;
}
return prev;
}
int rootDist(int v, pi data, int newLen) {
return dist[v] - data.s + data.f * newLen;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
int Q;
cin >> Q;
F0R(i, N) {
vpi blank;
graph.pb(blank);
parentEdge.pb(0);
}
F0R(i, N - 1) {
int A, B, C, D;
cin >> A >> B >> C >> D;
A--;
B--;
edgeData.pb(mp(C, D));
graph[A].pb(mp(B, i));
graph[B].pb(mp(A, i));
}
parent[0] = -1;
level[0] = 0;
dist[0] = 0;
dfs1(0, -1);
priority_queue<pi> pq;
F0R(i, N) { pq.push(mp(level[i], i)); }
F0R(i, N) {
special[i] = false;
checked[i] = false;
}
special[0] = true;
checked[0] = true;
while (!pq.empty()) {
int cur = pq.top().s;
pq.pop();
if (!pq.empty())
assert(level[cur] <= pq.top().f);
if (checked[cur])
continue;
F0R(i, 350) {
cur = parent[cur];
if (special[cur])
goto done;
checked[cur] = true;
}
special[cur] = true;
done:;
}
F0R(i, N) {
map<int, pi> blank;
colorData.pb(blank);
}
dfs2(0, -1);
F0R(i, N) {
F0R(j, 18) { lcaData[i][j] = -1; }
}
dfs3(0, -1);
F0R(query, Q) {
int A, B, C, D;
cin >> A >> B >> C >> D;
C--;
D--;
int E = lca(C, D);
cout << rootDist(C, getData(C, A), B) + rootDist(D, getData(D, A), B) -
2 * rootDist(E, getData(E, A), B)
<< endl;
}
return 0;
}
// read the question correctly (ll vs int)
// template by bqi343
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T>
using Tree =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
const int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 100001; // check the limits, dummy
vector<vpi> graph;
int level[MX];
int parent[MX];
bool special[MX];
bool checked[MX];
vpi edgeData;
vi parentEdge;
vector<map<int, pi>> colorData;
map<int, pi> curColors;
int lcaData[MX][18];
int dist[MX];
void dfs1(int v, int p) {
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
level[nxt] = level[v] + 1;
parent[nxt] = v;
parentEdge[nxt] = graph[v][i].s;
dist[nxt] = dist[v] + edgeData[parentEdge[nxt]].s;
dfs1(nxt, v);
}
}
void dfs2(int v, int p) {
if (special[v]) {
colorData[v] = curColors;
}
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
int ind = graph[v][i].s;
int col = edgeData[ind].f;
int dist = edgeData[ind].s;
if (!curColors.count(col)) {
curColors.insert(mp(col, mp(0, 0)));
}
curColors[col].f++;
curColors[col].s += dist;
dfs2(nxt, v);
curColors[col].f--;
curColors[col].s -= dist;
if (curColors[col].f == 0) {
curColors.erase(col);
}
}
}
void dfs3(int v, int p) {
lcaData[v][0] = p;
FOR(i, 1, 18) {
if (lcaData[v][i - 1] != -1) {
lcaData[v][i] = lcaData[lcaData[v][i - 1]][i - 1];
}
}
F0R(i, sz(graph[v])) {
int nxt = graph[v][i].f;
if (nxt == p)
continue;
dfs3(nxt, v);
}
}
int lca(int u, int v) {
if (level[u] < level[v]) {
swap(u, v);
}
F0Rd(i, 18) {
if (level[u] - (1 << i) >= level[v]) {
u = lcaData[u][i];
}
}
if (u == v)
return u;
F0Rd(i, 18) {
if (lcaData[u][i] != -1 && lcaData[v][i] != -1 &&
lcaData[u][i] != lcaData[v][i]) {
u = lcaData[u][i];
v = lcaData[v][i];
}
}
return lcaData[u][0];
}
pi getData(int v, int color) {
if (special[v]) {
if (!colorData[v].count(color)) {
return mp(0, 0);
} else {
return colorData[v][color];
}
}
pi prev = getData(parent[v], color);
int ind = parentEdge[v];
if (edgeData[ind].f == color) {
prev.f++;
prev.s += edgeData[ind].s;
}
return prev;
}
int rootDist(int v, pi data, int newLen) {
return dist[v] - data.s + data.f * newLen;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
int Q;
cin >> Q;
F0R(i, N) {
vpi blank;
graph.pb(blank);
parentEdge.pb(0);
}
F0R(i, N - 1) {
int A, B, C, D;
cin >> A >> B >> C >> D;
A--;
B--;
edgeData.pb(mp(C, D));
graph[A].pb(mp(B, i));
graph[B].pb(mp(A, i));
}
parent[0] = -1;
level[0] = 0;
dist[0] = 0;
dfs1(0, -1);
priority_queue<pi> pq;
F0R(i, N) { pq.push(mp(level[i], i)); }
F0R(i, N) {
special[i] = false;
checked[i] = false;
}
special[0] = true;
checked[0] = true;
while (!pq.empty()) {
int cur = pq.top().s;
pq.pop();
if (!pq.empty())
assert(level[cur] >= pq.top().f);
if (checked[cur])
continue;
F0R(i, 350) {
cur = parent[cur];
if (special[cur])
goto done;
checked[cur] = true;
}
special[cur] = true;
done:;
}
F0R(i, N) {
map<int, pi> blank;
colorData.pb(blank);
}
dfs2(0, -1);
F0R(i, N) {
F0R(j, 18) { lcaData[i][j] = -1; }
}
dfs3(0, -1);
F0R(query, Q) {
int A, B, C, D;
cin >> A >> B >> C >> D;
C--;
D--;
int E = lca(C, D);
cout << rootDist(C, getData(C, A), B) + rootDist(D, getData(D, A), B) -
2 * rootDist(E, getData(E, A), B)
<< endl;
}
return 0;
}
// read the question correctly (ll vs int)
// template by bqi343
| replace | 199 | 200 | 199 | 200 | -6 | 32ba53b0-8e6c-4e32-b74e-cc0b76de43d8.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02986/C++/s466543180.cpp:185: int main(): Assertion `level[cur] <= pq.top().f' failed.
|
p02986 | C++ | Runtime Error | /*
luogu AT4809
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define mid (l + r >> 1)
int n, q;
int ee, h[100005], nex[100005 << 1], to[100005 << 1], val[100005 << 1],
col[100005 << 1];
int dis[100005], v[100005], c[100005];
int dfn, mark[100005], fa[100005], son[100005], dep[100005], top[100005],
siz[100005];
int cnt, root[100005];
struct segtree {
int l, r;
int num, sum;
void init() { num = sum = 0; }
segtree operator+(segtree b) {
segtree res;
res.num = num + b.num;
res.sum = sum + b.sum;
return res;
}
} dat[100005 << 2];
void addedge(int x, int y, int z, int w) {
nex[++ee] = h[x];
to[ee] = y;
val[ee] = z;
col[ee] = w;
h[x] = ee;
}
void dfs1(int x, int pre) {
siz[x] = 1;
fa[x] = pre;
dep[x] = dep[pre] + 1;
for (int i = h[x]; i; i = nex[i])
if (to[i] != pre) {
v[to[i]] = val[i], c[to[i]] = col[i];
dis[to[i]] = dis[x] + val[i];
dfs1(to[i], x);
if (siz[to[i]] > siz[son[x]])
son[x] = to[i];
siz[x] += siz[to[i]];
}
}
void dfs2(int x, int tp) {
mark[x] = ++dfn;
top[x] = tp;
if (!son[x])
return;
dfs2(son[x], tp);
for (int i = h[x]; i; i = nex[i])
if (to[i] != fa[x] && to[i] != son[x])
dfs2(to[i], to[i]);
}
void modify(int &o, int l, int r, int x, int v) {
if (!o)
o = ++cnt;
dat[o].num++;
dat[o].sum += v;
if (l == x && r == x)
return;
if (x <= mid)
modify(dat[o].l, l, mid, x, v);
else
modify(dat[o].r, mid + 1, r, x, v);
}
segtree query(int o, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr)
return dat[o];
segtree res;
res.init();
if (ql <= mid)
res = res + query(dat[o].l, l, mid, ql, qr);
if (qr > mid)
res = res + query(dat[o].r, mid + 1, r, ql, qr);
return res;
}
int query_(int c, int x, int y, int d) {
int l = dis[x] + dis[y];
segtree res;
res.init();
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]])
swap(x, y);
res = res + query(root[c], 1, n, mark[top[x]], mark[x]);
x = fa[top[x]];
}
if (dep[x] < dep[y])
swap(x, y);
if (x != y)
res = res + query(root[c], 1, n, mark[y] + 1, mark[x]);
return l - 2 * dis[y] - res.sum + res.num * d;
}
signed main() {
cin >> n >> q;
for (int i = 1, x, y, z, w;
i < n && scanf("%lld %lld %lld %lld", &x, &y, &z, &w); i++)
addedge(x, y, w, z), addedge(y, x, w, z);
dfs1(1, 0), dfs2(1, 1);
for (int i = 2; i <= n; i++)
modify(root[c[i]], 1, n, mark[i], v[i]);
while (q--) {
int c, d, x, y;
scanf("%lld %lld %lld %lld", &c, &d, &x, &y);
printf("%lld\n", query_(c, x, y, d));
}
return 0;
} | /*
luogu AT4809
*/
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define mid (l + r >> 1)
int n, q;
int ee, h[100005], nex[100005 << 1], to[100005 << 1], val[100005 << 1],
col[100005 << 1];
int dis[100005], v[100005], c[100005];
int dfn, mark[100005], fa[100005], son[100005], dep[100005], top[100005],
siz[100005];
int cnt, root[100005];
struct segtree {
int l, r;
int num, sum;
void init() { num = sum = 0; }
segtree operator+(segtree b) {
segtree res;
res.num = num + b.num;
res.sum = sum + b.sum;
return res;
}
} dat[100005 << 5];
void addedge(int x, int y, int z, int w) {
nex[++ee] = h[x];
to[ee] = y;
val[ee] = z;
col[ee] = w;
h[x] = ee;
}
void dfs1(int x, int pre) {
siz[x] = 1;
fa[x] = pre;
dep[x] = dep[pre] + 1;
for (int i = h[x]; i; i = nex[i])
if (to[i] != pre) {
v[to[i]] = val[i], c[to[i]] = col[i];
dis[to[i]] = dis[x] + val[i];
dfs1(to[i], x);
if (siz[to[i]] > siz[son[x]])
son[x] = to[i];
siz[x] += siz[to[i]];
}
}
void dfs2(int x, int tp) {
mark[x] = ++dfn;
top[x] = tp;
if (!son[x])
return;
dfs2(son[x], tp);
for (int i = h[x]; i; i = nex[i])
if (to[i] != fa[x] && to[i] != son[x])
dfs2(to[i], to[i]);
}
void modify(int &o, int l, int r, int x, int v) {
if (!o)
o = ++cnt;
dat[o].num++;
dat[o].sum += v;
if (l == x && r == x)
return;
if (x <= mid)
modify(dat[o].l, l, mid, x, v);
else
modify(dat[o].r, mid + 1, r, x, v);
}
segtree query(int o, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr)
return dat[o];
segtree res;
res.init();
if (ql <= mid)
res = res + query(dat[o].l, l, mid, ql, qr);
if (qr > mid)
res = res + query(dat[o].r, mid + 1, r, ql, qr);
return res;
}
int query_(int c, int x, int y, int d) {
int l = dis[x] + dis[y];
segtree res;
res.init();
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]])
swap(x, y);
res = res + query(root[c], 1, n, mark[top[x]], mark[x]);
x = fa[top[x]];
}
if (dep[x] < dep[y])
swap(x, y);
if (x != y)
res = res + query(root[c], 1, n, mark[y] + 1, mark[x]);
return l - 2 * dis[y] - res.sum + res.num * d;
}
signed main() {
cin >> n >> q;
for (int i = 1, x, y, z, w;
i < n && scanf("%lld %lld %lld %lld", &x, &y, &z, &w); i++)
addedge(x, y, w, z), addedge(y, x, w, z);
dfs1(1, 0), dfs2(1, 1);
for (int i = 2; i <= n; i++)
modify(root[c[i]], 1, n, mark[i], v[i]);
while (q--) {
int c, d, x, y;
scanf("%lld %lld %lld %lld", &c, &d, &x, &y);
printf("%lld\n", query_(c, x, y, d));
}
return 0;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p02986 | C++ | Runtime Error | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
struct LCA {
static const int MAX_LOG_V = 21;
vector<vector<int>> G;
vector<vector<int>> parent;
vector<int> depth;
LCA(int size) {
G = vector<vector<int>>(size);
parent = vector<vector<int>>(MAX_LOG_V, vector<int>(size));
depth = vector<int>(size);
}
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (int i = 0; i < G[v].size(); i++) {
if (G[v][i] != p)
dfs(G[v][i], v, d + 1);
}
}
void init(int root, int V) {
dfs(root, -1, 0);
for (int k = 0; k + 1 < MAX_LOG_V; k++) {
for (int v = 0; v < V; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int k = 0; k < MAX_LOG_V; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = MAX_LOG_V - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class FColorfulTree {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
vector<vector<vector<int>>> G;
vector<int> dist, cnum, csum;
vector<vector<int>> C;
vector<map<int, int>> num, sum;
void dfs(int v, int p = -1) {
for (auto c : C[v]) {
num[v][c] = cnum[c];
sum[v][c] = csum[c];
}
REP(i, G[v].size()) {
int to = G[v][i][0];
int c = G[v][i][1];
int d = G[v][i][2];
if (to == p)
continue;
dist[to] = dist[v] + d;
cnum[c]++;
csum[c] += d;
dfs(to, v);
cnum[c]--;
csum[c] -= d;
}
}
void solve(std::istream &cin, std::ostream &cout) {
int N, Q;
cin >> N >> Q;
dist.resize(10005);
G.resize(10005);
C.resize(10005);
cnum.resize(10005);
csum.resize(10005);
vector<int> X(10005), Y(10005), U(10005), V(10005), L(10005);
num = vector<map<int, int>>(10005);
sum = vector<map<int, int>>(10005);
LCA lca(N);
REP(i, N - 1) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--, b--, c--;
G[a].push_back({b, c, d});
G[b].push_back({a, c, d});
lca.G[a].push_back(b);
lca.G[b].push_back(a);
}
lca.init(0, N);
REP(i, Q) {
int x, y, u, v;
cin >> x >> y >> u >> v;
x--, u--, v--;
X[i] = x;
Y[i] = y;
U[i] = u;
V[i] = v;
int l = lca.get(u, v);
L[i] = l;
C[l].push_back(x);
C[u].push_back(x);
C[v].push_back(x);
}
dfs(0);
REP(i, Q) {
int u = U[i];
int v = V[i];
int l = L[i];
int x = X[i];
int y = Y[i];
int d = dist[u] + dist[v] - 2 * dist[l];
int n = num[u][x] + num[v][x] - 2 * num[l][x];
int s = sum[u][x] + sum[v][x] - 2 * sum[l][x];
cout << d - s + n * y << endl;
}
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FColorfulTree solver;
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author tatsumack
*/
#include <fstream>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)
using namespace std;
typedef pair<int, int> P;
struct LCA {
static const int MAX_LOG_V = 21;
vector<vector<int>> G;
vector<vector<int>> parent;
vector<int> depth;
LCA(int size) {
G = vector<vector<int>>(size);
parent = vector<vector<int>>(MAX_LOG_V, vector<int>(size));
depth = vector<int>(size);
}
void dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (int i = 0; i < G[v].size(); i++) {
if (G[v][i] != p)
dfs(G[v][i], v, d + 1);
}
}
void init(int root, int V) {
dfs(root, -1, 0);
for (int k = 0; k + 1 < MAX_LOG_V; k++) {
for (int v = 0; v < V; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
int get(int u, int v) {
if (depth[u] > depth[v])
swap(u, v);
for (int k = 0; k < MAX_LOG_V; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v)
return u;
for (int k = MAX_LOG_V - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class FColorfulTree {
public:
static constexpr int kStressIterations = 0;
static void generateTest(std::ostream &test) {}
vector<vector<vector<int>>> G;
vector<int> dist, cnum, csum;
vector<vector<int>> C;
vector<map<int, int>> num, sum;
void dfs(int v, int p = -1) {
for (auto c : C[v]) {
num[v][c] = cnum[c];
sum[v][c] = csum[c];
}
REP(i, G[v].size()) {
int to = G[v][i][0];
int c = G[v][i][1];
int d = G[v][i][2];
if (to == p)
continue;
dist[to] = dist[v] + d;
cnum[c]++;
csum[c] += d;
dfs(to, v);
cnum[c]--;
csum[c] -= d;
}
}
void solve(std::istream &cin, std::ostream &cout) {
int N, Q;
cin >> N >> Q;
dist.resize(100005);
G.resize(100005);
C.resize(100005);
cnum.resize(100005);
csum.resize(100005);
vector<int> X(100005), Y(100005), U(100005), V(100005), L(100005);
num = vector<map<int, int>>(100005);
sum = vector<map<int, int>>(100005);
LCA lca(N);
REP(i, N - 1) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--, b--, c--;
G[a].push_back({b, c, d});
G[b].push_back({a, c, d});
lca.G[a].push_back(b);
lca.G[b].push_back(a);
}
lca.init(0, N);
REP(i, Q) {
int x, y, u, v;
cin >> x >> y >> u >> v;
x--, u--, v--;
X[i] = x;
Y[i] = y;
U[i] = u;
V[i] = v;
int l = lca.get(u, v);
L[i] = l;
C[l].push_back(x);
C[u].push_back(x);
C[v].push_back(x);
}
dfs(0);
REP(i, Q) {
int u = U[i];
int v = V[i];
int l = L[i];
int x = X[i];
int y = Y[i];
int d = dist[u] + dist[v] - 2 * dist[l];
int n = num[u][x] + num[v][x] - 2 * num[l][x];
int s = sum[u][x] + sum[v][x] - 2 * sum[l][x];
cout << d - s + n * y << endl;
}
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
std::istream &in(std::cin);
std::ostream &out(std::cout);
FColorfulTree solver;
solver.solve(in, out);
return 0;
}
| replace | 144 | 152 | 144 | 152 | 0 | |
p02986 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
// #include<unordered_set>
using namespace std;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
st;*/
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#define pb push_back
#define ld long double
#define int long long
mt19937 rnd(51);
const int N = 1e5 + 10;
vector<pair<int, pair<int, int>>> g[N];
vector<map<int, pair<int, int>>> mp(N);
vector<int> ans;
vector<bool> used(N);
vector<int> ind(N);
vector<int> d(N);
vector<pair<int, int>> t(4 * N, {1e18, 1e18});
vector<set<int>> color(N);
vector<int> num(N);
vector<int> cnt(N);
vector<int> dl(N);
void dfs(int v) {
used[v] = 1;
ind[v] = ans.size();
ans.pb(v);
for (auto to : g[v]) {
if (!used[to.first]) {
d[to.first] = d[v] + 1;
dl[to.first] = dl[v] + to.second.second;
dfs(to.first);
ans.pb(v);
}
}
}
void build(int v, int l, int r) {
if (l == r) {
t[v] = {d[ans[l]], ans[l]};
return;
}
int m = (l + r) / 2;
build(2 * v, l, m), build(2 * v + 1, m + 1, r);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
pair<int, int> mn(int v, int tl, int tr, int l, int r) {
if (l > r) {
return {1e18, 1e18};
}
if (tl == l && tr == r) {
return t[v];
}
int tm = (tl + tr) / 2;
return min(mn(2 * v, tl, tm, l, min(r, tm)),
mn(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
void zfhs(int v) {
used[v] = 1;
for (auto to : g[v]) {
if (!used[to.first]) {
num[to.second.first] += to.second.second;
cnt[to.second.first]++;
zfhs(to.first);
cnt[to.second.first]--;
num[to.second.first] -= to.second.second;
}
}
for (auto to : color[v]) {
mp[v][to] = {num[to], cnt[to]};
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<pair<int, int>, pair<int, int>>> kek;
vector<int> lol;
int n, q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
g[a].pb({b, {c, d}});
g[b].pb({a, {c, d}});
}
dfs(1);
build(1, 0, ans.size() - 1);
for (int i = 0; i < q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
int g = mn(1, 0, ans.size() - 1, min(ind[u], ind[v]), max(ind[u], ind[v]))
.second;
color[g].insert(x);
color[u].insert(x);
color[v].insert(x);
kek.pb({{x, y}, {u, v}});
lol.pb(g);
}
fill(used.begin(), used.end(), 0);
zfhs(1);
for (int i = 0; i < kek.size(); i++) {
auto to = kek[i];
int u = kek[i].second.first, v = kek[i].second.second, g = lol[i];
int mx = dl[u] + dl[v] - 2 * dl[g];
mx -= mp[u][to.first.first].first + mp[v][to.first.first].first -
2 * mp[g][to.first.first].first;
mx += (mp[u][to.first.first].second + mp[v][to.first.first].second -
2 * mp[g][to.first.first].second) *
kek[i].first.second;
cout << mx << endl;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
// #include<unordered_set>
using namespace std;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
st;*/
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#define pb push_back
#define ld long double
#define int long long
mt19937 rnd(51);
const int N = 1e5 + 10;
vector<pair<int, pair<int, int>>> g[N];
vector<map<int, pair<int, int>>> mp(N);
vector<int> ans;
vector<bool> used(N);
vector<int> ind(N);
vector<int> d(N);
vector<pair<int, int>> t(8 * N, {1e18, 1e18});
vector<set<int>> color(N);
vector<int> num(N);
vector<int> cnt(N);
vector<int> dl(N);
void dfs(int v) {
used[v] = 1;
ind[v] = ans.size();
ans.pb(v);
for (auto to : g[v]) {
if (!used[to.first]) {
d[to.first] = d[v] + 1;
dl[to.first] = dl[v] + to.second.second;
dfs(to.first);
ans.pb(v);
}
}
}
void build(int v, int l, int r) {
if (l == r) {
t[v] = {d[ans[l]], ans[l]};
return;
}
int m = (l + r) / 2;
build(2 * v, l, m), build(2 * v + 1, m + 1, r);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
pair<int, int> mn(int v, int tl, int tr, int l, int r) {
if (l > r) {
return {1e18, 1e18};
}
if (tl == l && tr == r) {
return t[v];
}
int tm = (tl + tr) / 2;
return min(mn(2 * v, tl, tm, l, min(r, tm)),
mn(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
void zfhs(int v) {
used[v] = 1;
for (auto to : g[v]) {
if (!used[to.first]) {
num[to.second.first] += to.second.second;
cnt[to.second.first]++;
zfhs(to.first);
cnt[to.second.first]--;
num[to.second.first] -= to.second.second;
}
}
for (auto to : color[v]) {
mp[v][to] = {num[to], cnt[to]};
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<pair<int, int>, pair<int, int>>> kek;
vector<int> lol;
int n, q;
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
g[a].pb({b, {c, d}});
g[b].pb({a, {c, d}});
}
dfs(1);
build(1, 0, ans.size() - 1);
for (int i = 0; i < q; i++) {
int x, y, u, v;
cin >> x >> y >> u >> v;
int g = mn(1, 0, ans.size() - 1, min(ind[u], ind[v]), max(ind[u], ind[v]))
.second;
color[g].insert(x);
color[u].insert(x);
color[v].insert(x);
kek.pb({{x, y}, {u, v}});
lol.pb(g);
}
fill(used.begin(), used.end(), 0);
zfhs(1);
for (int i = 0; i < kek.size(); i++) {
auto to = kek[i];
int u = kek[i].second.first, v = kek[i].second.second, g = lol[i];
int mx = dl[u] + dl[v] - 2 * dl[g];
mx -= mp[u][to.first.first].first + mp[v][to.first.first].first -
2 * mp[g][to.first.first].first;
mx += (mp[u][to.first.first].second + mp[v][to.first.first].second -
2 * mp[g][to.first.first].second) *
kek[i].first.second;
cout << mx << endl;
}
return 0;
}
| replace | 39 | 40 | 39 | 40 | 0 | |
p02986 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
using namespace std;
int n, T, num, tot;
int rdt[200300], rd[200300], rdc[200300], rdl[200300], wz[200300], ans[200300];
int dad[200300], hvdad[200300], hvson[200300], dep[200300], sz[200300],
dadlen[200300];
int trtoli[200300], litotr[200300];
int a[400300], sum[400300], L[400300], R[400300];
struct SS {
int ans, sum;
};
struct S {
int l, c, x, y, n;
} A[200050], Q[200050];
void cnct(int x, int y, int c, int l) {
rdt[++num] = wz[x], rd[num] = y, rdc[num] = c, rdl[num] = l, wz[x] = num;
rdt[++num] = wz[y], rd[num] = x, rdc[num] = c, rdl[num] = l, wz[y] = num;
}
void dfs(int x, int from, int l, int d) {
int t = wz[x], m = 0;
dad[x] = from, sz[x] = 1, dadlen[x] = l, dep[x] = d;
while (t) {
if (rd[t] != from) {
dfs(rd[t], x, rdl[t], d + 1);
if (sz[rd[t]] > m)
m = sz[rd[t]], hvson[x] = rd[t];
sz[x]++;
}
t = rdt[t];
}
}
void dfs2(int x, int hd) {
int t = wz[x];
trtoli[x] = ++num, hvdad[x] = hd;
litotr[num] = x;
if (hvson[x])
dfs2(hvson[x], hd);
while (t) {
if (rd[t] != dad[x] && rd[t] != hvson[x]) {
dfs2(rd[t], rd[t]);
}
t = rdt[t];
}
}
void Mk(int x, int l, int r) {
L[x] = l, R[x] = r;
if (l != r) {
Mk(x * 2, l, (l + r) / 2);
Mk(x * 2 + 1, (l + r) / 2 + 1, r);
a[x] = a[x * 2] + a[x * 2 + 1];
} else {
a[x] = dadlen[litotr[l]];
}
}
bool cmp(S t1, S t2) { return t1.c < t2.c; }
void updt(int x, int tar, int num, int ty) {
if (L[x] == R[x]) {
a[x] = num, sum[x] = ty;
} else {
if (tar < L[x * 2 + 1])
updt(x * 2, tar, num, ty);
else
updt(x * 2 + 1, tar, num, ty);
a[x] = a[x * 2] + a[x * 2 + 1];
sum[x] = sum[x * 2] + sum[x * 2 + 1];
}
}
void chg(int x, int y) {
int tar, tarnum = y;
if (dad[A[x].x] == A[x].y)
tar = trtoli[A[x].x];
else
tar = trtoli[A[x].y];
updt(1, tar, tarnum, 1);
}
void rechg(int x) {
int tar, tarnum = A[x].l;
if (dad[A[x].x] == A[x].y)
tar = trtoli[A[x].x];
else
tar = trtoli[A[x].y];
updt(1, tar, tarnum, 0);
}
SS getsum(int x, int l, int r) {
if (L[x] == R[x]) {
SS P;
P.ans = a[x];
P.sum = sum[x];
return P;
} else {
if (r < L[x * 2 + 1])
return getsum(x * 2, l, r);
else if (l > R[x * 2])
return getsum(x * 2 + 1, l, r);
else {
SS P = getsum(x * 2, l, R[x * 2]),
PP = getsum(x * 2 + 1, L[x * 2 + 1], r);
P.ans += PP.ans, P.sum += PP.sum;
return P;
}
}
}
int getans(int x, int y, int t1, int t2) {
int ans = 0, sum = 0;
SS P;
while (hvdad[x] != hvdad[y]) {
if (dep[hvdad[x]] < dep[hvdad[y]])
swap(x, y);
P = getsum(1, trtoli[hvdad[x]], trtoli[x]);
ans += P.ans, sum += P.sum;
x = dad[hvdad[x]];
}
if (x != y) {
if (dep[x] < dep[y])
swap(x, y);
P = getsum(1, trtoli[y] + 1, trtoli[x]);
ans += P.ans, sum += P.sum;
}
return ans + sum * (Q[t2].l - Q[t1].l);
}
int main() {
int i, j, k, i2, j2;
scanf("%d%d", &n, &T);
for (i = 1; i < n; i++) {
scanf("%d%d%d%d", &A[i].x, &A[i].y, &A[i].c, &A[i].l);
cnct(A[i].x, A[i].y, A[i].c, A[i].l), A[i].n = i;
}
for (i = 1; i <= T; i++)
scanf("%d%d%d%d", &Q[i].c, &Q[i].l, &Q[i].x, &Q[i].y), Q[i].n = i;
num = 0;
dfs(1, 0, 0, 0);
dfs2(1, 1);
Mk(1, 1, num);
sort(A + 1, A + n, cmp);
sort(Q + 1, Q + 1 + T, cmp);
i2 = 0;
for (i = 1; i <= T; i++) {
int pd = 0;
while (A[++i2].c < Q[i].c && i2 < n)
;
if (A[i2].c == Q[i].c) {
for (j2 = i2; A[j2].c == Q[i].c; j2++) {
chg(j2, Q[i].l);
}
pd = 1;
} else
i2--;
for (j = i + 1; j <= T; j++)
if (Q[j].c != Q[i].c)
break;
for (k = i; k < j; k++) {
ans[Q[k].n] = getans(Q[k].x, Q[k].y, i, k);
}
if (pd) {
for (j2 = i2; A[j2].c == Q[i].c; j2++) {
rechg(j2);
}
i2 = j2 - 1;
}
i = j - 1;
}
for (i = 1; i <= T; i++)
printf("%d\n", ans[i]);
} | #include <algorithm>
#include <cstdio>
using namespace std;
int n, T, num, tot;
int rdt[200300], rd[200300], rdc[200300], rdl[200300], wz[200300], ans[200300];
int dad[200300], hvdad[200300], hvson[200300], dep[200300], sz[200300],
dadlen[200300];
int trtoli[200300], litotr[200300];
int a[400300], sum[400300], L[400300], R[400300];
struct SS {
int ans, sum;
};
struct S {
int l, c, x, y, n;
} A[200050], Q[200050];
void cnct(int x, int y, int c, int l) {
rdt[++num] = wz[x], rd[num] = y, rdc[num] = c, rdl[num] = l, wz[x] = num;
rdt[++num] = wz[y], rd[num] = x, rdc[num] = c, rdl[num] = l, wz[y] = num;
}
void dfs(int x, int from, int l, int d) {
int t = wz[x], m = 0;
dad[x] = from, sz[x] = 1, dadlen[x] = l, dep[x] = d;
while (t) {
if (rd[t] != from) {
dfs(rd[t], x, rdl[t], d + 1);
if (sz[rd[t]] > m)
m = sz[rd[t]], hvson[x] = rd[t];
sz[x]++;
}
t = rdt[t];
}
}
void dfs2(int x, int hd) {
int t = wz[x];
trtoli[x] = ++num, hvdad[x] = hd;
litotr[num] = x;
if (hvson[x])
dfs2(hvson[x], hd);
while (t) {
if (rd[t] != dad[x] && rd[t] != hvson[x]) {
dfs2(rd[t], rd[t]);
}
t = rdt[t];
}
}
void Mk(int x, int l, int r) {
L[x] = l, R[x] = r;
if (l != r) {
Mk(x * 2, l, (l + r) / 2);
Mk(x * 2 + 1, (l + r) / 2 + 1, r);
a[x] = a[x * 2] + a[x * 2 + 1];
} else {
a[x] = dadlen[litotr[l]];
}
}
bool cmp(S t1, S t2) { return t1.c < t2.c; }
void updt(int x, int tar, int num, int ty) {
if (L[x] == R[x]) {
a[x] = num, sum[x] = ty;
} else {
if (tar < L[x * 2 + 1])
updt(x * 2, tar, num, ty);
else
updt(x * 2 + 1, tar, num, ty);
a[x] = a[x * 2] + a[x * 2 + 1];
sum[x] = sum[x * 2] + sum[x * 2 + 1];
}
}
void chg(int x, int y) {
int tar, tarnum = y;
if (dad[A[x].x] == A[x].y)
tar = trtoli[A[x].x];
else
tar = trtoli[A[x].y];
updt(1, tar, tarnum, 1);
}
void rechg(int x) {
int tar, tarnum = A[x].l;
if (dad[A[x].x] == A[x].y)
tar = trtoli[A[x].x];
else
tar = trtoli[A[x].y];
updt(1, tar, tarnum, 0);
}
SS getsum(int x, int l, int r) {
if (L[x] == l && R[x] == r) {
SS P;
P.ans = a[x];
P.sum = sum[x];
return P;
} else {
if (r < L[x * 2 + 1])
return getsum(x * 2, l, r);
else if (l > R[x * 2])
return getsum(x * 2 + 1, l, r);
else {
SS P = getsum(x * 2, l, R[x * 2]),
PP = getsum(x * 2 + 1, L[x * 2 + 1], r);
P.ans += PP.ans, P.sum += PP.sum;
return P;
}
}
}
int getans(int x, int y, int t1, int t2) {
int ans = 0, sum = 0;
SS P;
while (hvdad[x] != hvdad[y]) {
if (dep[hvdad[x]] < dep[hvdad[y]])
swap(x, y);
P = getsum(1, trtoli[hvdad[x]], trtoli[x]);
ans += P.ans, sum += P.sum;
x = dad[hvdad[x]];
}
if (x != y) {
if (dep[x] < dep[y])
swap(x, y);
P = getsum(1, trtoli[y] + 1, trtoli[x]);
ans += P.ans, sum += P.sum;
}
return ans + sum * (Q[t2].l - Q[t1].l);
}
int main() {
int i, j, k, i2, j2;
scanf("%d%d", &n, &T);
for (i = 1; i < n; i++) {
scanf("%d%d%d%d", &A[i].x, &A[i].y, &A[i].c, &A[i].l);
cnct(A[i].x, A[i].y, A[i].c, A[i].l), A[i].n = i;
}
for (i = 1; i <= T; i++)
scanf("%d%d%d%d", &Q[i].c, &Q[i].l, &Q[i].x, &Q[i].y), Q[i].n = i;
num = 0;
dfs(1, 0, 0, 0);
dfs2(1, 1);
Mk(1, 1, num);
sort(A + 1, A + n, cmp);
sort(Q + 1, Q + 1 + T, cmp);
i2 = 0;
for (i = 1; i <= T; i++) {
int pd = 0;
while (A[++i2].c < Q[i].c && i2 < n)
;
if (A[i2].c == Q[i].c) {
for (j2 = i2; A[j2].c == Q[i].c; j2++) {
chg(j2, Q[i].l);
}
pd = 1;
} else
i2--;
for (j = i + 1; j <= T; j++)
if (Q[j].c != Q[i].c)
break;
for (k = i; k < j; k++) {
ans[Q[k].n] = getans(Q[k].x, Q[k].y, i, k);
}
if (pd) {
for (j2 = i2; A[j2].c == Q[i].c; j2++) {
rechg(j2);
}
i2 = j2 - 1;
}
i = j - 1;
}
for (i = 1; i <= T; i++)
printf("%d\n", ans[i]);
} | replace | 96 | 97 | 96 | 97 | TLE | |
p02986 | C++ | Runtime Error | // #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long
#define ll long long
auto start_time = system_clock::now();
//@formatter:off
#ifdef _DEBUG
// 区間削除は出来ない
template <class T> struct my_pbds_tree {
set<T> s;
auto begin() { return s.begin(); }
auto end() { return s.end(); }
auto rbegin() { return s.rbegin(); }
auto rend() { return s.rend(); }
auto empty() { return s.empty(); }
auto size() { return s.size(); }
void clear() { s.clear(); }
template <class U> void insert(U v) { s.insert(v); }
template <class U> void operator+=(U v) { insert(v); }
template <class F> auto erase(F v) { return s.erase(v); }
template <class U> auto find(U v) { return s.find(v); }
template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
auto find_by_order(ll k) {
auto it = s.begin();
for (ll i = 0; i < k; i++)
it++;
return it;
}
auto order_of_key(ll v) {
auto it = s.begin();
ll i = 0;
for (; it != s.end() && *it < v; i++)
it++;
return i;
}
};
#define pbds(T) my_pbds_tree<T>
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
unordered_map<T, U> m;
my_unordered_map(){};
auto begin() { return m.begin(); }
auto end() { return m.end(); }
auto cbegin() { return m.cbegin(); }
auto cend() { return m.cend(); }
template <class V> auto erase(V v) { return m.erase(v); }
void clear() {
m.clear();
} /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
template <class V> auto find(V v) { return m.find(v); }
template <class V> auto &operator[](V n) { return m[n]; }
};
#define unordered_map my_unordered_map
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umapip unordered_map<ll, P>
#else
#define unordered_map __gnu_pbds::gp_hash_table
// find_by_order(k) k番目のイテレーター
// order_of_key(k) k以上が前から何番目か
#define pbds(U) \
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
__gnu_pbds::tree_order_statistics_node_update>
#define umapi unordered_map<ll, ll, xorshift>
#define umapp unordered_map<P, ll, xorshift>
#define umapip unordered_map<ll, P, xorshift>
#endif
struct xorshift {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
size_t operator()(std::pair<ll, ll> x) const {
ll v = ((x.first) << 32) | x.second;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(v + FIXED_RANDOM);
}
};
template <class U, class L>
void operator+=(
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update> &s,
L v) {
s.insert(v);
}
// 衝突対策
#define ws wszzzz
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) const {
return f != r.f ? f < r.f
: s != r.s ? s < r.s
: t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
r.s : t > r.t; 大きい順 */
}
bool operator>(const T2 &r) const {
return f != r.f ? f > r.f
: s != r.s ? s > r.s
: t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
r.s : t > r.t; 小さい順 */
}
bool operator==(const T2 &r) const {
return f == r.f && s == r.s && t == r.t;
}
bool operator!=(const T2 &r) const {
return f != r.f || s != r.s || t != r.t;
}
};
template <class A, class B, class C, class D> struct F2 {
A a;
B b;
C c;
D d;
F2() { a = 0, b = 0, c = 0, d = 0; }
F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F2 &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d; /* return a != r.a ? a > r.a : b != r.b ? b
> r.b : c != r.c ? c > r.c : d > r.d;*/
}
bool operator>(const F2 &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d; /* return a != r.a ? a < r.a : b != r.b
? b < r.b : c != r.c ? c < r.c : d < r.d;*/
}
bool operator==(const F2 &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F2 &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
ll operator[](ll i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
T mt(ll a, ll b, ll c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define wh while
#define upd update
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam(right) [&](ll &p) { return p right; }
// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;
#define vec vector
#define o_vvt(o1, o2, o3, o4, name, ...) name
#define vvt0(t) vec<vec<t>>
#define vvt1(t, a) vec<vec<t>> a
#define vvt2(t, a, b) vec<vec<t>> a(b)
#define vvt3(t, a, b, c) vec<vec<t>> a(b, vec<t>(c))
#define vvt4(t, a, b, c, d) vec<vec<t>> a(b, vec<t>(c, d))
#define vvi(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define bset bitset
#define uset unordered_set
#define useti unordered_set<ll, ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
template <class T> struct pq {
priority_queue<T, vector<T>, greater<T>> q; /*小さい順*/
T su = 0;
void clear() {
q = priority_queue<T, vector<T>, greater<T>>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
template <class T> struct pqg {
priority_queue<T> q; /*大きい順*/
T su = 0;
void clear() {
q = priority_queue<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
#define pqi pq<ll>
#define pqgi pqg<ll>
// マクロ 繰り返し
#define o_rep(o1, o2, o3, o4, name, ...) name
#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
#define rep(...) o_rep(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
#define rer(...) o_rep(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (ll i = 0, reps2lim = n; i < reps2lim; ++i) \
for (ll j = 0; j < reps2lim; ++j)
#define reps3(i, j, k, n) \
for (ll i = 0, reps3lim = n; i < reps3lim; ++i) \
for (ll j = 0; j < reps3lim; ++j) \
for (ll k = 0; k < reps3lim; ++k)
#define reps4(i, j, k, l, n) \
for (ll i = 0, reps4lim = n; i < reps4lim; ++i) \
for (ll j = 0; j < reps4lim; ++j) \
for (ll k = 0; k < reps4lim; ++k) \
for (ll l = 0; l < reps4lim; ++l)
#define o_reps(o1, o2, o3, o4, o5, name, ...) name
#define reps(...) o_reps(__VA_ARGS__, reps4, reps3, reps2, rep2, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (ll i = 0; i < a; ++i) \
for (ll j = 0; j < b; ++j) \
for (ll k = 0; k < c; ++k)
#define fora(a, b) for (auto &&a : b)
// インデックスを前後含めて走査
#define fori(i, s, len) \
for (int i = s, prev = (s == 0) ? len - 1 : s - 1, \
next = (s == len - 1) ? 0 : s + 1, cou = 0; \
cou < len; \
cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// vectorの中身を先頭から見る
#define foriv(i, v, d) \
int i = 0; \
for (auto prev = d[sz(d) - 1], next = d[1], v = d[0]; i < sz(d); \
i++, prev = v, v = next, next = (i >= sz(d) - 1 ? d[0] : d[i + 1]))
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; ++it)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const ll inf = (ll)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public
: /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
} // namespace std
// stream まとめ
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (ll i = 0; i < vec.size(); ++i)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, vector<pair<T, U>> &vec) {
for (ll i = 0; i < vec.size(); ++i) {
os << vec[i];
if (i != vec.size() - 1)
os << endl;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (ll i = 0; i < vec.size(); ++i) {
for (ll j = 0; j < vec[i].size(); ++j) {
os << vec[i][j] << " ";
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
fora(v, a) os << v << " ";
return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec) {
rep(h, sz(vec)) {
rep(w, sz(vec[0])) { os << vec[h][w]; }
os << endl;
}
return os;
}
template <typename W, typename H> void resize(vector<W> &vec, const H head) {
vec.resize(head);
}
template <typename W, typename H, typename... T>
void resize(vector<W> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename F> bool all_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (!all_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool any_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (any_of2(v[i], f))
return true;
}
return false;
}
template <typename T, typename F> bool none_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool none_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (none_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool find_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll find_if2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (find_if2(v[i], f))
return i;
}
return sz(v);
}
template <typename T, typename F> bool rfind_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll rfind_if2(vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (rfind_if2(v[i], f))
return i;
}
return -1;
}
template <class T> bool contains(string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(vector<T> &vec, F f) {
ll ret = 0;
fora(v, vec) ret += count_if2(v, f);
return ret;
}
template <typename T, typename F> void for_each2(T &v, F f) { f(v); }
template <typename T, typename F> void for_each2(vector<T> &vec, F f) {
fora(v, vec) for_each2(v, f);
}
template <typename W> ll count_od(vector<W> &a) {
return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(vector<W> &a) {
return count_if2(a, [](ll v) { return !(v & 1); });
}
#define all_of(a, right) all_of2(a, lam(right))
#define any_of(a, right) any_of2(a, lam(right))
#define none_of(a, right) none_of2(a, lam(right))
#define find_if(a, right) find_if2(a, lam(right))
#define rfind_if(a, right) rfind_if2(a, lam(right))
#define contains_if(a, right) contains_if2(a, lam(right))
#define count_if(a, right) count_if2(a, lam(right))
#define for_each(a, right) \
do { \
fora(v, a) { v right; } \
} while (0)
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
void replace(str &a, str key, str v) {
stringstream t;
ll kn = sz(key);
std::string::size_type Pos(a.find(key));
ll l = 0;
while (Pos != std::string::npos) {
t << a.substr(l, Pos - l);
t << v;
l = Pos + kn;
Pos = a.find(key, Pos + kn);
}
t << a.substr(l, sz(a) - l);
a = t.str();
}
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
void iota(vector<ll> &ve, ll s, ll n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(ll s, ll len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
assert(sz(a) == sz(b)); /*stringを0で初期化できない */
vector<pair<A, B>> res;
rep(i, sz(a)) res.eb(a[i], b[i]);
return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
a.resize(sz(p)), b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
assert(sz(a) == sz(b) && sz(b) == sz(c));
vector<T2<A, B, C>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
vector<F2<A, B, C, D>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
return res;
}
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
fisiti,
fisitd,
fisdti,
fisdtd,
fdsiti,
fdsitd,
fdsdti,
fdsdtd,
fitisi,
fitisd,
fitdsi,
fitdsd,
fdtisi,
fdtisd,
fdtdsi,
fdtdsd,
sifiti,
sifitd,
sifdti,
sifdtd,
sdfiti,
sdfitd,
sdfdti,
sdfdtd,
sitifi,
sitifd,
sitdfi,
sitdfd,
sdtifi,
sdtifd,
sdtdfi,
sdfdfd,
tifisi,
tifisd,
tifdsi,
tifdsd,
tdfisi,
tdfisd,
tdfdsi,
tdfdsd,
tisifi,
tisifd,
tisdfi,
tisdfd,
tdsifi,
tdsifd,
tdsdfi,
tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
typedef pair<A, B> U;
if (type == fisi)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
else if (type == fisd)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
else if (type == fdsi)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
else if (type == fdsd)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
else if (type == sifi)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
else if (type == sifd)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
else if (type == sdfi)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
else if (type == sdfd)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
if (type == fisi)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
else if (type == fisd)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
else if (type == fdsi)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
else if (type == fdsd)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
else if (type == sifi)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
else if (type == sifd)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
else if (type == sdfi)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
else if (type == sdfd)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
typedef F2<A, B, C, D> U;
if (type == fisi)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
else if (type == fisd)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
else if (type == fdsi)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
else if (type == fdsd)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
else if (type == sifi)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
else if (type == sifd)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
else if (type == sdfi)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
else if (type == sdfd)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
if (type == 0)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 1)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 2)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 3)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 4)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 5)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 6)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 7)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 8)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 9)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 10)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 11)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 12)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 13)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 14)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 15)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 16)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 17)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 18)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 19)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 20)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 21)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 22)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 23)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 24)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 25)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 26)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 27)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 28)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 29)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 30)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 31)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 32)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 33)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 34)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 35)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 36)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 37)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 38)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 39)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 40)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 41)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 42)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 43)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
else if (type == 44)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 45)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 46)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 47)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
typedef F2<A, B, C, D> U;
if (type == 0)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 1)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 2)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 3)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 4)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 5)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 6)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 7)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 8)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 9)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 10)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 11)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 12)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 13)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 14)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 15)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 16)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 17)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 18)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 19)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 20)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 21)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 22)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 23)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 24)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 25)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 26)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 27)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 28)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 29)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 30)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 31)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 32)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 33)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 34)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 35)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 36)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 37)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 38)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 39)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 40)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 41)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 42)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 43)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
else if (type == 44)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 45)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 46)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 47)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
}
void sort(string &a) { sort(all(a)); }
template <class T> void sort(vector<T> &a) { sort(all(a)); }
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
sort(all(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class T> void rsort(vector<T> &a) { sort(all(a), greater<T>()); };
template <class U, class F> void rsort(vector<U> &a, F f) {
sort(all(a), [&](U l, U r) { return f(l) > f(r); });
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
sort(c);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
sort(c, f);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
rsort(c);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
rsort(c, f);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
sort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
sort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
rsort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
rsort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
sort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
rsort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind);
return ind;
} /*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind, f);
return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
return ind;
}
template <class T> vi rsorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
rsortp(b, ind);
return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
vi ind = iota(0, sz(a));
auto c = a;
auto d = b;
sortt(c, d, ind, f);
return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
vi ind = iota(0, sz(a));
auto d = vtof(a, b, c, ind);
sort(d, f);
rep(i, sz(a)) ind[i] = d[i].d;
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] < c[y];
else
return b[x] < b[y];
} else {
return a[x] < a[y];
}
});
return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] > c[y];
else
return b[x] > b[y];
} else {
return a[x] > a[y];
}
});
return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
rsort(a[i]);
}
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, const T v, ll len) {
rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, const T v, ll lh, ll lw) {
rep(i, lh) rep(j, lw) xx[i][j] = v;
}
template <class T, class U> void fill(vector<T> &a, U val, vi &ind) {
fora(v, ind) a[v] = val;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
//@汎用便利関数 入力
ll in() {
ll ret;
cin >> ret;
return ret;
}
string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define o_din(o1, o2, o3, o4, o5, o6, name, ...) name
#define din1(a) \
ll a; \
cin >> a
#define din2(a, b) \
ll a, b; \
cin >> a >> b
#define din3(a, b, c) \
ll a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
ll a, b, c, d; \
cin >> a >> b >> c >> d
#define din5(a, b, c, d, e) \
ll a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define din6(a, b, c, d, e, f) \
ll a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define din(...) \
o_din(__VA_ARGS__, din6, din5, din4, din3, din2, din1)(__VA_ARGS__)
#define o_dins(o1, o2, o3, o4, o5, o6, name, ...) name
#define dins1(a) \
str a; \
cin >> a
#define dins2(a, b) \
str a, b; \
cin >> a >> b
#define dins3(a, b, c) \
str a, b, c; \
cin >> a >> b >> c
#define dins4(a, b, c, d) \
str a, b, c, d; \
cin >> a >> b >> c >> d
#define dins5(a, b, c, d, e) \
str a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define dins6(a, b, c, d, e, f) \
str a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define dins(...) \
o_dins(__VA_ARGS__, dins6, dins5, dins4, dins3, dins2, dins1)(__VA_ARGS__)
#define o_dind(o1, o2, o3, o4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) o_dind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }
#ifdef _DEBUG
template <class T> string out_m(vector<T> &a, ll W = inf) {
stringstream ss;
if (W == inf)
W = min(sz(a), 12ll);
if (sz(a) == 0)
return ss.str();
rep(i, W) { ss << a[i] << " "; }
ss << "" << endl;
return ss.str();
}
template <class T>
string out_m(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
H = min({H, sz(a), 12ll});
W = min({W, sz(a[0]), 12ll});
stringstream ss;
ss << endl;
if (key == -1)
ss << " *|";
else
ss << " " << key << "|";
rep(w, W) ss << std::right << std::setw(4) << w;
ss << "" << endl;
rep(w, W * 4 + 3) ss << "_";
ss << "" << endl;
rep(h, H) {
ss << std::right << std::setw(2) << h << "|";
rep(w, min(sz(a[h]), 12ll)) {
if (a[h][w] == linf)
ss << " e"
<< " ";
else
ss << std::right << std::setw(4) << a[h][w];
}
ss << "" << endl;
}
ss << endl;
return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
stringstream ss;
if (H == inf)
H = 5;
H = min(H, sz(a));
rep(i, H) {
ss << endl;
ss << out_m(a[i], W, U, i);
}
ss << endl;
return ss.str();
}
string out_m(int a) {
stringstream ss;
ss << a << endl;
return ss.str();
}
template <class T> string out_m(T &a) {
stringstream ss;
ss << a << endl;
return ss.str();
}
template <class T> void outv(vector<T> &a, ll W = inf) {
cout << out_m(a, W) << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
cout << out_m(a, H, W, key) << endl;
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
cout << out_m(a, H, W, U) << endl;
}
#else
template <class T> void outv(vector<T> &a, ll W = inf) {
rep(i, min(W, sz(a))) { cout << a[i] << " "; }
cout << "" << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
rep(i, min(H, sz(a))) { outv(a[i], W); }
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
;
}
#endif
template <class T> void outl(vector<T> &a, int n = inf) {
rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
rep(i, sz(a)) {
rep(j, sz(a[i])) { cout << a[i][j]; }
cout << endl;
}
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
template <class T> void na(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i];
}
#define dna(a, n) \
vi a(n); \
rep(dnai, n) cin >> a[dnai];
#define dnad(a, n) \
vi a(n); \
rep(dnai, n) cin >> a[dnai], a[dnai]--;
template <class T> void nao(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i], a[i]--;
}
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i];
}
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(dna2i, n) cin >> a[dna2i] >> b[dna2i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n + 1);
b.resize(n + 1);
a[0] = b[0] = 0;
rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
#define dna2d(a, b, n) \
vi a(n), b(n); \
rep(dna2di, n) { \
cin >> a[dna2di] >> b[dna2di]; \
a[dna2di]--, b[dna2di]--; \
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(dna3i, n) cin >> a[dna3i] >> b[dna3i] >> c[dna3i];
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(dna3di, n) { \
cin >> a[dna3di] >> b[dna3di] >> c[dna3di]; \
a[dna3di]--, b[dna3di]--, c[dna3di]--; \
}
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
d.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n) \
vi a(n), b(n), c(n), d(n); \
rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i];
#define dna4d(a, b, c, d, n) \
vi a(n), b(n), c(n), d(n); \
rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i], \
--a[dna4i], --b[dna4i], --c[dna4i], --d[dna4i];
#define nt(a, h, w) \
resize(a, h, w); \
rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w) \
resize(a, h, w); \
rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define deb1(x) debugName(x) << " = " << out_m(x)
#define deb2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb3(x, ...) deb1(x) << ", " << deb2(__VA_ARGS__)
#define deb4(x, ...) deb1(x) << ", " << deb3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
#define deb7(x, ...) deb1(x) << ", " << deb6(__VA_ARGS__)
#define deb8(x, ...) deb1(x) << ", " << deb7(__VA_ARGS__)
#define deb9(x, ...) deb1(x) << ", " << deb8(__VA_ARGS__)
#define deb10(x, ...) deb1(x) << ", " << deb9(__VA_ARGS__)
#define o_ebug(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << o_ebug(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb4, deb3, \
deb2, deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
//@formatter:off
// よく使うクラス、構造体
struct unionfind {
vector<ll> par;
vector<ll> siz;
vector<ll> es;
ll n, trees; // 連結グループの数(親の種類)
unionfind(ll n) : n(n), trees(n) {
par.resize(n);
siz.resize(n);
es.resize(n);
for (ll i = 0; i < n; i++) {
par[i] = i;
siz[i] = 1;
}
}
ll root(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = root(par[x]);
}
}
bool unite(ll x, ll y) {
x = root(x);
y = root(y);
es[x]++;
if (x == y)
return false;
if (siz[x] > siz[y])
swap(x, y);
trees--;
par[x] = y;
siz[y] += siz[x];
es[y] += es[x];
return true;
}
bool same(ll x, ll y) { return root(x) == root(y); }
ll size(ll x) { return siz[root(x)]; }
ll esize(ll x) { return es[root(x)]; }
vi sizes() {
vi cou(n);
vi ret;
ret.reserve(n);
rep(i, n) { cou[root(i)]++; }
rep(i, n) {
if (cou[i])
ret.push_back(cou[i]);
}
return ret;
}
// つながりを無向グラフと見なし、xが閉路に含まれるか判定
bool close(ll x) { return esize(x) >= size(x); }
vec<vi> sets() {
vi ind(n, -1);
ll i = 0;
vvi(res, trees);
rep(j, n) {
ll r = root(j);
if (ind[r] == -1)
ind[r] = i++;
res[ind[r]].push_back(j);
}
rep(i, trees) {
ll r = root(res[i][0]);
if (res[i][0] == r)
continue;
rep(j, 1, sz(res[i])) {
if (res[i][j] == r) {
swap(res[i][0], res[i][j]);
break;
}
}
}
return res;
}
}; //@formatter:off
using bll = __int128;
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
ll len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
//__int128 toi128(string &s) { __int128 ret = 0; for (ll i = 0; i <
//s.length(); ++i) if ('0' <= s[i] && s[i] <= '9') ret = 10 *
//ret + s[i] - '0'; return ret;}
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() {
assert(0 == 1);
exit(0);
}
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
vi ranv(ll n, ll min, ll max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
str ransu(ll n) {
str s;
rep(i, n) s += (char)rand('A', 'Z');
return s;
}
str ransl(ll n) {
str s;
rep(i, n) s += (char)rand('a', 'z');
return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
// 便利 汎用
void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, ll>> run_length(string &a) {
vector<pair<char, ll>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> ll mgr(ll ok, ll ng, F f) {
if (ok < ng)
while (ng - ok > 1) {
ll mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
while (ok - ng > 1) {
ll mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else if (a < b)
return b;
else
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) > sz(b)) {
return b;
} else if (sz(a) < sz(b)) {
return a;
} else if (a > b)
return b;
else
return a;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename W, typename U>
T find(vector<vector<vector<W>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename W, typename T> ll count2(W &a, const T k) { return a == k; }
template <typename W, typename T> ll count2(vector<W> &a, const T k) {
ll ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
template <typename W, typename T> ll count(vector<W> &a, const T k) {
ll ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
ll count(str &a, str k) {
ll ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ++ret;
return ret;
}
vi count(str &a) {
vi cou(26);
char c = 'a';
if ('A' <= a[0] && a[0] <= 'Z')
c = 'A';
rep(i, sz(a))++ cou[a[i] - c];
return cou;
}
#define couif count_if
// algorythm
ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class U> void rev(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
a = b;
}
void rev(string &a) { reverse(all(a)); }
constexpr ll p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
ll get(ll a, ll keta) { return (a / (ll)pow(10, keta)) % 10; }
ll keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
ll dsum(ll v, ll sin = 10) {
ll ret = 0;
for (; v; v /= sin)
ret += v % sin;
return ret;
}
struct sint {
ll v;
sint(ll v) : v(v) {}
operator ll() { return v; }
// 下からi番目
ll operator[](ll i) { return (v / p10[i]) % 10; }
ll back(ll i) { return operator[](i); }
// 上からi番目
ll top(ll i) {
ll len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
ll settop(ll i, ll k) {
ll len = keta(v);
return set(len - 1 - i, k);
}
ll set(ll i, ll k) {
if (i < 0)
return settop(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
ll add(ll i, ll k = 1) { return v += p10[i] * k; }
ll addtop(ll i, ll k = 1) { return v += p10[keta(v) - i - 1] * k; }
ll dec(ll i, ll k = 1) { return v -= p10[i] * k; }
ll dectop(ll i, ll k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> t operator o(T r) { return v o r; }
op(ll, +=);
op(ll, -=);
op(ll, *=);
op(ll, /=);
op(ll, %=);
op(ll, +);
op(ll, -);
op(ll, *);
op(ll, /);
op(ll, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> ll operator<<=(T r) { return v *= p10[r]; }
template <class T> ll operator<<(T r) { return v * p10[r]; }
template <class T> ll operator>>=(T r) { return v /= p10[r]; }
template <class T> ll operator>>(T r) { return v / p10[r]; }
};
ll mask10(ll v) { return p10[v] - 1; }
// 変換系
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
template <class T> auto keys(T &a) {
vector<decltype((a.begin())->fi)> res;
for (auto &&k : a)
res.push_back(k.fi);
return res;
}
template <class T> auto values(T &a) {
vector<decltype((a.begin())->se)> res;
for (auto &&k : a)
res.push_back(k.se);
return res;
}
template <class T, class U> bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> T min(vector<T> &a) { return *min_element(all(a)); }
template <class T> T mini(vector<T> &a) {
return min_element(all(a)) - a.begin();
}
template <class T> T min(vector<T> &a, ll n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T min(vector<T> &a, ll s, ll n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a) { return *max_element(all(a)); }
template <class T, class U> T max(vector<T> &a, vector<U> &b) {
return max(*max_element(all(a)), *max_element(all(b)));
}
template <class T> T maxi(vector<T> &a) {
return max_element(all(a)) - a.begin();
}
template <class T> T max(vector<T> &a, ll n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a, ll s, ll n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> T sum(vector<T> &v, ll s, ll t) {
T ret = 0;
rep(i, s, min(sz(v), t)) ret += v[i];
return ret;
}
template <class T> T sum(vector<T> &v, ll t = inf) { return sum(v, 0, t); }
template <class T> T sum(vector<vector<T>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<vector<vector<T>>>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
template <class T> auto sum(priority_queue<T> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
// template<class T, class U, class... W> auto sumn(vector<T> &v, U head, W...
// tail) { auto ret = sum(v[0], tail...); rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...); return ret;}
vi v_i(vi &a) {
int n = max(a) + 1;
vi ret(n, -1);
rep(i, sz(a)) { ret[a[i]] = i; }
return ret;
}
void clear(PQ &q) { q = PQ(); }
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> T *negarr(ll size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> T *negarr2(ll h, ll w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (ll i = 1; i <= 2 * h + 1; ++i) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret)) ret[i] = a[i] == k;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
template <class T> vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
return rui[r] - rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
T operator()(ll l, ll r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
T operator[](ll i) { return rrui[i]; }
};
template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
fora(v, a.rui) os << v << " ";
return os;
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
vector<ll> ruiv(string &a) {
if (sz(a) == 0)
return vi(1);
ll dec = ('0' <= a[0] && a[0] <= '9') ? '0' : 0;
vector<ll> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i] - dec;
return ret;
}
ruiC<ll> ruic(string &a) {
vector<ll> ret = ruiv(a);
return ruiC<ll>(ret);
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<ll>(ret);
}
// xor
template <class T> struct ruixC {
const vector<T> rui;
ruixC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruiXc ";
deb(l, r);
assert(0);
}
return rui[r] ^ rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
vi ret = ruix(a);
return ruixC<ll>(ret);
}
template <class T> vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
ll n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void dec(vector<T> &a, vector<U> &b) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
for (auto &u : c)
dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool ins(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
return ins(0, i, sz(a)) && ins(0, j, sz(a));
}
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
// 添え字を返す
template <class F> ll goldd_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class F> ll goldt_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> dou goldd_d(dou left, dou right, F calc, ll loop = 200) {
dou GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
ll k = 141;
loop++;
while (--loop) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return left;
}
template <class F> dou goldt_d(dou left, dou right, F calc, ll loop = 200) {
double GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm);
loop++;
while (--loop) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return left;
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> ll goldd_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll mini = 0, minv = MAX(ll); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldd_l(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return mini;
}
template <class F> ll goldt_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll maxi = 0, maxv = MIN(ll); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldt_l(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return maxi;
}
template <class F>
dou goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
auto lim = milliseconds(time - 20);
dou mini = 0, minv = MAX(dou); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldd_d(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return mini;
}
template <class F>
dou goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
auto lim = milliseconds(time - 20);
dou maxi = 0, maxv = MIN(dou); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldt_d(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return maxi;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
ll bget(ll m, ll keta, ll sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
ll bit(vi &a) {
int m = 0;
for (auto &&v : a)
m |= bit(v);
return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) { return n & -n; }
ll lbiti(ll n) { return log2(n & -n); }
// 最上位ビット
ll hbit(ll n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
ll hbiti(ll n) { return log2(hbit(n)); }
ll hbitk(ll n) {
ll k = 0;
rer(i, 5) {
ll a = k + (1ll << i);
ll b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; /*最下位の1*/
ll y = mask + x; /*連続した下の1を繰り上がらせる*/
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
vi res;
ll m = 0;
while (nextComb(m, n, r)) {
res.push_back(m);
}
return res;
}
// masの立ってるindexを見る
#define forbit(i, mas) \
for (int forbitj = lbit(mas), forbitm = mas, i = log2(forbitj); forbitm; \
forbitm = forbitj ? forbitm ^ forbitj : 0, forbitj = lbit(forbitm), \
i = log2(forbitj))
char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
ll res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(ll i) {
vi res;
while (i) {
res.push_back(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
ll n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
ll n = sz(a);
vi ret(n);
rep(i, n) ret[i] = a[i] == one;
return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
ll n = sz(s), m = sz(s[0]);
vector<vector<ll>> res(n, vector<ll>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, umap<ll, ll> &map) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
ll v = a[i];
a[i] = lower_bound(all(b), a[i]) - b.begin();
map[v] = a[i];
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
ll len = a.size();
fora(v, a) b.push_back(v);
fora(v, r) b.push_back(v);
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
ll len = a.size();
fora(v, a) b.push_back(v);
fora(v, r) b.push_back(v);
fora(v, s) b.push_back(v);
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
for (ll i = 0; i < sz(s); ++i)
r[i] = lower_bound(all(b), s[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vi> &a) {
vi b;
fora(vv, a) fora(v, vv) b.push_back(v);
sort(b);
unique(b);
fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) fora(vv, vvv) fora(v, vv) b.push_back(v);
sort(b);
unique(b);
fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(ll a[], ll len) {
vi b;
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define rlowerIndex(a, v) (upper_bound(all(a), v) - a.begin() - 1)
#define rlowerBound(a, v) *(--(upper_bound(all(a), v)))
#define rupperIndex(a, v) (lower_bound(all(a), v) - a.begin() - 1)
#define rupperBound(a, v) *(--(lower_bound(all(a), v)))
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))
// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX(T));
rep(i, n) {
int id = lowerIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX(T));
}
template <class T> int lis_eq(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX(T));
rep(i, n) {
int id = upperIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX(T));
}
// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
auto ret = m.lower_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
auto ret = m.upper_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
auto ret = upper_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
auto ret = lower_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T> void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
ll mod(ll a, ll m) { return (a % m + m) % m; }
ll pow(ll a) { return a * a; };
ll fact(ll v) { return v <= 1 ? 1 : v * fact(v - 1); }
dou factd(int v) {
static vd fact(2, 1);
if (sz(fact) <= v) {
rep(i, sz(fact), v + 1) { fact.push_back(fact.back() * i); }
}
return fact[v];
}
ll comi(ll n, ll r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd2(ll n, ll r) {
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
double comd(int n, int r) {
if (r < 0 || r > n)
return 0;
if (n < 2020)
return comd2(n, r);
static vd fact(2, 1);
if (sz(fact) <= n) {
rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
}
return fact[n] / fact[n - r] / fact[r];
}
ll gcd(ll a, ll b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
ll gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
ll res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
ll lower_remi__bx_a(ll kei, ll rem, ll x) {
if (rem >= x)
return 0;
return (x - rem + kei - 1) / kei;
}
ll lower_remv__bx_a(ll kei, ll rem, ll x) {
if (rem >= x)
return rem;
return (x - rem + kei - 1) / kei * kei + rem;
}
ll upper_remi__bx_a(ll kei, ll rem, ll x) {
if (rem > x)
return 0;
return (x - rem + kei) / kei;
}
ll upper_remv__bx_a(ll kei, ll rem, ll x) {
if (rem > x)
return rem;
return (x - rem + kei) / kei * kei + rem;
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
++res;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return ((1 + t) * t) >> 1; }
ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
// 機能拡張
template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
a.fi += b.fi;
a.se += b.se;
}
template <class T, class U> pair<T, U> operator+(pair<T, U> &a, pair<T, U> &b) {
return pair<T, U>(a.fi + b.fi, a.se + b.se);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
basic_string<CharT, Traits, Alloc> str(lhs);
str.append(to_string(rv));
return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
basic_string<CharT, Traits, Alloc> str(lhs);
str.append(to_string(rv));
return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
auto bek = s;
s = "";
for (; num; num >>= 1) {
if (num & 1) {
s += bek;
}
bek += bek;
}
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
fora(d, v) a.push(d);
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
fora(d, v) a.insert(d);
return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.push_back(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
a.push_back(b[i]);
}
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
exit(0);
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <class T, class U> void operator*=(vector<T> &a, U b) {
vector<T> ta = a;
rep(b - 1) { a += ta; }
}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
ll l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
vector<string> res;
ll kn = sz(deli);
std::string::size_type Pos(a.find(deli));
ll l = 0;
while (Pos != std::string::npos) {
if (Pos - l)
res.push_back(a.substr(l, Pos - l));
l = Pos + kn;
Pos = a.find(deli, Pos + kn);
}
if (sz(a) - l)
res.push_back(a.substr(l, sz(a) - l));
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
template <typename T> class fixed_point : T {
public:
explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
template <typename... Args>
constexpr decltype(auto) operator()(Args &&...args) const {
return T::operator()(*this, std::forward<Args>(args)...);
}
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
return fixed_point<T>{std::forward<T>(t)};
}
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv; //@formatter:on
// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
// 右、上が正
constexpr ll y4[] = {1, -1, 0, 0};
constexpr ll x4[] = {0, 0, -1, 1};
constexpr ll y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// ll k, K, d, x, y, z, q, Q,cou;vvi (s, 0, 0);
// ll n, m, k, H, W;
// vi a, b;
// vvc (ba, 0, 0);
ll n, H, W;
vi A, B, C;
/*@formatter:off*/
#define forg(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c; \
gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
#define fort(gi, ve) \
for (ll gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
++gi) \
if (t != p)
#define fore(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c, ty, id; \
gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, \
id = ve[gi].id, ty = ve[gi].ty, true); \
++gi)
// typeが追加される
#define forg2(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c, ty; \
gi < forglim && \
(f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, true); \
++gi)
#define fort2(gi, ve) \
for (ll gi = 0, f, t, c, ty; \
gi < ve.size() && \
(f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, true); \
++gi) \
if (t != p)
template <class T> struct edge {
int f, t;
T c;
int id;
int ty;
edge(int f, int t, T c = 1, int ty = -1, int id = -1)
: f(f), t(t), c(c), id(id), ty(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> usedv;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), usedv.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
usedv.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int ty, int id) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::usedv;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, ty, id);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, ty, id);
edges.emplace_back(f, t, c, ty, id);
}
void ing(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t;
cin >> f >> t;
f -= minus;
t -= minus;
add(f, t);
}
}
void ingc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c;
cin >> f >> t >> c;
f -= minus;
t -= minus;
add(f, t, c);
}
}
void ingct(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> c >> ty;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
void ingtc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> ty >> c;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
bool used(edge<T> &e) { return usedv[e.id]; }
bool used(int id) { return usedv[id]; }
void del(edge<T> &e) { usedv[e.id] = 1; }
void del(int id) { usedv[id] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.push_back(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::usedv;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
// f < t
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, ty, id);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, ty, id);
g[t].emplace_back(t, f, c, ty, id);
edges.emplace_back(f, t, c, ty, id); //
edges.emplace_back(t, f, c, ty, id);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.ty;
T c = e.c;
add(f, t, c, ty);
}
void ing(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t;
cin >> f >> t;
f -= minus;
t -= minus;
add(f, t);
}
}
void ingc(int m, int minus = 1) {
rep(i, m) {
int f, t, c;
cin >> f >> t >> c;
f -= minus;
t -= minus;
add(f, t, c);
}
}
void ingct(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> c >> ty;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
void ingtc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> ty >> c;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
bool used(edge<T> &e) { return usedv[e.id]; }
bool used(int id) { return usedv[id]; }
void del(edge<T> &e) { usedv[e.id] = 1; }
void del(int id) { usedv[id] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.push_back(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
/*radiq_heap*/
vi dijkstra2(const graph<int> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return dis;
}
template <class T>
vector<vector<T>> dijkstra_all(const graph<T> &g, int init_value = -1) {
vector<vector<T>> dis(g.n);
rep(i, g.n) { dis[i] = dijkstra(g, i, init_value); }
return dis;
}
// ret vector(dis,count); 最短経路とその通りを数える
template <class T>
auto dijkstra_cou(const graph<T> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
vi cou(g.n);
cou[0] = 1;
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
cou[to] = cou[e.f];
q.emplace(dis[to], to);
} else if (dis[to] == c) {
cou[to] += cou[e.f];
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return vtop(dis, cou);
}
// コストを無限に減らせる := -linf
// たどり着けない := linf
template <class T> vector<T> bell(graph<T> &g, int s) {
if (g.n >= 1e4) {
cout << "bell size too big" << endl;
exit(0);
}
vector<T> res(g.n, linf);
res[s] = 0;
vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく */
fix([&](auto ds, int p, int i) -> void {
if (can[i])
return;
can[i] = true;
forg(gi, g[i]) if (t != p) ds(i, t);
})(-1, 0);
vector<edge<T>> es;
fora(e, g.edges) {
if (can[e.f])
es += e;
}
rep(i, g.n) {
bool upd = false;
fora(e, es) {
if (res[e.f] != linf && res[e.t] > res[e.f] + e.c) {
upd = true;
res[e.t] = res[e.f] + e.c;
}
}
if (!upd)
break;
}
rep(i, g.n * 2) {
bool upd = 0;
fora(e, g.edges) {
if (res[e.f] != linf && res[e.t] != -linf && res[e.t] > res[e.f] + e.c) {
upd = 1;
res[e.t] = -linf;
}
}
if (!upd)
break;
}
return res;
}
// コストを無限に増やせる := linf
// たどり着けない := -linf
template <class T> vector<T> bell_far(graph<T> &g, int s) {
if (g.n >= 1e4) {
cout << "bell_far size too big" << endl;
exit(0);
}
vector<T> res(g.n, linf);
res[s] = 0;
vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく*/
fix([&](auto ds, int p, int i) -> void {
if (can[i])
return;
can[i] = true;
forg(gi, g[i]) if (t != p) ds(i, t);
})(-1, 0);
vector<edge<T>> es;
fora(e, g.edges) {
if (can[e.f])
es += e;
}
rep(i, g.n) {
bool upd = false;
fora(e, es) {
if (res[e.f] != linf && res[e.t] > res[e.f] - e.c) { /*-c*/
upd = true;
res[e.t] = res[e.f] - e.c; /*-c*/
}
}
if (!upd)
break;
}
rep(i, g.n * 2) {
bool upd = 0;
fora(e, g.edges) {
if (res[e.f] != linf && res[e.t] != -linf &&
res[e.t] > res[e.f] - e.c) { /*-c*/
upd = 1;
res[e.t] = -linf;
}
}
if (!upd)
break;
}
rep(i, g.n) res[i] *= -1;
return res;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int init_value = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n)
chmi(dis[i][j], dis[i][k] + dis[k][j]); /*基本、たどり着かないなら-1*/
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = init_value;
return dis;
}
template <class T> class MinOp {
public:
T operator()(T a, T b) { return min(a, b); }
};
template <typename OpFunc> struct SparseTable {
OpFunc op;
signed size;
vector<signed> lg;
vector<vector<pair<signed, signed>>> table;
void init(const vector<pair<signed, signed>> &array, OpFunc opfunc) {
signed n = array.size();
op = opfunc;
lg.assign(n + 1, 0);
for (signed i = 1; i <= n; i++) {
lg[i] = 31 - __builtin_clz(i);
}
table.assign(lg[n] + 1, array);
for (signed i = 1; i <= lg[n]; i++) {
for (signed j = 0; j < n; j++) {
if (j + (1 << (i - 1)) < n) {
table[i][j] = op(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
} else {
table[i][j] = table[i - 1][j];
}
}
}
}
pair<signed, signed> query(signed l, signed r) {
assert(l < r);
return op(table[lg[r - l]][l], table[lg[r - l]][r - (1 << lg[r - l])]);
}
};
struct PMORMQ {
vector<signed> a;
SparseTable<MinOp<pair<signed, signed>>> sparse_table;
vector<vector<vector<signed>>> lookup_table;
vector<signed> block_type;
signed block_size, n_block;
void init(const vector<signed> &array) {
a = array;
signed n = a.size();
block_size = std::max(1, (31 - __builtin_clz(n)) / 2);
while (n % block_size != 0) {
a.push_back(a.back() + 1);
n++;
}
n_block = n / block_size;
vector<pair<signed, signed>> b(n_block, make_pair(INT_MAX, INT_MAX));
for (signed i = 0; i < n; i++) {
b[i / block_size] = min(b[i / block_size], make_pair(a[i], i));
}
sparse_table.init(b, MinOp<pair<signed, signed>>());
block_type.assign(n_block, 0);
for (signed i = 0; i < n_block; i++) {
signed cur = 0;
for (signed j = 0; j < block_size - 1; j++) {
signed ind = i * block_size + j;
if (a[ind] < a[ind + 1]) {
cur |= 1 << j;
}
}
block_type[i] = cur;
}
lookup_table.assign(
1 << (block_size - 1),
vector<vector<signed>>(block_size, vector<signed>(block_size + 1)));
for (signed i = 0; i < (1 << (block_size - 1)); i++) {
for (signed j = 0; j < block_size; j++) {
signed res = 0;
signed cur = 0;
signed pos = j;
for (signed k = j + 1; k <= block_size; k++) {
lookup_table[i][j][k] = pos;
if (i & (1 << (k - 1))) {
cur++;
} else {
cur--;
}
if (res > cur) {
pos = k;
res = cur;
}
}
}
}
}
signed query(signed l, signed r) {
assert(l < r);
signed lb = l / block_size;
signed rb = r / block_size;
if (lb == rb) {
return lb * block_size +
lookup_table[block_type[lb]][l % block_size][r % block_size];
}
signed pl = lb * block_size +
lookup_table[block_type[lb]][l % block_size][block_size];
signed pr =
rb * block_size + lookup_table[block_type[rb]][0][r % block_size];
signed pos = pl;
if (r % block_size > 0 && a[pl] > a[pr]) {
pos = pr;
}
if (lb + 1 == rb) {
return pos;
}
signed spv = sparse_table.query(lb + 1, rb).second;
if (a[pos] > a[spv]) {
return spv;
}
return pos;
}
};
/*@formatter:on*/
template <class T = int> class tree : public undigraph<T> {
PMORMQ rmq;
int cnt;
vector<signed> id, in;
bool never = true;
bool never_hld = true;
void dfs(int x, int p, int d, int dis = 0) {
id[cnt] = x;
par[x] = p;
dep.push_back(d);
disv[x] = dis;
in[x] = cnt++;
forg(gi, g[x]) {
if (t == p) {
continue;
}
dfs(t, x, d + 1, dis + c);
id[cnt] = x;
dep.push_back(d);
cnt++;
}
}
void precalc() {
never = false;
cnt = 0;
dep.clear();
disv.assign(n, 0);
in.assign(n, -1);
id.assign(2 * n - 1, -1);
par.assign(n, -1);
dfs(root, -1, 0);
rmq.init(dep);
#ifdef _DEBUG
cerr << "---tree---" << endl;
rep(i, n) {
if (!(i == root || sz(g[i]) > 1))
continue;
cerr << i << " -> ";
vi ts;
forg(gi, g[i]) {
if (t != par[i])
ts.push_back(t);
}
rep(i, sz(ts) - 1) cerr << ts[i] << ", ";
cerr << ts.back() << endl;
}
cerr << endl;
#endif
}
int pos;
void hld_build() {
never_hld = false;
if (never)
precalc();
pos = 0;
vid.assign(n, -1);
head.assign(n, 0);
sub.assign(n, 1);
hvy.assign(n, -1);
hdep.assign(n, 0);
inv.assign(n, 0);
type.assign(n, 0);
build();
#ifdef _DEBUG
cerr << "---hld_index---" << endl;
vi inds;
rep(i, n) if (sz(g[i])) inds.push_back(i);
rep(i, sz(inds)) {
str s = tos(bel(inds[i]));
cerr << std::right << std::setw(sz(s) + (i ? 1 : 0)) << inds[i];
}
cerr << endl;
rep(i, sz(inds)) { cerr << bel(inds[i]) << " "; }
cerr << endl << endl;
cerr << "---hld_edge_index---" << endl;
fora(e, edges) {
if (e.f <= e.t)
cerr << e.f << "-" << e.t << " " << bel(e) << endl;
}
cerr << endl << endl;
#endif
}
void build(vector<int> rs = vector<int>(1, 0)) {
int c = 0;
for (int r : rs) {
dfs(r);
bfs(r, c++);
}
}
void dfs(int rt) {
stack<P> st;
hdep[rt] = 0;
st.emplace(rt, 0);
while (!st.empty()) {
int v = st.top().first;
int &i = st.top().second;
if (i < (int)g[v].size()) {
int u = g[v][i++].t;
if (u == par[v])
continue;
hdep[u] = hdep[v] + 1;
st.emplace(u, 0);
} else {
st.pop();
int res = 0;
forg(gi, g[v]) {
int u = t;
if (u == par[v])
continue;
sub[v] += sub[u];
if (res < sub[u])
res = sub[u], hvy[v] = u;
}
}
}
}
void bfs(int r, int c) {
int &k = pos;
queue<int> q({r});
while (!q.empty()) {
int h = q.front();
q.pop();
for (int i = h; i != -1; i = hvy[i]) {
type[i] = c;
vid[i] = k++;
inv[vid[i]] = i;
head[i] = h;
forg(gi, g[i]) if (t != par[i] && t != hvy[i]) q.push(t);
}
}
}
vi vid;
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::usedv;
vector<int> disv;
vector<signed> dep, par;
vector<int> head, sub, hvy, inv, type,
hdep /*おそらくグループ内のdep*/; /*vid := bel()*/
int root;
tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
int lca(int a, int b) {
if (never)
precalc();
int x = in[a];
int y = in[b];
if (x > y) {
swap(x, y);
}
int pos = rmq.query(x, y + 1);
return id[pos];
}
int dis(int a, int b) {
if (never)
precalc();
int x = in[a];
int y = in[b];
if (x > y) {
swap(x, y);
}
int pos = rmq.query(x, y + 1);
int p = id[pos];
return disv[a] + disv[b] - disv[p] * 2;
}
/*O(N) hldを使わず木を普通にたどる*/
void for_each_l(int u, int v, function<void(int)> fnode) {
int r = lca(u, v);
while (u != r) {
fnode(u);
u = par[u];
}
while (v != r) {
fnode(v);
v = par[v];
}
fnode(r);
}
void for_each_edge_l /*O(N) 頂点に対しての処理順が可換*/ (
int u, int v, function<void(edge<int> &)> fedge) {
int r = lca(u, v);
auto sub = [&](int u, int r) {
while (u != r) {
forg(gi, g[u]) {
if (t == par[u]) {
fedge(g[u][gi]);
u = par[u];
break;
}
}
}
};
sub(u, r);
sub(v, r);
}
/*Fは半開 (u,v)は木の頂点* /
/*中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう*/
void for_each_(int u, int v, const function<void(int, int)> &f) {
if (never_hld)
hld_build();
while (1) {
if (vid[u] > vid[v])
swap(u, v);
int l = max(vid[head[v]], vid[u]);
int r = vid[v] + 1;
f(l, r);
if (head[u] != head[v])
v = par[head[v]];
else
break;
}
}
void for_each_edge /*[l,r) O(log(N)) 辺を頂点として扱っている
上と同じ感じで使える*/
(int u, int v, const function<void(int, int)> &f) {
if (never_hld)
hld_build();
while (1) {
if (vid[u] > vid[v])
swap(u, v);
if (head[u] != head[v]) {
int l = vid[head[v]];
int r = vid[v] + 1;
f(l, r);
v = par[head[v]];
} else {
if (u != v) {
int l = vid[u] + 1;
int r = vid[v] + 1;
f(l, r);
}
break;
}
}
}
int bel(int v) { /*hld内での頂点番号を返す*/
if (never_hld)
hld_build();
return vid[v];
}
int bel(
int f,
int t) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
if (never_hld)
hld_build();
return hdep[f] > hdep[t] ? vid[f] : vid[t];
}
int bel(
edge<T> &
e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
if (never_hld)
hld_build();
return hdep[e.f] > hdep[e.t] ? vid[e.f] : vid[e.t];
}
template <class... U> int operator()(U... args) { return bel(args...); }
};
;
/*@formatter:off*/
// 辺によりメモリを大量消費ためedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::usedv;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, ty, id);
ole();
}
g[f].emplace_back(f, t, c, ty, eid++);
g[t].emplace_back(t, f, c, ty, eid++);
}
int getid(int h, int w) {
if (!ins(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(vector<vector<char>> ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() {
rep(i, n) fora(e, g[i]) if (e.f < e.t) edges.push_back(e);
}
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::usedv;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, ty, id);
ole();
}
g[f].emplace_back(f, t, c, ty, eid++);
}
int getid(int h, int w) {
if (!ins(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(vector<vector<char>> ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.push_back(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
unionfind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int n = g.size();
vb was(n);
queue<P> q;
rep(i, n) {
if (was[i])
continue;
q.push(mp(i, 1));
was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (was[t])
continue;
q.push(mp(t, col ^ 1));
was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, digraph<T> &g) {
os << endl << g.n << " " << sz(g.edges) << endl;
fore(gi, g.edges) { os << f << " " << t << " " << c << endl; }
return os;
}
template <class T> ostream &operator<<(ostream &os, undigraph<T> &g) {
os << endl << g.n << " " << sz(g.edges) << endl;
fore(gi, g.edges) {
if (f < t)
os << f << " " << t << " " << c << endl;
}
return os;
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.push_back(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++; /*小さい順*/
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.push_back(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
// 閉路がある時linfを返す
template <class T> int longest_path(digraph<T> &g) {
vi top;
if (!topo(top, g)) {
return linf;
}
int n = sz(top);
vi dp(n, 0);
for (auto &&i : top) {
forg(gi, g[i]) { chma(dp[t], dp[i] + 1); }
}
return max(dp);
}
template <class T> vi longest_path_v(digraph<T> &g) {
vi top;
if (!topo(top, g)) {
return vi();
}
int n = sz(top);
vi dp(n, 0);
vi pre(n, -1);
for (auto &&i : top) {
forg(gi, g[i]) {
if (chma(dp[t], dp[i] + 1)) {
pre[t] = i;
}
}
}
int s = std::max_element(dp.begin(), dp.end()) - dp.begin();
vi path;
while (s != -1) {
path.push_back(s);
s = pre[s];
}
std::reverse(path.begin(), path.end());
return path;
}
// 連結グラフが与えられる 閉路があるか
template <class T> bool close(undigraph<T> &g) {
int n = 0;
int e = 0;
rep(i, g.n) {
if (sz(g[i]))
n++;
forg(gi, g[i]) { e++; }
}
return (e >> 1) >= n;
}
template <class T> bool close(undigraph<T> &g, int v) {
unionfind uf(g.n);
rep(i, g.n) {
forg(gi, g[i]) {
if (f < t)
break;
if (f == t && f == v)
return true;
if (uf.same(f, v) && uf.same(t, v))
return true;
uf.unite(f, t);
}
}
return false;
}
template <class T> bool close(digraph<T> &g) {
vi res;
return topo(res, g);
}
template <class T> vi indegree(graph<T> &g) {
vi ret(g.size());
rep(i, g.size()) {
forg(gi, g[i]) { ret[t]++; }
}
return ret;
}
template <class T> vi outdegree(graph<T> &g) {
vi ret(g.size());
rep(i, g.size()) { ret[i] = g[i].size(); }
return ret;
}
template <class T> digraph<T> rev(digraph<T> &g) {
digraph<T> r(g.n);
rep(i, g.n) {
forg(gi, g[i]) { r.add(t, f, c); }
}
return r;
}
// 橋を列挙する (取り除くと連結でなくなる辺)
template <class T> vp bridge(graph<T> &G) {
static bool was;
vp brid;
vi articulation;
vi ord(G.n), low(G.n);
vb vis(G.n);
function<void(int, int, int)> dfs = [&](int v, int p, int k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++) {
if (!vis[G[v][i].t]) {
ct++;
dfs(G[v][i].t, v, k);
low[v] = min(low[v], low[G[v][i].t]);
if (~p && ord[v] <= low[G[v][i].t])
isArticulation = true;
if (ord[v] < low[G[v][i].t])
brid.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
} else if (G[v][i].t != p) {
low[v] = min(low[v], ord[G[v][i].t]);
}
}
if (p == -1 && ct > 1)
isArticulation = true;
if (isArticulation)
articulation.push_back(v);
};
int k = 0;
rep(i, n) {
if (!vis[i])
dfs(i, -1, k);
}
sort(brid.begin(), brid.end());
return brid;
}
// 間接点を列挙する (取り除くと連結でなくなる点)
template <class T> vi articulation(undigraph<T> &G) {
static bool was;
vp bridge;
vi arti;
vi ord(G.n), low(G.n);
vb vis(G.n);
function<void(int, int, int)> dfs = [&](int v, int p, int k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++) {
if (!vis[G[v][i].t]) {
ct++;
dfs(G[v][i].t, v, k);
low[v] = min(low[v], low[G[v][i].t]);
if (~p && ord[v] <= low[G[v][i].t])
isArticulation = true;
if (ord[v] < low[G[v][i].t])
bridge.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
} else if (G[v][i].t != p) {
low[v] = min(low[v], ord[G[v][i].t]);
}
}
if (p == -1 && ct > 1)
isArticulation = true;
if (isArticulation)
arti.push_back(v);
};
int k = 0;
rep(i, n) {
if (!vis[i])
dfs(i, -1, k);
}
sort(arti.begin(), arti.end());
return arti;
}
#define kansetu articulation
P farthest(undigraph<> &E, int cur, int pre, int d, vi &D) {
D[cur] = d;
P r = {d, cur};
forg(gi, E[cur]) if (t != pre) {
P v = farthest(E, t, cur, d + 1, D);
r = max(r, v);
}
return r;
}
// dagでなければ-1を返す
int diameter(digraph<> &g) {
vi per;
if (!topo(per, g))
return -1;
int n = g.n;
vi dp(n, 1);
fora(v, per) {
forg(gi, g[v]) { chma(dp[t], dp[f] + 1); }
}
return max(dp);
}
vi diameter(undigraph<> &E) { /* diameter,center*/
vi D[3];
D[0].resize(E.size());
D[1].resize(E.size());
auto v1 = farthest(E, 0, 0, 0, D[0]);
auto v2 = farthest(E, v1.second, v1.second, 0, D[0]);
farthest(E, v2.second, v2.second, 0, D[1]);
int i;
rep(i, D[0].size()) D[2].push_back(max(D[0][i], D[1][i]));
return D[2];
}
// i d
vp diameter_p(undigraph<> &E) { /* diameter,center*/
vector<int> D[3];
D[0].resize(E.size());
D[1].resize(E.size());
auto v1 = farthest(E, 0, 0, 0, D[0]);
auto v2 = farthest(E, v1.second, v1.second, 0, D[0]);
farthest(E, v2.second, v2.second, 0, D[1]);
int i;
vp res(E.size());
rep(i, D[0].size()) {
if (D[0][i] > D[1][i])
res[i] = mp(D[0][i], v1.second);
else
res[i] = mp(D[1][i], v2.second);
}
return res;
}
digraph<> rang_di(int n, int m, bool zibun = 0, bool taju = 0) {
umapp was;
digraph<> g(n);
was[mp(-1, -2)] = 1;
while (m) {
int f = -1, t = -2;
while (f < 0 || (!taju && was[mp(f, t)])) {
f = rand(0, n - 1);
t = rand(0, n - 1);
if (!zibun && f == t)
f = -1;
}
g.add(f, t);
was[mp(f, t)] = 1;
m--;
}
return g;
}
digraph<> perfect_di(int n, bool zibun = 0) {
digraph<> g(n);
rep(i, n) {
rep(j, n) {
if (!zibun && i == j)
con;
g.add(i, j);
}
}
return g;
}
undigraph<> rang_un(int n, int m, bool zibun = 0, bool taju = 0) {
umapp was;
undigraph<> g(n);
was[mp(-1, -2)] = 1;
while (m) {
int f = -1, t = -2;
while (f < 0 || (!taju && was[mp(min(f, t), max(f, t))])) {
f = rand(0, n - 1);
t = rand(0, n - 1);
if (!zibun && f == t)
f = -1;
}
g.add(f, t);
was[mp(min(f, t), max(f, t))] = 1;
m--;
}
return g;
}
undigraph<> perfect_un(int n, bool zibun = 0) {
undigraph<> g(n);
rep(i, n) {
rep(j, i, n) {
if (!zibun && i == j)
con;
g.add(i, j);
}
}
return g;
}
/*閉路が1つしかない場合、その閉路に含まれる頂点を1としたvectorを返す*/;
template <class T> vi get_close1(digraph<T> &g) {
int n = g.n;
queue<int> q;
vi d = outdegree(g);
vi res(n, 1);
rep(i, n) {
if (d[i] == 0) {
q += i;
res[i] = 0;
}
}
auto rg = rev(g);
while (q.size()) {
auto now = q.front();
q.pop();
forg(gi, rg[now]) {
if (--d[t] == 0) {
q += t;
res[t] = 0;
}
}
}
return res;
};
// 閉路パスを一つ返す
vi close_path(digraph<> &g) {
int n = g.n;
vi state(n);
vi path;
rep(i, n) if (!state[i]) {
if (fix([&](auto dfs, int v) -> bool {
if (state[v]) {
if (state[v] == 1) {
path.erase(path.begin(), find(path.begin(), path.end(), v));
return true;
}
return false;
}
path.push_back(v);
state[v] = 1;
forg(gi, g[v]) {
if (dfs(t))
return true;
}
state[v] = -1;
path.pop_back();
return false;
})(i)) {
return path;
}
}
return vi();
}
vi close_path_min(digraph<> &g) {
int n = g.n;
vvi(dis, n);
rep(i, n) dis[i] = dijkstra(g, i, linf);
int mind = linf;
int f = 0, t = 0;
rep(i, n) {
rep(j, n) {
if (i == j)
continue;
if (chmi(mind, dis[i][j] + dis[j][i])) {
f = i;
t = j;
}
}
}
vi path;
auto add = [&](int f, int t) {
int now = f;
while (now != t) {
rep(i, n) {
if (dis[now][i] == 1 && dis[f][i] + dis[i][t] == dis[f][t]) {
path.push_back(i);
now = i;
break;
}
}
}
};
add(f, t);
add(t, f);
return path;
}
template <class T> int krus(undigraph<T> &g) {
int res = 0;
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res += e.c;
}
}
return res;
}
// idは 00 11 22のようにedgesに持たれている
template <class T> vi krus_id(undigraph<T> &g) {
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
vi res;
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.push_back(e.id);
}
}
return res;
}
template <class T> vector<edge<T>> krus_ed(undigraph<T> &g) {
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
vector<edge<T>> res;
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.push_back(e);
}
}
return res;
}
template <class T> tree<T> krus_tr(undigraph<T> &g) {
tree<T> res(g.n);
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.add(e.f, e.t);
}
}
return res;
}
template <class T> vector<vector<edge<T>>> type_list(digraph<T> &g) {
vector<vector<edge<T>>> res;
rep(i, g.n) {
forg2(gi, g[i]) { res[ty].push_back(g[i][gi]); }
}
return res;
}
template <class T>
vector<vector<edge<T>>> type_list(undigraph<T> &g, int types = -1) {
int tn = types;
if (types == -1)
tn = g.n;
rep(i, g.n) {
forg2(gi, g[i]) { chma(tn, ty); }
}
vector<vector<edge<T>>> res(tn + 1);
vi was(g.n);
rep(i, g.n) {
forg2(gi, g[i]) {
if (f < t)
res[ty].push_back(g[i][gi]);
else if (f == t && !was[f]) {
res[ty].push_back(g[i][gi]);
was[f] = 1;
}
}
}
return res;
}
/*頂点数がkの木を一つ返す サイズが0の木が帰ったら終了*/
tree<int> next_tree(int k) {
assert(2 <= k && k < 11);
static str name;
static ifstream ina;
static int rem;
static vp edges;
static int pk = -1; /*前回見たk*/
if (pk != k) {
if (~pk)
ina.close();
edges.clear();
pk = k;
name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\trees_sizek\\nazeka6.txt"
: "C:\\Users\\kaout\\Desktop\\trees_sizek\\tree_size" +
tos(k) + ".txt";
ina = ifstream(name);
rem = pow(k, k - 2); /*Cayleyの定理*/
rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
pk = k;
}
tree<int> g(k);
if (rem == 0) {
g.resize(0);
return g;
}
int m;
ina >> m;
while (m) {
int lb = lbit(m);
int id = log2(lb);
g.add(edges[id].first, edges[id].second);
m ^= lb;
}
rem--;
return g;
}
undigraph<int> next_undi(int k) {
assert(2 <= k && k < 9);
static str name;
static ifstream ina;
static int rem;
static vp edges;
static vi lims = {-1, -1, 1, 4, 38, 728, 26704, 1866256};
static int pk = -1; /*前回見たk*/
if (pk != k) {
if (~pk)
ina.close();
edges.clear();
pk = k;
name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\undi_sizek\\roku.txt"
: "C:\\Users\\kaout\\Desktop\\undi_sizek\\undi_size" +
tos(k) + ".txt";
ina = ifstream(name);
rem = lims[k];
rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
pk = k;
}
undigraph<int> g(k);
if (rem == 0) {
g.resize(0);
return g;
}
int m;
ina >> m;
while (m) {
int lb = lbit(m);
int id = log2(lb);
g.add(edges[id].first, edges[id].second);
m ^= lb;
}
rem--;
return g;
}
vector<tree<int>> trees(int k) {
vector<tree<int>> res;
while (1) {
tree<int> g = next_tree(k);
if (sz(g) == 0)
break;
res.push_back(g);
}
return res;
}
vector<undigraph<int>> undis(int k) {
vector<undigraph<int>> res;
while (1) {
undigraph<int> g = next_undi(k);
if (sz(g) == 0)
break;
res.push_back(g);
}
return res;
} /*@formatter:on*/
template <class M = int> struct segsum { /*@formatter:off*/
int n;
vector<M> seg;
M f(M a, M b) { return a + b; }
const M e = (M)0;
segsum(vector<M> &dat) {
n = 1;
int asz = dat.size();
while (n <= asz)
n <<= 1;
seg.assign((n << 1) - 1, e);
rep(i, asz) seg[i + n - 1] = dat[i];
rer(i, n - 2) seg[i] = f(seg[(i << 1) | 1], seg[(i << 1) + 2]);
debu();
}
segsum(int len, M init_value) : e(init_value) {
n = 1;
int asz = len;
while (n <= asz)
n <<= 1;
seg.assign((n << 1) - 1, e);
rep(i, asz) seg[i + n - 1] = e;
rer(i, n - 2) seg[i] = f(seg[(i << 1) | 1], seg[(i << 1) + 2]);
debu();
}
void update(int k, M v) {
int tk = k;
seg[k + n - 1] = v;
k += n - 1;
while (k) {
k = (k - 1) >> 1;
seg[k] = f(seg[(k << 1) | 1], seg[(k << 1) + 2]);
}
debup(tk, v);
}
void del(int k) { update(k, e); }
void add(int k, int v) { update(k, v + seg[k + n - 1]); }
M query_bottomup(int l, int r) {
int tl = l, tr = r;
M retl = e;
M retr = e;
l += n - 1;
r += n - 1;
while (l < r) { /*右なら、次に右上へ移動してしまうので*/
if (!(l & 1)) {
retl = f(retl, seg[l]);
} /*右なら、左を取らないと機会を逃す*/
if (!(r & 1)) {
retr = f(seg[r - 1], retr);
}
l >>= 1;
r = (r - 1) >> 1;
}
M ret = f(retl, retr);
debge(tl, tr, ret);
return ret;
}
M query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
else if (a <= l && r <= b)
return seg[k];
else {
M sl = query(a, b, (k << 1) | 1, l, (l + r) >> 1);
M sr = query(a, b, (k << 1) + 2, (l + r) >> 1, r);
return f(sl, sr);
}
} /* M get(int a = 0, int b = -1) { return query(a, b == -1 ? n : b, 0, 0,
n); }*/
M get(int a, int b) { return query_bottomup(a, min(b, n)); }
M get(int b = inf) { return query_bottomup(0, min(b, n)); }
int operator()(int b = inf) { return get(0, b); }
int operator()(int a, int b) { return get(a, b); }
M operator[](int k) { return seg[k + n - 1]; }
#ifdef _DEBUG
void debu() {
rep(i, min(n, 10ll)) {
int v = operator[](i);
if (v == MIN(ll) || v == MAX(ll)) {
cerr << "e ";
} else {
cerr << v << " ";
}
}
cerr << "" << endl << endl;
}
void debup(int k, int v) {
cerr << "upd : [" << k << "] = " << v << endl;
debu();
}
void debge(int l, int r, M v) {
cerr << "get : [" << l << ", " << r << ") = " << v << endl;
debu();
}
#else
void debu() { ; }
void debup(int k, int v) { ; }
void debge(int l, int r, M v) { ; } /*@formatter:on*/
#endif
};
void solve() {
// int q;
// in(n, q);
// tree<> g(2 * k5);;
// g.ingtc(n, n - 1);
// dna4(C, L, U, V, q);
// dec(C), dec(U), dec(V);
// vvi(qci, k5);
// rep(i, q) {
// qci[C[i]] += i;
// }
// vi res(q);
// segsum<> co(k5, 0);
// segsum<> sm(k5, 0);
// auto E = type_list(g);
// rep(ci, sz(E)) {
// fora(e, E[ci]) {
// int p = g(e);
// co.upd(p, 1);
// sm.upd(p, e.c);
// }
//
// fora(i, qci[ci]) {
// int u = U[i], v = V[i];
// g.for_each_(u, v, [&](int l, int r) {
// res[i] -= sm(l, r);
// res[i] += co(l, r) * L[i];
// });
// }
//
// fora(e, E[ci]) {
// int p = g(e);
// co.upd(p, 0);
// sm.upd(p, 0);
// }
// }
// rep(i, q)res[i] += g.dis(U[i],V[i]);
// outl(res);
int q;
tree<> g(2);
in(n, q);
g.ingtc(n, n - 1);
dna4d(cs, ls, u, v, q);
inc(ls, 1);
vi res(q);
rep(i, q) { res[i] = g.dis(u[i], v[i]); }
auto es = type_list(g);
vvi(qs, k5);
rep(i, q) { qs[cs[i]] += i; }
deb(qs);
segsum<int> cou(k5, 0);
segsum<int> sum(k5, 0);
rep(ci, k5) {
fora(e, es[ci]) {
int p = g.bel(e);
cou.add(p, 1);
sum.add(p, e.c);
}
fora(qi, qs[ci]) {
auto f = [&](int l, int r) {
res[qi] -= sum.get(l, r);
res[qi] += cou.get(l, r) * ls[qi];
};
g.for_each_edge(u[qi], v[qi], f);
}
fora(e, es[ci]) {
int p = g.bel(e);
cou.add(p, -1);
sum.add(p, -e.c);
}
}
outl(res);
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
ll n = rand(1, 8);
vi a = ranv(n, 1, 10);
auto myres = my(arg);
auto res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "AC : " << res << endl;
cerr << "MY : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| // #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long
#define ll long long
auto start_time = system_clock::now();
//@formatter:off
#ifdef _DEBUG
// 区間削除は出来ない
template <class T> struct my_pbds_tree {
set<T> s;
auto begin() { return s.begin(); }
auto end() { return s.end(); }
auto rbegin() { return s.rbegin(); }
auto rend() { return s.rend(); }
auto empty() { return s.empty(); }
auto size() { return s.size(); }
void clear() { s.clear(); }
template <class U> void insert(U v) { s.insert(v); }
template <class U> void operator+=(U v) { insert(v); }
template <class F> auto erase(F v) { return s.erase(v); }
template <class U> auto find(U v) { return s.find(v); }
template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
auto find_by_order(ll k) {
auto it = s.begin();
for (ll i = 0; i < k; i++)
it++;
return it;
}
auto order_of_key(ll v) {
auto it = s.begin();
ll i = 0;
for (; it != s.end() && *it < v; i++)
it++;
return i;
}
};
#define pbds(T) my_pbds_tree<T>
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
unordered_map<T, U> m;
my_unordered_map(){};
auto begin() { return m.begin(); }
auto end() { return m.end(); }
auto cbegin() { return m.cbegin(); }
auto cend() { return m.cend(); }
template <class V> auto erase(V v) { return m.erase(v); }
void clear() {
m.clear();
} /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
template <class V> auto find(V v) { return m.find(v); }
template <class V> auto &operator[](V n) { return m[n]; }
};
#define unordered_map my_unordered_map
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umapip unordered_map<ll, P>
#else
#define unordered_map __gnu_pbds::gp_hash_table
// find_by_order(k) k番目のイテレーター
// order_of_key(k) k以上が前から何番目か
#define pbds(U) \
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
__gnu_pbds::tree_order_statistics_node_update>
#define umapi unordered_map<ll, ll, xorshift>
#define umapp unordered_map<P, ll, xorshift>
#define umapip unordered_map<ll, P, xorshift>
#endif
struct xorshift {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
size_t operator()(std::pair<ll, ll> x) const {
ll v = ((x.first) << 32) | x.second;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(v + FIXED_RANDOM);
}
};
template <class U, class L>
void operator+=(
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update> &s,
L v) {
s.insert(v);
}
// 衝突対策
#define ws wszzzz
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) const {
return f != r.f ? f < r.f
: s != r.s ? s < r.s
: t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
r.s : t > r.t; 大きい順 */
}
bool operator>(const T2 &r) const {
return f != r.f ? f > r.f
: s != r.s ? s > r.s
: t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
r.s : t > r.t; 小さい順 */
}
bool operator==(const T2 &r) const {
return f == r.f && s == r.s && t == r.t;
}
bool operator!=(const T2 &r) const {
return f != r.f || s != r.s || t != r.t;
}
};
template <class A, class B, class C, class D> struct F2 {
A a;
B b;
C c;
D d;
F2() { a = 0, b = 0, c = 0, d = 0; }
F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F2 &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d; /* return a != r.a ? a > r.a : b != r.b ? b
> r.b : c != r.c ? c > r.c : d > r.d;*/
}
bool operator>(const F2 &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d; /* return a != r.a ? a < r.a : b != r.b
? b < r.b : c != r.c ? c < r.c : d < r.d;*/
}
bool operator==(const F2 &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F2 &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
ll operator[](ll i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
T mt(ll a, ll b, ll c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define wh while
#define upd update
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam(right) [&](ll &p) { return p right; }
// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;
#define vec vector
#define o_vvt(o1, o2, o3, o4, name, ...) name
#define vvt0(t) vec<vec<t>>
#define vvt1(t, a) vec<vec<t>> a
#define vvt2(t, a, b) vec<vec<t>> a(b)
#define vvt3(t, a, b, c) vec<vec<t>> a(b, vec<t>(c))
#define vvt4(t, a, b, c, d) vec<vec<t>> a(b, vec<t>(c, d))
#define vvi(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...) \
o_vvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define bset bitset
#define uset unordered_set
#define useti unordered_set<ll, ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
template <class T> struct pq {
priority_queue<T, vector<T>, greater<T>> q; /*小さい順*/
T su = 0;
void clear() {
q = priority_queue<T, vector<T>, greater<T>>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
template <class T> struct pqg {
priority_queue<T> q; /*大きい順*/
T su = 0;
void clear() {
q = priority_queue<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
#define pqi pq<ll>
#define pqgi pqg<ll>
// マクロ 繰り返し
#define o_rep(o1, o2, o3, o4, name, ...) name
#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
#define rep(...) o_rep(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
#define rer(...) o_rep(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (ll i = 0, reps2lim = n; i < reps2lim; ++i) \
for (ll j = 0; j < reps2lim; ++j)
#define reps3(i, j, k, n) \
for (ll i = 0, reps3lim = n; i < reps3lim; ++i) \
for (ll j = 0; j < reps3lim; ++j) \
for (ll k = 0; k < reps3lim; ++k)
#define reps4(i, j, k, l, n) \
for (ll i = 0, reps4lim = n; i < reps4lim; ++i) \
for (ll j = 0; j < reps4lim; ++j) \
for (ll k = 0; k < reps4lim; ++k) \
for (ll l = 0; l < reps4lim; ++l)
#define o_reps(o1, o2, o3, o4, o5, name, ...) name
#define reps(...) o_reps(__VA_ARGS__, reps4, reps3, reps2, rep2, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (ll i = 0; i < a; ++i) \
for (ll j = 0; j < b; ++j) \
for (ll k = 0; k < c; ++k)
#define fora(a, b) for (auto &&a : b)
// インデックスを前後含めて走査
#define fori(i, s, len) \
for (int i = s, prev = (s == 0) ? len - 1 : s - 1, \
next = (s == len - 1) ? 0 : s + 1, cou = 0; \
cou < len; \
cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// vectorの中身を先頭から見る
#define foriv(i, v, d) \
int i = 0; \
for (auto prev = d[sz(d) - 1], next = d[1], v = d[0]; i < sz(d); \
i++, prev = v, v = next, next = (i >= sz(d) - 1 ? d[0] : d[i + 1]))
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; ++it)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const ll inf = (ll)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public
: /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
} // namespace std
// stream まとめ
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (ll i = 0; i < vec.size(); ++i)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, vector<pair<T, U>> &vec) {
for (ll i = 0; i < vec.size(); ++i) {
os << vec[i];
if (i != vec.size() - 1)
os << endl;
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (ll i = 0; i < vec.size(); ++i) {
for (ll j = 0; j < vec[i].size(); ++j) {
os << vec[i][j] << " ";
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
fora(v, a) os << v << " ";
return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec) {
rep(h, sz(vec)) {
rep(w, sz(vec[0])) { os << vec[h][w]; }
os << endl;
}
return os;
}
template <typename W, typename H> void resize(vector<W> &vec, const H head) {
vec.resize(head);
}
template <typename W, typename H, typename... T>
void resize(vector<W> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename F> bool all_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (!all_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool any_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (any_of2(v[i], f))
return true;
}
return false;
}
template <typename T, typename F> bool none_of2(T &v, F f) { return f(v); }
template <typename T, typename F> bool none_of2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (none_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool find_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll find_if2(vector<T> &v, F f) {
rep(i, sz(v)) {
if (find_if2(v[i], f))
return i;
}
return sz(v);
}
template <typename T, typename F> bool rfind_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll rfind_if2(vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (rfind_if2(v[i], f))
return i;
}
return -1;
}
template <class T> bool contains(string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(vector<T> &vec, F f) {
ll ret = 0;
fora(v, vec) ret += count_if2(v, f);
return ret;
}
template <typename T, typename F> void for_each2(T &v, F f) { f(v); }
template <typename T, typename F> void for_each2(vector<T> &vec, F f) {
fora(v, vec) for_each2(v, f);
}
template <typename W> ll count_od(vector<W> &a) {
return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(vector<W> &a) {
return count_if2(a, [](ll v) { return !(v & 1); });
}
#define all_of(a, right) all_of2(a, lam(right))
#define any_of(a, right) any_of2(a, lam(right))
#define none_of(a, right) none_of2(a, lam(right))
#define find_if(a, right) find_if2(a, lam(right))
#define rfind_if(a, right) rfind_if2(a, lam(right))
#define contains_if(a, right) contains_if2(a, lam(right))
#define count_if(a, right) count_if2(a, lam(right))
#define for_each(a, right) \
do { \
fora(v, a) { v right; } \
} while (0)
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
void replace(str &a, str key, str v) {
stringstream t;
ll kn = sz(key);
std::string::size_type Pos(a.find(key));
ll l = 0;
while (Pos != std::string::npos) {
t << a.substr(l, Pos - l);
t << v;
l = Pos + kn;
Pos = a.find(key, Pos + kn);
}
t << a.substr(l, sz(a) - l);
a = t.str();
}
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
void iota(vector<ll> &ve, ll s, ll n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(ll s, ll len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
assert(sz(a) == sz(b)); /*stringを0で初期化できない */
vector<pair<A, B>> res;
rep(i, sz(a)) res.eb(a[i], b[i]);
return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
a.resize(sz(p)), b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
assert(sz(a) == sz(b) && sz(b) == sz(c));
vector<T2<A, B, C>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
vector<F2<A, B, C, D>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
return res;
}
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
fisiti,
fisitd,
fisdti,
fisdtd,
fdsiti,
fdsitd,
fdsdti,
fdsdtd,
fitisi,
fitisd,
fitdsi,
fitdsd,
fdtisi,
fdtisd,
fdtdsi,
fdtdsd,
sifiti,
sifitd,
sifdti,
sifdtd,
sdfiti,
sdfitd,
sdfdti,
sdfdtd,
sitifi,
sitifd,
sitdfi,
sitdfd,
sdtifi,
sdtifd,
sdtdfi,
sdfdfd,
tifisi,
tifisd,
tifdsi,
tifdsd,
tdfisi,
tdfisd,
tdfdsi,
tdfdsd,
tisifi,
tisifd,
tisdfi,
tisdfd,
tdsifi,
tdsifd,
tdsdfi,
tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
typedef pair<A, B> U;
if (type == fisi)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
else if (type == fisd)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
else if (type == fdsi)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
else if (type == fdsd)
sort(all(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
else if (type == sifi)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
else if (type == sifd)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
else if (type == sdfi)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
else if (type == sdfd)
sort(all(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
if (type == fisi)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
else if (type == fisd)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
else if (type == fdsi)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
else if (type == fdsd)
sort(all(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
else if (type == sifi)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
else if (type == sifd)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
else if (type == sdfi)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
else if (type == sdfd)
sort(all(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
typedef F2<A, B, C, D> U;
if (type == fisi)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
else if (type == fisd)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
else if (type == fdsi)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
else if (type == fdsd)
sort(all(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
else if (type == sifi)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
else if (type == sifd)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
else if (type == sdfi)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
else if (type == sdfd)
sort(all(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
if (type == 0)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 1)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 2)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 3)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 4)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 5)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 6)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 7)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 8)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 9)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 10)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 11)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 12)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 13)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 14)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 15)
sort(all(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 16)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 17)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 18)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 19)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 20)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 21)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 22)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 23)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 24)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 25)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 26)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 27)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 28)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 29)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 30)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 31)
sort(all(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 32)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 33)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 34)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 35)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 36)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 37)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 38)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 39)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 40)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 41)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 42)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 43)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
else if (type == 44)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 45)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 46)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 47)
sort(all(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
typedef F2<A, B, C, D> U;
if (type == 0)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 1)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 2)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 3)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 4)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 5)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 6)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 7)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 8)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 9)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 10)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 11)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 12)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 13)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 14)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 15)
sort(all(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 16)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 17)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 18)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 19)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 20)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 21)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 22)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 23)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 24)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 25)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 26)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 27)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 28)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 29)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 30)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 31)
sort(all(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 32)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 33)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 34)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 35)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 36)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 37)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 38)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 39)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 40)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 41)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 42)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 43)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
else if (type == 44)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 45)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 46)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 47)
sort(all(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
}
void sort(string &a) { sort(all(a)); }
template <class T> void sort(vector<T> &a) { sort(all(a)); }
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
sort(all(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class T> void rsort(vector<T> &a) { sort(all(a), greater<T>()); };
template <class U, class F> void rsort(vector<U> &a, F f) {
sort(all(a), [&](U l, U r) { return f(l) > f(r); });
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
sort(c);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
sort(c, f);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
rsort(c);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
rsort(c, f);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
sort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
sort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
rsort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
rsort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
sort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
rsort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind);
return ind;
} /*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind, f);
return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
return ind;
}
template <class T> vi rsorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
rsortp(b, ind);
return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
vi ind = iota(0, sz(a));
auto c = a;
auto d = b;
sortt(c, d, ind, f);
return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
vi ind = iota(0, sz(a));
auto d = vtof(a, b, c, ind);
sort(d, f);
rep(i, sz(a)) ind[i] = d[i].d;
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] < c[y];
else
return b[x] < b[y];
} else {
return a[x] < a[y];
}
});
return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(all(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] > c[y];
else
return b[x] > b[y];
} else {
return a[x] > a[y];
}
});
return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
rsort(a[i]);
}
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, const T v, ll len) {
rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, const T v, ll lh, ll lw) {
rep(i, lh) rep(j, lw) xx[i][j] = v;
}
template <class T, class U> void fill(vector<T> &a, U val, vi &ind) {
fora(v, ind) a[v] = val;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
//@汎用便利関数 入力
ll in() {
ll ret;
cin >> ret;
return ret;
}
string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define o_din(o1, o2, o3, o4, o5, o6, name, ...) name
#define din1(a) \
ll a; \
cin >> a
#define din2(a, b) \
ll a, b; \
cin >> a >> b
#define din3(a, b, c) \
ll a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
ll a, b, c, d; \
cin >> a >> b >> c >> d
#define din5(a, b, c, d, e) \
ll a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define din6(a, b, c, d, e, f) \
ll a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define din(...) \
o_din(__VA_ARGS__, din6, din5, din4, din3, din2, din1)(__VA_ARGS__)
#define o_dins(o1, o2, o3, o4, o5, o6, name, ...) name
#define dins1(a) \
str a; \
cin >> a
#define dins2(a, b) \
str a, b; \
cin >> a >> b
#define dins3(a, b, c) \
str a, b, c; \
cin >> a >> b >> c
#define dins4(a, b, c, d) \
str a, b, c, d; \
cin >> a >> b >> c >> d
#define dins5(a, b, c, d, e) \
str a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define dins6(a, b, c, d, e, f) \
str a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define dins(...) \
o_dins(__VA_ARGS__, dins6, dins5, dins4, dins3, dins2, dins1)(__VA_ARGS__)
#define o_dind(o1, o2, o3, o4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) o_dind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }
#ifdef _DEBUG
template <class T> string out_m(vector<T> &a, ll W = inf) {
stringstream ss;
if (W == inf)
W = min(sz(a), 12ll);
if (sz(a) == 0)
return ss.str();
rep(i, W) { ss << a[i] << " "; }
ss << "" << endl;
return ss.str();
}
template <class T>
string out_m(vector<vector<T>> &a, ll H = inf, ll W = inf, int key = -1) {
H = min({H, sz(a), 12ll});
W = min({W, sz(a[0]), 12ll});
stringstream ss;
ss << endl;
if (key == -1)
ss << " *|";
else
ss << " " << key << "|";
rep(w, W) ss << std::right << std::setw(4) << w;
ss << "" << endl;
rep(w, W * 4 + 3) ss << "_";
ss << "" << endl;
rep(h, H) {
ss << std::right << std::setw(2) << h << "|";
rep(w, min(sz(a[h]), 12ll)) {
if (a[h][w] == linf)
ss << " e"
<< " ";
else
ss << std::right << std::setw(4) << a[h][w];
}
ss << "" << endl;
}
ss << endl;
return ss.str();
}
/*@formatter:off*/
template <class T>
string out_m(vector<vector<vector<T>>> &a, ll H = inf, ll W = inf, ll U = inf) {
stringstream ss;
if (H == inf)
H = 5;
H = min(H, sz(a));
rep(i, H) {
ss << endl;
ss << out_m(a[i], W, U, i);
}
ss << endl;
return ss.str();
}
string out_m(int a) {
stringstream ss;
ss << a << endl;
return ss.str();
}
template <class T> string out_m(T &a) {
stringstream ss;
ss << a << endl;
return ss.str();
}
template <class T> void outv(vector<T> &a, ll W = inf) {
cout << out_m(a, W) << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
cout << out_m(a, H, W, key) << endl;
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
cout << out_m(a, H, W, U) << endl;
}
#else
template <class T> void outv(vector<T> &a, ll W = inf) {
rep(i, min(W, sz(a))) { cout << a[i] << " "; }
cout << "" << endl;
}
template <class T>
void outv(vector<vector<T>> &a, ll H = linf, ll W = linf, int key = -1) {
rep(i, min(H, sz(a))) { outv(a[i], W); }
}
template <class T>
void outv(vector<vector<vector<T>>> &a, ll H = linf, ll W = linf, ll U = linf) {
;
}
#endif
template <class T> void outl(vector<T> &a, int n = inf) {
rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
rep(i, sz(a)) {
rep(j, sz(a[i])) { cout << a[i][j]; }
cout << endl;
}
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
template <class T> void na(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i];
}
#define dna(a, n) \
vi a(n); \
rep(dnai, n) cin >> a[dnai];
#define dnad(a, n) \
vi a(n); \
rep(dnai, n) cin >> a[dnai], a[dnai]--;
template <class T> void nao(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i], a[i]--;
}
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i];
}
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(dna2i, n) cin >> a[dna2i] >> b[dna2i];
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n + 1);
b.resize(n + 1);
a[0] = b[0] = 0;
rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
#define dna2d(a, b, n) \
vi a(n), b(n); \
rep(dna2di, n) { \
cin >> a[dna2di] >> b[dna2di]; \
a[dna2di]--, b[dna2di]--; \
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(dna3i, n) cin >> a[dna3i] >> b[dna3i] >> c[dna3i];
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(dna3di, n) { \
cin >> a[dna3di] >> b[dna3di] >> c[dna3di]; \
a[dna3di]--, b[dna3di]--, c[dna3di]--; \
}
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
d.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n) \
vi a(n), b(n), c(n), d(n); \
rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i];
#define dna4d(a, b, c, d, n) \
vi a(n), b(n), c(n), d(n); \
rep(dna4i, n) cin >> a[dna4i] >> b[dna4i] >> c[dna4i] >> d[dna4i], \
--a[dna4i], --b[dna4i], --c[dna4i], --d[dna4i];
#define nt(a, h, w) \
resize(a, h, w); \
rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w) \
resize(a, h, w); \
rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define deb1(x) debugName(x) << " = " << out_m(x)
#define deb2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb3(x, ...) deb1(x) << ", " << deb2(__VA_ARGS__)
#define deb4(x, ...) deb1(x) << ", " << deb3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
#define deb7(x, ...) deb1(x) << ", " << deb6(__VA_ARGS__)
#define deb8(x, ...) deb1(x) << ", " << deb7(__VA_ARGS__)
#define deb9(x, ...) deb1(x) << ", " << deb8(__VA_ARGS__)
#define deb10(x, ...) deb1(x) << ", " << deb9(__VA_ARGS__)
#define o_ebug(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << o_ebug(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb4, deb3, \
deb2, deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
//@formatter:off
// よく使うクラス、構造体
struct unionfind {
vector<ll> par;
vector<ll> siz;
vector<ll> es;
ll n, trees; // 連結グループの数(親の種類)
unionfind(ll n) : n(n), trees(n) {
par.resize(n);
siz.resize(n);
es.resize(n);
for (ll i = 0; i < n; i++) {
par[i] = i;
siz[i] = 1;
}
}
ll root(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = root(par[x]);
}
}
bool unite(ll x, ll y) {
x = root(x);
y = root(y);
es[x]++;
if (x == y)
return false;
if (siz[x] > siz[y])
swap(x, y);
trees--;
par[x] = y;
siz[y] += siz[x];
es[y] += es[x];
return true;
}
bool same(ll x, ll y) { return root(x) == root(y); }
ll size(ll x) { return siz[root(x)]; }
ll esize(ll x) { return es[root(x)]; }
vi sizes() {
vi cou(n);
vi ret;
ret.reserve(n);
rep(i, n) { cou[root(i)]++; }
rep(i, n) {
if (cou[i])
ret.push_back(cou[i]);
}
return ret;
}
// つながりを無向グラフと見なし、xが閉路に含まれるか判定
bool close(ll x) { return esize(x) >= size(x); }
vec<vi> sets() {
vi ind(n, -1);
ll i = 0;
vvi(res, trees);
rep(j, n) {
ll r = root(j);
if (ind[r] == -1)
ind[r] = i++;
res[ind[r]].push_back(j);
}
rep(i, trees) {
ll r = root(res[i][0]);
if (res[i][0] == r)
continue;
rep(j, 1, sz(res[i])) {
if (res[i][j] == r) {
swap(res[i][0], res[i][j]);
break;
}
}
}
return res;
}
}; //@formatter:off
using bll = __int128;
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
ll len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
//__int128 toi128(string &s) { __int128 ret = 0; for (ll i = 0; i <
//s.length(); ++i) if ('0' <= s[i] && s[i] <= '9') ret = 10 *
//ret + s[i] - '0'; return ret;}
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() {
assert(0 == 1);
exit(0);
}
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
vi ranv(ll n, ll min, ll max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
str ransu(ll n) {
str s;
rep(i, n) s += (char)rand('A', 'Z');
return s;
}
str ransl(ll n) {
str s;
rep(i, n) s += (char)rand('a', 'z');
return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
// 便利 汎用
void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, ll>> run_length(string &a) {
vector<pair<char, ll>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> ll mgr(ll ok, ll ng, F f) {
if (ok < ng)
while (ng - ok > 1) {
ll mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
while (ok - ng > 1) {
ll mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else if (a < b)
return b;
else
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) > sz(b)) {
return b;
} else if (sz(a) < sz(b)) {
return a;
} else if (a > b)
return b;
else
return a;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename W, typename U>
T find(vector<vector<vector<W>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename W, typename T> ll count2(W &a, const T k) { return a == k; }
template <typename W, typename T> ll count2(vector<W> &a, const T k) {
ll ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
template <typename W, typename T> ll count(vector<W> &a, const T k) {
ll ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
ll count(str &a, str k) {
ll ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ++ret;
return ret;
}
vi count(str &a) {
vi cou(26);
char c = 'a';
if ('A' <= a[0] && a[0] <= 'Z')
c = 'A';
rep(i, sz(a))++ cou[a[i] - c];
return cou;
}
#define couif count_if
// algorythm
ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class U> void rev(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
a = b;
}
void rev(string &a) { reverse(all(a)); }
constexpr ll p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
ll get(ll a, ll keta) { return (a / (ll)pow(10, keta)) % 10; }
ll keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
ll dsum(ll v, ll sin = 10) {
ll ret = 0;
for (; v; v /= sin)
ret += v % sin;
return ret;
}
struct sint {
ll v;
sint(ll v) : v(v) {}
operator ll() { return v; }
// 下からi番目
ll operator[](ll i) { return (v / p10[i]) % 10; }
ll back(ll i) { return operator[](i); }
// 上からi番目
ll top(ll i) {
ll len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
ll settop(ll i, ll k) {
ll len = keta(v);
return set(len - 1 - i, k);
}
ll set(ll i, ll k) {
if (i < 0)
return settop(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
ll add(ll i, ll k = 1) { return v += p10[i] * k; }
ll addtop(ll i, ll k = 1) { return v += p10[keta(v) - i - 1] * k; }
ll dec(ll i, ll k = 1) { return v -= p10[i] * k; }
ll dectop(ll i, ll k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> t operator o(T r) { return v o r; }
op(ll, +=);
op(ll, -=);
op(ll, *=);
op(ll, /=);
op(ll, %=);
op(ll, +);
op(ll, -);
op(ll, *);
op(ll, /);
op(ll, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> ll operator<<=(T r) { return v *= p10[r]; }
template <class T> ll operator<<(T r) { return v * p10[r]; }
template <class T> ll operator>>=(T r) { return v /= p10[r]; }
template <class T> ll operator>>(T r) { return v / p10[r]; }
};
ll mask10(ll v) { return p10[v] - 1; }
// 変換系
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
template <class T> auto keys(T &a) {
vector<decltype((a.begin())->fi)> res;
for (auto &&k : a)
res.push_back(k.fi);
return res;
}
template <class T> auto values(T &a) {
vector<decltype((a.begin())->se)> res;
for (auto &&k : a)
res.push_back(k.se);
return res;
}
template <class T, class U> bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> T min(vector<T> &a) { return *min_element(all(a)); }
template <class T> T mini(vector<T> &a) {
return min_element(all(a)) - a.begin();
}
template <class T> T min(vector<T> &a, ll n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T min(vector<T> &a, ll s, ll n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a) { return *max_element(all(a)); }
template <class T, class U> T max(vector<T> &a, vector<U> &b) {
return max(*max_element(all(a)), *max_element(all(b)));
}
template <class T> T maxi(vector<T> &a) {
return max_element(all(a)) - a.begin();
}
template <class T> T max(vector<T> &a, ll n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> T max(vector<T> &a, ll s, ll n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> T sum(vector<T> &v, ll s, ll t) {
T ret = 0;
rep(i, s, min(sz(v), t)) ret += v[i];
return ret;
}
template <class T> T sum(vector<T> &v, ll t = inf) { return sum(v, 0, t); }
template <class T> T sum(vector<vector<T>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<T>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<vector<T>>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> T sum(vector<vector<vector<vector<vector<T>>>>> &v) {
T ret = 0;
rep(i, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T> auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
template <class T> auto sum(priority_queue<T> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
// template<class T, class U, class... W> auto sumn(vector<T> &v, U head, W...
// tail) { auto ret = sum(v[0], tail...); rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...); return ret;}
vi v_i(vi &a) {
int n = max(a) + 1;
vi ret(n, -1);
rep(i, sz(a)) { ret[a[i]] = i; }
return ret;
}
void clear(PQ &q) { q = PQ(); }
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> T *negarr(ll size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> T *negarr2(ll h, ll w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (ll i = 1; i <= 2 * h + 1; ++i) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret)) ret[i] = a[i] == k;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
template <class T> vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
return rui[r] - rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
T operator()(ll l, ll r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
T operator[](ll i) { return rrui[i]; }
};
template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
fora(v, a.rui) os << v << " ";
return os;
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
vector<ll> ruiv(string &a) {
if (sz(a) == 0)
return vi(1);
ll dec = ('0' <= a[0] && a[0] <= '9') ? '0' : 0;
vector<ll> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i] - dec;
return ret;
}
ruiC<ll> ruic(string &a) {
vector<ll> ret = ruiv(a);
return ruiC<ll>(ret);
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<ll>(ret);
}
// xor
template <class T> struct ruixC {
const vector<T> rui;
ruixC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruiXc ";
deb(l, r);
assert(0);
}
return rui[r] ^ rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
vi ret = ruix(a);
return ruixC<ll>(ret);
}
template <class T> vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
ll n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void dec(vector<T> &a, vector<U> &b) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
for (auto &u : c)
dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool ins(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
return ins(0, i, sz(a)) && ins(0, j, sz(a));
}
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
// 添え字を返す
template <class F> ll goldd_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class F> ll goldt_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> dou goldd_d(dou left, dou right, F calc, ll loop = 200) {
dou GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
ll k = 141;
loop++;
while (--loop) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return left;
}
template <class F> dou goldt_d(dou left, dou right, F calc, ll loop = 200) {
double GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm);
loop++;
while (--loop) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return left;
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> ll goldd_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll mini = 0, minv = MAX(ll); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldd_l(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return mini;
}
template <class F> ll goldt_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll maxi = 0, maxv = MIN(ll); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldt_l(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return maxi;
}
template <class F>
dou goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
auto lim = milliseconds(time - 20);
dou mini = 0, minv = MAX(dou); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldd_d(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return mini;
}
template <class F>
dou goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
auto lim = milliseconds(time - 20);
dou maxi = 0, maxv = MIN(dou); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldt_d(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return maxi;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
ll bget(ll m, ll keta, ll sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
ll bit(vi &a) {
int m = 0;
for (auto &&v : a)
m |= bit(v);
return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) { return n & -n; }
ll lbiti(ll n) { return log2(n & -n); }
// 最上位ビット
ll hbit(ll n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
ll hbiti(ll n) { return log2(hbit(n)); }
ll hbitk(ll n) {
ll k = 0;
rer(i, 5) {
ll a = k + (1ll << i);
ll b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; /*最下位の1*/
ll y = mask + x; /*連続した下の1を繰り上がらせる*/
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
vi res;
ll m = 0;
while (nextComb(m, n, r)) {
res.push_back(m);
}
return res;
}
// masの立ってるindexを見る
#define forbit(i, mas) \
for (int forbitj = lbit(mas), forbitm = mas, i = log2(forbitj); forbitm; \
forbitm = forbitj ? forbitm ^ forbitj : 0, forbitj = lbit(forbitm), \
i = log2(forbitj))
char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
ll res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(ll i) {
vi res;
while (i) {
res.push_back(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
ll n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
ll n = sz(a);
vi ret(n);
rep(i, n) ret[i] = a[i] == one;
return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
ll n = sz(s), m = sz(s[0]);
vector<vector<ll>> res(n, vector<ll>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, umap<ll, ll> &map) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
ll v = a[i];
a[i] = lower_bound(all(b), a[i]) - b.begin();
map[v] = a[i];
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
ll len = a.size();
fora(v, a) b.push_back(v);
fora(v, r) b.push_back(v);
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
ll len = a.size();
fora(v, a) b.push_back(v);
fora(v, r) b.push_back(v);
fora(v, s) b.push_back(v);
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
for (ll i = 0; i < sz(s); ++i)
r[i] = lower_bound(all(b), s[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vi> &a) {
vi b;
fora(vv, a) fora(v, vv) b.push_back(v);
sort(b);
unique(b);
fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) fora(vv, vvv) fora(v, vv) b.push_back(v);
sort(b);
unique(b);
fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(ll a[], ll len) {
vi b;
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define rlowerIndex(a, v) (upper_bound(all(a), v) - a.begin() - 1)
#define rlowerBound(a, v) *(--(upper_bound(all(a), v)))
#define rupperIndex(a, v) (lower_bound(all(a), v) - a.begin() - 1)
#define rupperBound(a, v) *(--(lower_bound(all(a), v)))
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))
// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX(T));
rep(i, n) {
int id = lowerIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX(T));
}
template <class T> int lis_eq(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX(T));
rep(i, n) {
int id = upperIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX(T));
}
// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
auto ret = m.lower_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
auto ret = m.upper_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
auto ret = upper_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
auto ret = lower_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T> void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
ll mod(ll a, ll m) { return (a % m + m) % m; }
ll pow(ll a) { return a * a; };
ll fact(ll v) { return v <= 1 ? 1 : v * fact(v - 1); }
dou factd(int v) {
static vd fact(2, 1);
if (sz(fact) <= v) {
rep(i, sz(fact), v + 1) { fact.push_back(fact.back() * i); }
}
return fact[v];
}
ll comi(ll n, ll r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd2(ll n, ll r) {
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
double comd(int n, int r) {
if (r < 0 || r > n)
return 0;
if (n < 2020)
return comd2(n, r);
static vd fact(2, 1);
if (sz(fact) <= n) {
rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
}
return fact[n] / fact[n - r] / fact[r];
}
ll gcd(ll a, ll b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
ll gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
ll res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
ll lower_remi__bx_a(ll kei, ll rem, ll x) {
if (rem >= x)
return 0;
return (x - rem + kei - 1) / kei;
}
ll lower_remv__bx_a(ll kei, ll rem, ll x) {
if (rem >= x)
return rem;
return (x - rem + kei - 1) / kei * kei + rem;
}
ll upper_remi__bx_a(ll kei, ll rem, ll x) {
if (rem > x)
return 0;
return (x - rem + kei) / kei;
}
ll upper_remv__bx_a(ll kei, ll rem, ll x) {
if (rem > x)
return rem;
return (x - rem + kei) / kei * kei + rem;
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
++res;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return ((1 + t) * t) >> 1; }
ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
// 機能拡張
template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
a.fi += b.fi;
a.se += b.se;
}
template <class T, class U> pair<T, U> operator+(pair<T, U> &a, pair<T, U> &b) {
return pair<T, U>(a.fi + b.fi, a.se + b.se);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
basic_string<CharT, Traits, Alloc> str(lhs);
str.append(to_string(rv));
return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
basic_string<CharT, Traits, Alloc> str(lhs);
str.append(to_string(rv));
return str;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
lhs += to_string(rv);
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
auto bek = s;
s = "";
for (; num; num >>= 1) {
if (num & 1) {
s += bek;
}
bek += bek;
}
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
fora(d, v) a.push(d);
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
fora(d, v) a.insert(d);
return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.push_back(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
a.push_back(b[i]);
}
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
exit(0);
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <class T, class U> void operator*=(vector<T> &a, U b) {
vector<T> ta = a;
rep(b - 1) { a += ta; }
}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
ll l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
vector<string> res;
ll kn = sz(deli);
std::string::size_type Pos(a.find(deli));
ll l = 0;
while (Pos != std::string::npos) {
if (Pos - l)
res.push_back(a.substr(l, Pos - l));
l = Pos + kn;
Pos = a.find(deli, Pos + kn);
}
if (sz(a) - l)
res.push_back(a.substr(l, sz(a) - l));
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
template <typename T> class fixed_point : T {
public:
explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
template <typename... Args>
constexpr decltype(auto) operator()(Args &&...args) const {
return T::operator()(*this, std::forward<Args>(args)...);
}
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
return fixed_point<T>{std::forward<T>(t)};
}
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv; //@formatter:on
// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
// 右、上が正
constexpr ll y4[] = {1, -1, 0, 0};
constexpr ll x4[] = {0, 0, -1, 1};
constexpr ll y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// ll k, K, d, x, y, z, q, Q,cou;vvi (s, 0, 0);
// ll n, m, k, H, W;
// vi a, b;
// vvc (ba, 0, 0);
ll n, H, W;
vi A, B, C;
/*@formatter:off*/
#define forg(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c; \
gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
#define fort(gi, ve) \
for (ll gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
++gi) \
if (t != p)
#define fore(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c, ty, id; \
gi < forglim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, \
id = ve[gi].id, ty = ve[gi].ty, true); \
++gi)
// typeが追加される
#define forg2(gi, ve) \
for (ll gi = 0, forglim = ve.size(), f, t, c, ty; \
gi < forglim && \
(f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, true); \
++gi)
#define fort2(gi, ve) \
for (ll gi = 0, f, t, c, ty; \
gi < ve.size() && \
(f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, true); \
++gi) \
if (t != p)
template <class T> struct edge {
int f, t;
T c;
int id;
int ty;
edge(int f, int t, T c = 1, int ty = -1, int id = -1)
: f(f), t(t), c(c), id(id), ty(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> usedv;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), usedv.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
usedv.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int ty, int id) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::usedv;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, ty, id);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, ty, id);
edges.emplace_back(f, t, c, ty, id);
}
void ing(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t;
cin >> f >> t;
f -= minus;
t -= minus;
add(f, t);
}
}
void ingc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c;
cin >> f >> t >> c;
f -= minus;
t -= minus;
add(f, t, c);
}
}
void ingct(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> c >> ty;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
void ingtc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> ty >> c;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
bool used(edge<T> &e) { return usedv[e.id]; }
bool used(int id) { return usedv[id]; }
void del(edge<T> &e) { usedv[e.id] = 1; }
void del(int id) { usedv[id] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.push_back(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::usedv;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
// f < t
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, ty, id);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, ty, id);
g[t].emplace_back(t, f, c, ty, id);
edges.emplace_back(f, t, c, ty, id); //
edges.emplace_back(t, f, c, ty, id);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.ty;
T c = e.c;
add(f, t, c, ty);
}
void ing(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t;
cin >> f >> t;
f -= minus;
t -= minus;
add(f, t);
}
}
void ingc(int m, int minus = 1) {
rep(i, m) {
int f, t, c;
cin >> f >> t >> c;
f -= minus;
t -= minus;
add(f, t, c);
}
}
void ingct(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> c >> ty;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
void ingtc(int n, int m, int minus = 1) {
this->resize(n);
rep(i, m) {
int f, t, c, ty;
cin >> f >> t >> ty >> c;
f -= minus;
t -= minus;
ty -= minus;
add(f, t, c, ty);
}
}
bool used(edge<T> &e) { return usedv[e.id]; }
bool used(int id) { return usedv[id]; }
void del(edge<T> &e) { usedv[e.id] = 1; }
void del(int id) { usedv[id] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.push_back(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
/*radiq_heap*/
vi dijkstra2(const graph<int> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return dis;
}
template <class T>
vector<vector<T>> dijkstra_all(const graph<T> &g, int init_value = -1) {
vector<vector<T>> dis(g.n);
rep(i, g.n) { dis[i] = dijkstra(g, i, init_value); }
return dis;
}
// ret vector(dis,count); 最短経路とその通りを数える
template <class T>
auto dijkstra_cou(const graph<T> &g, int s, int init_value = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
vi cou(g.n);
cou[0] = 1;
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
cou[to] = cou[e.f];
q.emplace(dis[to], to);
} else if (dis[to] == c) {
cou[to] += cou[e.f];
}
}
} /*基本、たどり着かないなら-1*/
for (auto &&d : dis)
if (d == initValue)
d = init_value;
return vtop(dis, cou);
}
// コストを無限に減らせる := -linf
// たどり着けない := linf
template <class T> vector<T> bell(graph<T> &g, int s) {
if (g.n >= 1e4) {
cout << "bell size too big" << endl;
exit(0);
}
vector<T> res(g.n, linf);
res[s] = 0;
vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく */
fix([&](auto ds, int p, int i) -> void {
if (can[i])
return;
can[i] = true;
forg(gi, g[i]) if (t != p) ds(i, t);
})(-1, 0);
vector<edge<T>> es;
fora(e, g.edges) {
if (can[e.f])
es += e;
}
rep(i, g.n) {
bool upd = false;
fora(e, es) {
if (res[e.f] != linf && res[e.t] > res[e.f] + e.c) {
upd = true;
res[e.t] = res[e.f] + e.c;
}
}
if (!upd)
break;
}
rep(i, g.n * 2) {
bool upd = 0;
fora(e, g.edges) {
if (res[e.f] != linf && res[e.t] != -linf && res[e.t] > res[e.f] + e.c) {
upd = 1;
res[e.t] = -linf;
}
}
if (!upd)
break;
}
return res;
}
// コストを無限に増やせる := linf
// たどり着けない := -linf
template <class T> vector<T> bell_far(graph<T> &g, int s) {
if (g.n >= 1e4) {
cout << "bell_far size too big" << endl;
exit(0);
}
vector<T> res(g.n, linf);
res[s] = 0;
vb can(g.n); /*頂点から行けない頂点を持つ、辺を消しておく*/
fix([&](auto ds, int p, int i) -> void {
if (can[i])
return;
can[i] = true;
forg(gi, g[i]) if (t != p) ds(i, t);
})(-1, 0);
vector<edge<T>> es;
fora(e, g.edges) {
if (can[e.f])
es += e;
}
rep(i, g.n) {
bool upd = false;
fora(e, es) {
if (res[e.f] != linf && res[e.t] > res[e.f] - e.c) { /*-c*/
upd = true;
res[e.t] = res[e.f] - e.c; /*-c*/
}
}
if (!upd)
break;
}
rep(i, g.n * 2) {
bool upd = 0;
fora(e, g.edges) {
if (res[e.f] != linf && res[e.t] != -linf &&
res[e.t] > res[e.f] - e.c) { /*-c*/
upd = 1;
res[e.t] = -linf;
}
}
if (!upd)
break;
}
rep(i, g.n) res[i] *= -1;
return res;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int init_value = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n)
chmi(dis[i][j], dis[i][k] + dis[k][j]); /*基本、たどり着かないなら-1*/
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = init_value;
return dis;
}
template <class T> class MinOp {
public:
T operator()(T a, T b) { return min(a, b); }
};
template <typename OpFunc> struct SparseTable {
OpFunc op;
signed size;
vector<signed> lg;
vector<vector<pair<signed, signed>>> table;
void init(const vector<pair<signed, signed>> &array, OpFunc opfunc) {
signed n = array.size();
op = opfunc;
lg.assign(n + 1, 0);
for (signed i = 1; i <= n; i++) {
lg[i] = 31 - __builtin_clz(i);
}
table.assign(lg[n] + 1, array);
for (signed i = 1; i <= lg[n]; i++) {
for (signed j = 0; j < n; j++) {
if (j + (1 << (i - 1)) < n) {
table[i][j] = op(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
} else {
table[i][j] = table[i - 1][j];
}
}
}
}
pair<signed, signed> query(signed l, signed r) {
assert(l < r);
return op(table[lg[r - l]][l], table[lg[r - l]][r - (1 << lg[r - l])]);
}
};
struct PMORMQ {
vector<signed> a;
SparseTable<MinOp<pair<signed, signed>>> sparse_table;
vector<vector<vector<signed>>> lookup_table;
vector<signed> block_type;
signed block_size, n_block;
void init(const vector<signed> &array) {
a = array;
signed n = a.size();
block_size = std::max(1, (31 - __builtin_clz(n)) / 2);
while (n % block_size != 0) {
a.push_back(a.back() + 1);
n++;
}
n_block = n / block_size;
vector<pair<signed, signed>> b(n_block, make_pair(INT_MAX, INT_MAX));
for (signed i = 0; i < n; i++) {
b[i / block_size] = min(b[i / block_size], make_pair(a[i], i));
}
sparse_table.init(b, MinOp<pair<signed, signed>>());
block_type.assign(n_block, 0);
for (signed i = 0; i < n_block; i++) {
signed cur = 0;
for (signed j = 0; j < block_size - 1; j++) {
signed ind = i * block_size + j;
if (a[ind] < a[ind + 1]) {
cur |= 1 << j;
}
}
block_type[i] = cur;
}
lookup_table.assign(
1 << (block_size - 1),
vector<vector<signed>>(block_size, vector<signed>(block_size + 1)));
for (signed i = 0; i < (1 << (block_size - 1)); i++) {
for (signed j = 0; j < block_size; j++) {
signed res = 0;
signed cur = 0;
signed pos = j;
for (signed k = j + 1; k <= block_size; k++) {
lookup_table[i][j][k] = pos;
if (i & (1 << (k - 1))) {
cur++;
} else {
cur--;
}
if (res > cur) {
pos = k;
res = cur;
}
}
}
}
}
signed query(signed l, signed r) {
assert(l < r);
signed lb = l / block_size;
signed rb = r / block_size;
if (lb == rb) {
return lb * block_size +
lookup_table[block_type[lb]][l % block_size][r % block_size];
}
signed pl = lb * block_size +
lookup_table[block_type[lb]][l % block_size][block_size];
signed pr =
rb * block_size + lookup_table[block_type[rb]][0][r % block_size];
signed pos = pl;
if (r % block_size > 0 && a[pl] > a[pr]) {
pos = pr;
}
if (lb + 1 == rb) {
return pos;
}
signed spv = sparse_table.query(lb + 1, rb).second;
if (a[pos] > a[spv]) {
return spv;
}
return pos;
}
};
/*@formatter:on*/
template <class T = int> class tree : public undigraph<T> {
PMORMQ rmq;
int cnt;
vector<signed> id, in;
bool never = true;
bool never_hld = true;
void dfs(int x, int p, int d, int dis = 0) {
id[cnt] = x;
par[x] = p;
dep.push_back(d);
disv[x] = dis;
in[x] = cnt++;
forg(gi, g[x]) {
if (t == p) {
continue;
}
dfs(t, x, d + 1, dis + c);
id[cnt] = x;
dep.push_back(d);
cnt++;
}
}
void precalc() {
never = false;
cnt = 0;
dep.clear();
disv.assign(n, 0);
in.assign(n, -1);
id.assign(2 * n - 1, -1);
par.assign(n, -1);
dfs(root, -1, 0);
rmq.init(dep);
#ifdef _DEBUG
cerr << "---tree---" << endl;
rep(i, n) {
if (!(i == root || sz(g[i]) > 1))
continue;
cerr << i << " -> ";
vi ts;
forg(gi, g[i]) {
if (t != par[i])
ts.push_back(t);
}
rep(i, sz(ts) - 1) cerr << ts[i] << ", ";
cerr << ts.back() << endl;
}
cerr << endl;
#endif
}
int pos;
void hld_build() {
never_hld = false;
if (never)
precalc();
pos = 0;
vid.assign(n, -1);
head.assign(n, 0);
sub.assign(n, 1);
hvy.assign(n, -1);
hdep.assign(n, 0);
inv.assign(n, 0);
type.assign(n, 0);
build();
#ifdef _DEBUG
cerr << "---hld_index---" << endl;
vi inds;
rep(i, n) if (sz(g[i])) inds.push_back(i);
rep(i, sz(inds)) {
str s = tos(bel(inds[i]));
cerr << std::right << std::setw(sz(s) + (i ? 1 : 0)) << inds[i];
}
cerr << endl;
rep(i, sz(inds)) { cerr << bel(inds[i]) << " "; }
cerr << endl << endl;
cerr << "---hld_edge_index---" << endl;
fora(e, edges) {
if (e.f <= e.t)
cerr << e.f << "-" << e.t << " " << bel(e) << endl;
}
cerr << endl << endl;
#endif
}
void build(vector<int> rs = vector<int>(1, 0)) {
int c = 0;
for (int r : rs) {
dfs(r);
bfs(r, c++);
}
}
void dfs(int rt) {
stack<P> st;
hdep[rt] = 0;
st.emplace(rt, 0);
while (!st.empty()) {
int v = st.top().first;
int &i = st.top().second;
if (i < (int)g[v].size()) {
int u = g[v][i++].t;
if (u == par[v])
continue;
hdep[u] = hdep[v] + 1;
st.emplace(u, 0);
} else {
st.pop();
int res = 0;
forg(gi, g[v]) {
int u = t;
if (u == par[v])
continue;
sub[v] += sub[u];
if (res < sub[u])
res = sub[u], hvy[v] = u;
}
}
}
}
void bfs(int r, int c) {
int &k = pos;
queue<int> q({r});
while (!q.empty()) {
int h = q.front();
q.pop();
for (int i = h; i != -1; i = hvy[i]) {
type[i] = c;
vid[i] = k++;
inv[vid[i]] = i;
head[i] = h;
forg(gi, g[i]) if (t != par[i] && t != hvy[i]) q.push(t);
}
}
}
vi vid;
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::usedv;
vector<int> disv;
vector<signed> dep, par;
vector<int> head, sub, hvy, inv, type,
hdep /*おそらくグループ内のdep*/; /*vid := bel()*/
int root;
tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
int lca(int a, int b) {
if (never)
precalc();
int x = in[a];
int y = in[b];
if (x > y) {
swap(x, y);
}
int pos = rmq.query(x, y + 1);
return id[pos];
}
int dis(int a, int b) {
if (never)
precalc();
int x = in[a];
int y = in[b];
if (x > y) {
swap(x, y);
}
int pos = rmq.query(x, y + 1);
int p = id[pos];
return disv[a] + disv[b] - disv[p] * 2;
}
/*O(N) hldを使わず木を普通にたどる*/
void for_each_l(int u, int v, function<void(int)> fnode) {
int r = lca(u, v);
while (u != r) {
fnode(u);
u = par[u];
}
while (v != r) {
fnode(v);
v = par[v];
}
fnode(r);
}
void for_each_edge_l /*O(N) 頂点に対しての処理順が可換*/ (
int u, int v, function<void(edge<int> &)> fedge) {
int r = lca(u, v);
auto sub = [&](int u, int r) {
while (u != r) {
forg(gi, g[u]) {
if (t == par[u]) {
fedge(g[u][gi]);
u = par[u];
break;
}
}
}
};
sub(u, r);
sub(v, r);
}
/*Fは半開 (u,v)は木の頂点* /
/*中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう*/
void for_each_(int u, int v, const function<void(int, int)> &f) {
if (never_hld)
hld_build();
while (1) {
if (vid[u] > vid[v])
swap(u, v);
int l = max(vid[head[v]], vid[u]);
int r = vid[v] + 1;
f(l, r);
if (head[u] != head[v])
v = par[head[v]];
else
break;
}
}
void for_each_edge /*[l,r) O(log(N)) 辺を頂点として扱っている
上と同じ感じで使える*/
(int u, int v, const function<void(int, int)> &f) {
if (never_hld)
hld_build();
while (1) {
if (vid[u] > vid[v])
swap(u, v);
if (head[u] != head[v]) {
int l = vid[head[v]];
int r = vid[v] + 1;
f(l, r);
v = par[head[v]];
} else {
if (u != v) {
int l = vid[u] + 1;
int r = vid[v] + 1;
f(l, r);
}
break;
}
}
}
int bel(int v) { /*hld内での頂点番号を返す*/
if (never_hld)
hld_build();
return vid[v];
}
int bel(
int f,
int t) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
if (never_hld)
hld_build();
return hdep[f] > hdep[t] ? vid[f] : vid[t];
}
int bel(
edge<T> &
e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/
if (never_hld)
hld_build();
return hdep[e.f] > hdep[e.t] ? vid[e.f] : vid[e.t];
}
template <class... U> int operator()(U... args) { return bel(args...); }
};
;
/*@formatter:off*/
// 辺によりメモリを大量消費ためedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::usedv;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, ty, id);
ole();
}
g[f].emplace_back(f, t, c, ty, eid++);
g[t].emplace_back(t, f, c, ty, eid++);
}
int getid(int h, int w) {
if (!ins(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(vector<vector<char>> ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() {
rep(i, n) fora(e, g[i]) if (e.f < e.t) edges.push_back(e);
}
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::usedv;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int ty = -1, int id = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, ty, id);
ole();
}
g[f].emplace_back(f, t, c, ty, eid++);
}
int getid(int h, int w) {
if (!ins(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(vector<vector<char>> ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.push_back(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
unionfind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int n = g.size();
vb was(n);
queue<P> q;
rep(i, n) {
if (was[i])
continue;
q.push(mp(i, 1));
was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (was[t])
continue;
q.push(mp(t, col ^ 1));
was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, digraph<T> &g) {
os << endl << g.n << " " << sz(g.edges) << endl;
fore(gi, g.edges) { os << f << " " << t << " " << c << endl; }
return os;
}
template <class T> ostream &operator<<(ostream &os, undigraph<T> &g) {
os << endl << g.n << " " << sz(g.edges) << endl;
fore(gi, g.edges) {
if (f < t)
os << f << " " << t << " " << c << endl;
}
return os;
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.push_back(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++; /*小さい順*/
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.push_back(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
// 閉路がある時linfを返す
template <class T> int longest_path(digraph<T> &g) {
vi top;
if (!topo(top, g)) {
return linf;
}
int n = sz(top);
vi dp(n, 0);
for (auto &&i : top) {
forg(gi, g[i]) { chma(dp[t], dp[i] + 1); }
}
return max(dp);
}
template <class T> vi longest_path_v(digraph<T> &g) {
vi top;
if (!topo(top, g)) {
return vi();
}
int n = sz(top);
vi dp(n, 0);
vi pre(n, -1);
for (auto &&i : top) {
forg(gi, g[i]) {
if (chma(dp[t], dp[i] + 1)) {
pre[t] = i;
}
}
}
int s = std::max_element(dp.begin(), dp.end()) - dp.begin();
vi path;
while (s != -1) {
path.push_back(s);
s = pre[s];
}
std::reverse(path.begin(), path.end());
return path;
}
// 連結グラフが与えられる 閉路があるか
template <class T> bool close(undigraph<T> &g) {
int n = 0;
int e = 0;
rep(i, g.n) {
if (sz(g[i]))
n++;
forg(gi, g[i]) { e++; }
}
return (e >> 1) >= n;
}
template <class T> bool close(undigraph<T> &g, int v) {
unionfind uf(g.n);
rep(i, g.n) {
forg(gi, g[i]) {
if (f < t)
break;
if (f == t && f == v)
return true;
if (uf.same(f, v) && uf.same(t, v))
return true;
uf.unite(f, t);
}
}
return false;
}
template <class T> bool close(digraph<T> &g) {
vi res;
return topo(res, g);
}
template <class T> vi indegree(graph<T> &g) {
vi ret(g.size());
rep(i, g.size()) {
forg(gi, g[i]) { ret[t]++; }
}
return ret;
}
template <class T> vi outdegree(graph<T> &g) {
vi ret(g.size());
rep(i, g.size()) { ret[i] = g[i].size(); }
return ret;
}
template <class T> digraph<T> rev(digraph<T> &g) {
digraph<T> r(g.n);
rep(i, g.n) {
forg(gi, g[i]) { r.add(t, f, c); }
}
return r;
}
// 橋を列挙する (取り除くと連結でなくなる辺)
template <class T> vp bridge(graph<T> &G) {
static bool was;
vp brid;
vi articulation;
vi ord(G.n), low(G.n);
vb vis(G.n);
function<void(int, int, int)> dfs = [&](int v, int p, int k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++) {
if (!vis[G[v][i].t]) {
ct++;
dfs(G[v][i].t, v, k);
low[v] = min(low[v], low[G[v][i].t]);
if (~p && ord[v] <= low[G[v][i].t])
isArticulation = true;
if (ord[v] < low[G[v][i].t])
brid.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
} else if (G[v][i].t != p) {
low[v] = min(low[v], ord[G[v][i].t]);
}
}
if (p == -1 && ct > 1)
isArticulation = true;
if (isArticulation)
articulation.push_back(v);
};
int k = 0;
rep(i, n) {
if (!vis[i])
dfs(i, -1, k);
}
sort(brid.begin(), brid.end());
return brid;
}
// 間接点を列挙する (取り除くと連結でなくなる点)
template <class T> vi articulation(undigraph<T> &G) {
static bool was;
vp bridge;
vi arti;
vi ord(G.n), low(G.n);
vb vis(G.n);
function<void(int, int, int)> dfs = [&](int v, int p, int k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++) {
if (!vis[G[v][i].t]) {
ct++;
dfs(G[v][i].t, v, k);
low[v] = min(low[v], low[G[v][i].t]);
if (~p && ord[v] <= low[G[v][i].t])
isArticulation = true;
if (ord[v] < low[G[v][i].t])
bridge.push_back(make_pair(min(v, G[v][i].t), max(v, G[v][i].t)));
} else if (G[v][i].t != p) {
low[v] = min(low[v], ord[G[v][i].t]);
}
}
if (p == -1 && ct > 1)
isArticulation = true;
if (isArticulation)
arti.push_back(v);
};
int k = 0;
rep(i, n) {
if (!vis[i])
dfs(i, -1, k);
}
sort(arti.begin(), arti.end());
return arti;
}
#define kansetu articulation
P farthest(undigraph<> &E, int cur, int pre, int d, vi &D) {
D[cur] = d;
P r = {d, cur};
forg(gi, E[cur]) if (t != pre) {
P v = farthest(E, t, cur, d + 1, D);
r = max(r, v);
}
return r;
}
// dagでなければ-1を返す
int diameter(digraph<> &g) {
vi per;
if (!topo(per, g))
return -1;
int n = g.n;
vi dp(n, 1);
fora(v, per) {
forg(gi, g[v]) { chma(dp[t], dp[f] + 1); }
}
return max(dp);
}
vi diameter(undigraph<> &E) { /* diameter,center*/
vi D[3];
D[0].resize(E.size());
D[1].resize(E.size());
auto v1 = farthest(E, 0, 0, 0, D[0]);
auto v2 = farthest(E, v1.second, v1.second, 0, D[0]);
farthest(E, v2.second, v2.second, 0, D[1]);
int i;
rep(i, D[0].size()) D[2].push_back(max(D[0][i], D[1][i]));
return D[2];
}
// i d
vp diameter_p(undigraph<> &E) { /* diameter,center*/
vector<int> D[3];
D[0].resize(E.size());
D[1].resize(E.size());
auto v1 = farthest(E, 0, 0, 0, D[0]);
auto v2 = farthest(E, v1.second, v1.second, 0, D[0]);
farthest(E, v2.second, v2.second, 0, D[1]);
int i;
vp res(E.size());
rep(i, D[0].size()) {
if (D[0][i] > D[1][i])
res[i] = mp(D[0][i], v1.second);
else
res[i] = mp(D[1][i], v2.second);
}
return res;
}
digraph<> rang_di(int n, int m, bool zibun = 0, bool taju = 0) {
umapp was;
digraph<> g(n);
was[mp(-1, -2)] = 1;
while (m) {
int f = -1, t = -2;
while (f < 0 || (!taju && was[mp(f, t)])) {
f = rand(0, n - 1);
t = rand(0, n - 1);
if (!zibun && f == t)
f = -1;
}
g.add(f, t);
was[mp(f, t)] = 1;
m--;
}
return g;
}
digraph<> perfect_di(int n, bool zibun = 0) {
digraph<> g(n);
rep(i, n) {
rep(j, n) {
if (!zibun && i == j)
con;
g.add(i, j);
}
}
return g;
}
undigraph<> rang_un(int n, int m, bool zibun = 0, bool taju = 0) {
umapp was;
undigraph<> g(n);
was[mp(-1, -2)] = 1;
while (m) {
int f = -1, t = -2;
while (f < 0 || (!taju && was[mp(min(f, t), max(f, t))])) {
f = rand(0, n - 1);
t = rand(0, n - 1);
if (!zibun && f == t)
f = -1;
}
g.add(f, t);
was[mp(min(f, t), max(f, t))] = 1;
m--;
}
return g;
}
undigraph<> perfect_un(int n, bool zibun = 0) {
undigraph<> g(n);
rep(i, n) {
rep(j, i, n) {
if (!zibun && i == j)
con;
g.add(i, j);
}
}
return g;
}
/*閉路が1つしかない場合、その閉路に含まれる頂点を1としたvectorを返す*/;
template <class T> vi get_close1(digraph<T> &g) {
int n = g.n;
queue<int> q;
vi d = outdegree(g);
vi res(n, 1);
rep(i, n) {
if (d[i] == 0) {
q += i;
res[i] = 0;
}
}
auto rg = rev(g);
while (q.size()) {
auto now = q.front();
q.pop();
forg(gi, rg[now]) {
if (--d[t] == 0) {
q += t;
res[t] = 0;
}
}
}
return res;
};
// 閉路パスを一つ返す
vi close_path(digraph<> &g) {
int n = g.n;
vi state(n);
vi path;
rep(i, n) if (!state[i]) {
if (fix([&](auto dfs, int v) -> bool {
if (state[v]) {
if (state[v] == 1) {
path.erase(path.begin(), find(path.begin(), path.end(), v));
return true;
}
return false;
}
path.push_back(v);
state[v] = 1;
forg(gi, g[v]) {
if (dfs(t))
return true;
}
state[v] = -1;
path.pop_back();
return false;
})(i)) {
return path;
}
}
return vi();
}
vi close_path_min(digraph<> &g) {
int n = g.n;
vvi(dis, n);
rep(i, n) dis[i] = dijkstra(g, i, linf);
int mind = linf;
int f = 0, t = 0;
rep(i, n) {
rep(j, n) {
if (i == j)
continue;
if (chmi(mind, dis[i][j] + dis[j][i])) {
f = i;
t = j;
}
}
}
vi path;
auto add = [&](int f, int t) {
int now = f;
while (now != t) {
rep(i, n) {
if (dis[now][i] == 1 && dis[f][i] + dis[i][t] == dis[f][t]) {
path.push_back(i);
now = i;
break;
}
}
}
};
add(f, t);
add(t, f);
return path;
}
template <class T> int krus(undigraph<T> &g) {
int res = 0;
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res += e.c;
}
}
return res;
}
// idは 00 11 22のようにedgesに持たれている
template <class T> vi krus_id(undigraph<T> &g) {
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
vi res;
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.push_back(e.id);
}
}
return res;
}
template <class T> vector<edge<T>> krus_ed(undigraph<T> &g) {
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
vector<edge<T>> res;
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.push_back(e);
}
}
return res;
}
template <class T> tree<T> krus_tr(undigraph<T> &g) {
tree<T> res(g.n);
unionfind uf(g.n);
if (sz(g.edges) == 0)
g.set_edges();
int i = 0;
auto E = g.edges;
sort(E);
fora(e, E) {
if (uf.unite(e.f, e.t)) {
res.add(e.f, e.t);
}
}
return res;
}
template <class T> vector<vector<edge<T>>> type_list(digraph<T> &g) {
vector<vector<edge<T>>> res;
rep(i, g.n) {
forg2(gi, g[i]) { res[ty].push_back(g[i][gi]); }
}
return res;
}
template <class T>
vector<vector<edge<T>>> type_list(undigraph<T> &g, int types = -1) {
int tn = types;
if (types == -1)
tn = g.n;
rep(i, g.n) {
forg2(gi, g[i]) { chma(tn, ty); }
}
vector<vector<edge<T>>> res(tn + 1);
vi was(g.n);
rep(i, g.n) {
forg2(gi, g[i]) {
if (f < t)
res[ty].push_back(g[i][gi]);
else if (f == t && !was[f]) {
res[ty].push_back(g[i][gi]);
was[f] = 1;
}
}
}
return res;
}
/*頂点数がkの木を一つ返す サイズが0の木が帰ったら終了*/
tree<int> next_tree(int k) {
assert(2 <= k && k < 11);
static str name;
static ifstream ina;
static int rem;
static vp edges;
static int pk = -1; /*前回見たk*/
if (pk != k) {
if (~pk)
ina.close();
edges.clear();
pk = k;
name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\trees_sizek\\nazeka6.txt"
: "C:\\Users\\kaout\\Desktop\\trees_sizek\\tree_size" +
tos(k) + ".txt";
ina = ifstream(name);
rem = pow(k, k - 2); /*Cayleyの定理*/
rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
pk = k;
}
tree<int> g(k);
if (rem == 0) {
g.resize(0);
return g;
}
int m;
ina >> m;
while (m) {
int lb = lbit(m);
int id = log2(lb);
g.add(edges[id].first, edges[id].second);
m ^= lb;
}
rem--;
return g;
}
undigraph<int> next_undi(int k) {
assert(2 <= k && k < 9);
static str name;
static ifstream ina;
static int rem;
static vp edges;
static vi lims = {-1, -1, 1, 4, 38, 728, 26704, 1866256};
static int pk = -1; /*前回見たk*/
if (pk != k) {
if (~pk)
ina.close();
edges.clear();
pk = k;
name = (k == 6) ? "C:\\Users\\kaout\\Desktop\\undi_sizek\\roku.txt"
: "C:\\Users\\kaout\\Desktop\\undi_sizek\\undi_size" +
tos(k) + ".txt";
ina = ifstream(name);
rem = lims[k];
rep(i, k) rep(j, i + 1, k) edges.emplace_back(i, j);
pk = k;
}
undigraph<int> g(k);
if (rem == 0) {
g.resize(0);
return g;
}
int m;
ina >> m;
while (m) {
int lb = lbit(m);
int id = log2(lb);
g.add(edges[id].first, edges[id].second);
m ^= lb;
}
rem--;
return g;
}
vector<tree<int>> trees(int k) {
vector<tree<int>> res;
while (1) {
tree<int> g = next_tree(k);
if (sz(g) == 0)
break;
res.push_back(g);
}
return res;
}
vector<undigraph<int>> undis(int k) {
vector<undigraph<int>> res;
while (1) {
undigraph<int> g = next_undi(k);
if (sz(g) == 0)
break;
res.push_back(g);
}
return res;
} /*@formatter:on*/
template <class M = int> struct segsum { /*@formatter:off*/
int n;
vector<M> seg;
M f(M a, M b) { return a + b; }
const M e = (M)0;
segsum(vector<M> &dat) {
n = 1;
int asz = dat.size();
while (n <= asz)
n <<= 1;
seg.assign((n << 1) - 1, e);
rep(i, asz) seg[i + n - 1] = dat[i];
rer(i, n - 2) seg[i] = f(seg[(i << 1) | 1], seg[(i << 1) + 2]);
debu();
}
segsum(int len, M init_value) : e(init_value) {
n = 1;
int asz = len;
while (n <= asz)
n <<= 1;
seg.assign((n << 1) - 1, e);
rep(i, asz) seg[i + n - 1] = e;
rer(i, n - 2) seg[i] = f(seg[(i << 1) | 1], seg[(i << 1) + 2]);
debu();
}
void update(int k, M v) {
int tk = k;
seg[k + n - 1] = v;
k += n - 1;
while (k) {
k = (k - 1) >> 1;
seg[k] = f(seg[(k << 1) | 1], seg[(k << 1) + 2]);
}
debup(tk, v);
}
void del(int k) { update(k, e); }
void add(int k, int v) { update(k, v + seg[k + n - 1]); }
M query_bottomup(int l, int r) {
int tl = l, tr = r;
M retl = e;
M retr = e;
l += n - 1;
r += n - 1;
while (l < r) { /*右なら、次に右上へ移動してしまうので*/
if (!(l & 1)) {
retl = f(retl, seg[l]);
} /*右なら、左を取らないと機会を逃す*/
if (!(r & 1)) {
retr = f(seg[r - 1], retr);
}
l >>= 1;
r = (r - 1) >> 1;
}
M ret = f(retl, retr);
debge(tl, tr, ret);
return ret;
}
M query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
else if (a <= l && r <= b)
return seg[k];
else {
M sl = query(a, b, (k << 1) | 1, l, (l + r) >> 1);
M sr = query(a, b, (k << 1) + 2, (l + r) >> 1, r);
return f(sl, sr);
}
} /* M get(int a = 0, int b = -1) { return query(a, b == -1 ? n : b, 0, 0,
n); }*/
M get(int a, int b) { return query_bottomup(a, min(b, n)); }
M get(int b = inf) { return query_bottomup(0, min(b, n)); }
int operator()(int b = inf) { return get(0, b); }
int operator()(int a, int b) { return get(a, b); }
M operator[](int k) { return seg[k + n - 1]; }
#ifdef _DEBUG
void debu() {
rep(i, min(n, 10ll)) {
int v = operator[](i);
if (v == MIN(ll) || v == MAX(ll)) {
cerr << "e ";
} else {
cerr << v << " ";
}
}
cerr << "" << endl << endl;
}
void debup(int k, int v) {
cerr << "upd : [" << k << "] = " << v << endl;
debu();
}
void debge(int l, int r, M v) {
cerr << "get : [" << l << ", " << r << ") = " << v << endl;
debu();
}
#else
void debu() { ; }
void debup(int k, int v) { ; }
void debge(int l, int r, M v) { ; } /*@formatter:on*/
#endif
};
void solve() {
// int q;
// in(n, q);
// tree<> g(2 * k5);;
// g.ingtc(n, n - 1);
// dna4(C, L, U, V, q);
// dec(C), dec(U), dec(V);
// vvi(qci, k5);
// rep(i, q) {
// qci[C[i]] += i;
// }
// vi res(q);
// segsum<> co(k5, 0);
// segsum<> sm(k5, 0);
// auto E = type_list(g);
// rep(ci, sz(E)) {
// fora(e, E[ci]) {
// int p = g(e);
// co.upd(p, 1);
// sm.upd(p, e.c);
// }
//
// fora(i, qci[ci]) {
// int u = U[i], v = V[i];
// g.for_each_(u, v, [&](int l, int r) {
// res[i] -= sm(l, r);
// res[i] += co(l, r) * L[i];
// });
// }
//
// fora(e, E[ci]) {
// int p = g(e);
// co.upd(p, 0);
// sm.upd(p, 0);
// }
// }
// rep(i, q)res[i] += g.dis(U[i],V[i]);
// outl(res);
int q;
tree<> g(2);
in(n, q);
g.ingtc(n, n - 1);
dna4d(cs, ls, u, v, q);
inc(ls, 1);
vi res(q);
rep(i, q) { res[i] = g.dis(u[i], v[i]); }
auto es = type_list(g);
vvi(qs, k5);
rep(i, q) { qs[cs[i]] += i; }
deb(qs);
segsum<int> cou(k5, 0);
segsum<int> sum(k5, 0);
rep(ci, sz(es)) {
fora(e, es[ci]) {
int p = g.bel(e);
cou.add(p, 1);
sum.add(p, e.c);
}
fora(qi, qs[ci]) {
auto f = [&](int l, int r) {
res[qi] -= sum.get(l, r);
res[qi] += cou.get(l, r) * ls[qi];
};
g.for_each_edge(u[qi], v[qi], f);
}
fora(e, es[ci]) {
int p = g.bel(e);
cou.add(p, -1);
sum.add(p, -e.c);
}
}
outl(res);
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
ll n = rand(1, 8);
vi a = ranv(n, 1, 10);
auto myres = my(arg);
auto res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "AC : " << res << endl;
cerr << "MY : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| replace | 5,238 | 5,239 | 5,238 | 5,239 | -11 | |
p02986 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <complex>
#include <cstring>
#include <functional>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define X first
#define Y second
#define pb(x) push_back(x)
#define FOR(k, n) for (int k = 0; k < n; k++)
#define FORN(k, s, n) for (int k = s; k < n; k++)
#define debug(x) printf("%s = %d\n", #x, x)
#define debug2(x, y) printf("%s = %d, %s = %d\n", #x, x, #y, y)
#define debug3(x, y, z) \
printf("%s = %d, %s = %d, %s = %d\n", #x, x, #y, y, #z, z)
#define debug4(x, y, z, t) \
printf("%s = %d, %s = %d, %s = %d, %s = %d\n", #x, x, #y, y, #z, z, #t, t)
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
typedef complex<double> cd;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
// Solution
const int MAXN = 100005;
const int SQRT = 317;
struct Edge {
ll c;
ll d;
Edge() : Edge(0, 0) {}
Edge(ll c, ll d) : c{c}, d{d} {}
};
ll n, q, u, v, c, d, x, y, o_size, dtime, P[MAXN], S[MAXN], TIN[MAXN], D[MAXN],
TOUT[MAXN], DP[MAXN][20];
vector<unordered_map<ll, Edge>> G;
vector<pair<ll, ll>> depths;
pair<ll, ll> M[2 * SQRT][MAXN];
map<ll, ll> CM;
char O[20 * MAXN];
void compute_root_info(ll v) {
ll u = v;
CM[v] = sz(CM);
while (P[u] != -1) {
M[CM[v]][G[u][P[u]].c].X++;
M[CM[v]][G[u][P[u]].c].Y += G[u][P[u]].d;
D[CM[v]] += G[u][P[u]].d;
u = P[u];
}
}
pair<ll, pair<ll, ll>> get_root_info(ll v, ll c) {
ll tot = 0;
pair<ll, ll> p;
while (P[v] != -1) {
if (S[v] == 1) {
tot += D[CM[v]];
p.X += M[CM[v]][c].X;
p.Y += M[CM[v]][c].Y;
return {tot, p};
}
tot += G[v][P[v]].d;
if (G[v][P[v]].c == c) {
p.X++;
p.Y += G[v][P[v]].d;
}
v = P[v];
}
return {tot, p};
}
void dfs(ll v, ll p, ll depth) {
P[v] = p;
depths[v] = {depth, v};
TIN[v] = dtime++;
for (pair<ll, Edge> e : G[v]) {
if (e.X != p) {
dfs(e.X, v, depth + 1);
}
}
TOUT[v] = dtime++;
}
bool is_ancestor(ll u, ll v) {
return (TIN[u] <= TIN[v] && TOUT[v] <= TOUT[u]);
}
ll lca(ll u, ll v) {
if (is_ancestor(u, v)) {
return u;
} else if (is_ancestor(v, u)) {
return v;
} else {
for (int i = 19; i >= 0; i--) {
if (!is_ancestor(DP[u][i], v)) {
u = DP[u][i];
}
}
return DP[u][0];
}
}
void init_sparse_table() {
for (int i = 0; i < n; i++) {
DP[i][0] = P[i] == -1 ? i : P[i];
}
for (int i = 1; i < 20; i++) {
for (int k = 0; k < n; k++) {
DP[k][i] = DP[DP[k][i - 1]][i - 1];
}
}
}
int main() {
scanf("%lld%lld", &n, &q);
G.resize(n);
depths.resize(n);
for (int i = 0; i < n - 1; i++) {
scanf("%lld%lld%lld%lld", &u, &v, &c, &d);
G[u - 1][v - 1] = {c, d};
G[v - 1][u - 1] = {c, d};
}
dfs(0, -1, 0);
init_sparse_table();
sort(depths.begin(), depths.end(), greater<pair<ll, ll>>());
for (int i = 0; i < n; i++) {
v = depths[i].Y;
for (int k = 0; k < SQRT; k++) {
if (S[v] == 1) {
break;
} else if (k == SQRT - 1 || P[v] == -1) {
S[v] = 1;
compute_root_info(v);
break;
}
v = P[v];
}
}
while (q--) {
scanf("%lld%lld%lld%lld", &x, &y, &u, &v);
pair<ll, pair<ll, ll>> u_stats = get_root_info(u - 1, x);
pair<ll, pair<ll, ll>> v_stats = get_root_info(v - 1, x);
pair<ll, pair<ll, ll>> lca_stats = get_root_info(lca(u - 1, v - 1), x);
ll tot_dist = u_stats.X + v_stats.X - 2 * lca_stats.X;
ll edge_cnt = u_stats.Y.X + v_stats.Y.X - 2 * lca_stats.Y.X;
ll edge_weights = u_stats.Y.Y + v_stats.Y.Y - 2 * lca_stats.Y.Y;
o_size +=
sprintf(O + o_size, "%lld\n", tot_dist - edge_weights + y * edge_cnt);
}
printf("%s", O);
return 0;
} | #include <algorithm>
#include <assert.h>
#include <complex>
#include <cstring>
#include <functional>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define X first
#define Y second
#define pb(x) push_back(x)
#define FOR(k, n) for (int k = 0; k < n; k++)
#define FORN(k, s, n) for (int k = s; k < n; k++)
#define debug(x) printf("%s = %d\n", #x, x)
#define debug2(x, y) printf("%s = %d, %s = %d\n", #x, x, #y, y)
#define debug3(x, y, z) \
printf("%s = %d, %s = %d, %s = %d\n", #x, x, #y, y, #z, z)
#define debug4(x, y, z, t) \
printf("%s = %d, %s = %d, %s = %d, %s = %d\n", #x, x, #y, y, #z, z, #t, t)
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
typedef complex<double> cd;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
// Solution
const int MAXN = 100005;
const int SQRT = 317;
struct Edge {
ll c;
ll d;
Edge() : Edge(0, 0) {}
Edge(ll c, ll d) : c{c}, d{d} {}
};
ll n, q, u, v, c, d, x, y, o_size, dtime, P[MAXN], S[MAXN], TIN[MAXN], D[MAXN],
TOUT[MAXN], DP[MAXN][20];
vector<map<ll, Edge>> G;
vector<pair<ll, ll>> depths;
pair<ll, ll> M[2 * SQRT][MAXN];
map<ll, ll> CM;
char O[20 * MAXN];
void compute_root_info(ll v) {
ll u = v;
CM[v] = sz(CM);
while (P[u] != -1) {
M[CM[v]][G[u][P[u]].c].X++;
M[CM[v]][G[u][P[u]].c].Y += G[u][P[u]].d;
D[CM[v]] += G[u][P[u]].d;
u = P[u];
}
}
pair<ll, pair<ll, ll>> get_root_info(ll v, ll c) {
ll tot = 0;
pair<ll, ll> p;
while (P[v] != -1) {
if (S[v] == 1) {
tot += D[CM[v]];
p.X += M[CM[v]][c].X;
p.Y += M[CM[v]][c].Y;
return {tot, p};
}
tot += G[v][P[v]].d;
if (G[v][P[v]].c == c) {
p.X++;
p.Y += G[v][P[v]].d;
}
v = P[v];
}
return {tot, p};
}
void dfs(ll v, ll p, ll depth) {
P[v] = p;
depths[v] = {depth, v};
TIN[v] = dtime++;
for (pair<ll, Edge> e : G[v]) {
if (e.X != p) {
dfs(e.X, v, depth + 1);
}
}
TOUT[v] = dtime++;
}
bool is_ancestor(ll u, ll v) {
return (TIN[u] <= TIN[v] && TOUT[v] <= TOUT[u]);
}
ll lca(ll u, ll v) {
if (is_ancestor(u, v)) {
return u;
} else if (is_ancestor(v, u)) {
return v;
} else {
for (int i = 19; i >= 0; i--) {
if (!is_ancestor(DP[u][i], v)) {
u = DP[u][i];
}
}
return DP[u][0];
}
}
void init_sparse_table() {
for (int i = 0; i < n; i++) {
DP[i][0] = P[i] == -1 ? i : P[i];
}
for (int i = 1; i < 20; i++) {
for (int k = 0; k < n; k++) {
DP[k][i] = DP[DP[k][i - 1]][i - 1];
}
}
}
int main() {
scanf("%lld%lld", &n, &q);
G.resize(n);
depths.resize(n);
for (int i = 0; i < n - 1; i++) {
scanf("%lld%lld%lld%lld", &u, &v, &c, &d);
G[u - 1][v - 1] = {c, d};
G[v - 1][u - 1] = {c, d};
}
dfs(0, -1, 0);
init_sparse_table();
sort(depths.begin(), depths.end(), greater<pair<ll, ll>>());
for (int i = 0; i < n; i++) {
v = depths[i].Y;
for (int k = 0; k < SQRT; k++) {
if (S[v] == 1) {
break;
} else if (k == SQRT - 1 || P[v] == -1) {
S[v] = 1;
compute_root_info(v);
break;
}
v = P[v];
}
}
while (q--) {
scanf("%lld%lld%lld%lld", &x, &y, &u, &v);
pair<ll, pair<ll, ll>> u_stats = get_root_info(u - 1, x);
pair<ll, pair<ll, ll>> v_stats = get_root_info(v - 1, x);
pair<ll, pair<ll, ll>> lca_stats = get_root_info(lca(u - 1, v - 1), x);
ll tot_dist = u_stats.X + v_stats.X - 2 * lca_stats.X;
ll edge_cnt = u_stats.Y.X + v_stats.Y.X - 2 * lca_stats.Y.X;
ll edge_weights = u_stats.Y.Y + v_stats.Y.Y - 2 * lca_stats.Y.Y;
o_size +=
sprintf(O + o_size, "%lld\n", tot_dist - edge_weights + y * edge_cnt);
}
printf("%s", O);
return 0;
} | replace | 61 | 62 | 61 | 62 | TLE | |
p02987 | C++ | Runtime Error | // Keep Working hard
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.precision(10);
const int N = 1e5 + 5;
int a[N];
void solve() {
string s;
cin >> s;
map<int, int> mp;
for (int i = 0; i < 4; i++) {
mp[s[i] - 'A']++;
}
for (auto i : mp) {
if (i.second != 2) {
cout << "No";
exit(0);
}
}
cout << "Yes";
}
void fileIO() {
#ifndef ONLINE_JUDGE
freopen("int.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
}
int32_t main() {
IOS;
fileIO();
int t = 1;
while (t--) {
solve();
}
return 0;
}
| // Keep Working hard
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.precision(10);
const int N = 1e5 + 5;
int a[N];
void solve() {
string s;
cin >> s;
map<int, int> mp;
for (int i = 0; i < 4; i++) {
mp[s[i] - 'A']++;
}
for (auto i : mp) {
if (i.second != 2) {
cout << "No";
exit(0);
}
}
cout << "Yes";
}
void fileIO() {
#ifndef ONLINE_JUDGE
freopen("int.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
}
int32_t main() {
IOS;
// fileIO();
int t = 1;
while (t--) {
solve();
}
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) && s.at(2) == s.at(3) ||
s.at(1) == s.at(2) && s.at(0) == s.at(3) ||
s.at(1) == s.at(3) && s.at(2) == s.at(4)) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) && s.at(2) == s.at(3) && s.at(1) != s.at(2) ||
s.at(1) == s.at(2) && s.at(0) == s.at(3) && s.at(0) != s.at(1) ||
s.at(1) == s.at(3) && s.at(2) == s.at(0) && s.at(1) != s.at(2)) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
| replace | 6 | 9 | 6 | 9 | 0 | |
p02987 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int seged = 0;
string S = "ASSA";
cin >> S;
for (int i = 0; i < S.length() - 1; i++) {
for (int j = i + 1; S.length(); j++) {
if (S[i] == S[j]) {
seged += 1;
}
}
}
if (seged == 2) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int seged = 0;
string S = "ASSA";
cin >> S;
for (int i = 0; i < S.length() - 1; i++) {
for (int j = i + 1; j < S.length(); j++) {
if (S[i] == S[j]) {
seged += 1;
}
}
}
if (seged == 2) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| replace | 8 | 9 | 8 | 9 | TLE | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
char c[4];
strcpy(c, str.c_str());
sort(c, c + 4);
if (c[0] == c[1] && c[2] == c[3] && c[1] != c[2]) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
char c[10];
strcpy(c, str.c_str());
sort(c, c + 4);
if (c[0] == c[1] && c[2] == c[3] && c[1] != c[2]) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
vector<int> cnt(26);
int ans = 0;
rep(i, 4) {
int t;
t = s[i] - 'a';
if (cnt[t] == 1) {
ans++;
}
cnt[t]++;
}
if (ans == 2) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
string s;
cin >> s;
vector<int> cnt(26);
int ans = 0;
rep(i, 4) {
int t;
t = s[i] - 'A';
if (cnt[t] == 1) {
ans++;
}
cnt[t]++;
}
if (ans == 2) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int table[26];
char S[5];
int main() {
for (int i = 0; i < 26; i++) {
table[i] = 0;
}
scanf("%s", S);
for (int i = 0; S[i] != '\0'; i++) {
table[S[i] - 'a']++;
}
int num_2 = 0;
for (int i = 0; i < 26; i++) {
if (table[i] == 2) {
num_2++;
}
}
if (num_2 == 2) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
| #include <bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int table[26];
char S[5];
int main() {
for (int i = 0; i < 26; i++) {
table[i] = 0;
}
scanf("%s", S);
for (int i = 0; S[i] != '\0'; i++) {
table[S[i] - 'A']++;
}
int num_2 = 0;
for (int i = 0; i < 26; i++) {
if (table[i] == 2) {
num_2++;
}
}
if (num_2 == 2) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
| replace | 23 | 24 | 23 | 24 | -11 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
sort(S.begin(), S.end());
if (S.at(0) == S.at(1) && S.at(2) == S.at(3) && S.at(0) != S.at(2))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
sort(S.begin(), S.end());
if (S.at(0) == S.at(1) && S.at(2) == S.at(3) && S.at(0) != S.at(2))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | insert | 5 | 5 | 5 | 6 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 0) >= this->size() (which is 0)
|
p02987 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
string a[2] = {"", ""};
int count1 = 0;
int count2 = 0;
string S;
cin >> S;
for (int i = 1; i < 4; i++) {
if (S[0] == S[i]) {
count1++;
} else {
a[count2] = S[i];
count2++;
}
}
if (count1 == 1 and a[0] == a[1]) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string a[4];
int count1 = 0;
int count2 = 0;
string S;
cin >> S;
for (int i = 1; i < 4; i++) {
if (S[0] == S[i]) {
count1++;
} else {
a[count2] = S[i];
count2++;
}
}
if (count1 == 1 and a[0] == a[1]) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define sz(a) int((a).size())
#define pb push_back
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define rep(i, n) for (ll i = 0; i < n; i++)
// s.replace(s.find("10"), sizeof("10") - 1, "");
using namespace std;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
bool compare(const pair<int, int> &i, const pair<int, int> &j) {
return i.second < j.second;
}
int main() {
// added the two lines below
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
// freopen("error.txt","w",stderr);
#endif
string s;
cin >> s;
map<char, int> m;
int flag = 0;
for (int i = 0; i < s.size(); i++) {
m[s[i]]++;
}
for (auto i = m.begin(); i != m.end(); i++) {
if ((*i).second != 2) {
flag = 1;
break;
}
}
if (flag)
cout << "No";
else
cout << "Yes";
}
| #include <bits/stdc++.h>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define sz(a) int((a).size())
#define pb push_back
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define rep(i, n) for (ll i = 0; i < n; i++)
// s.replace(s.find("10"), sizeof("10") - 1, "");
using namespace std;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
bool compare(const pair<int, int> &i, const pair<int, int> &j) {
return i.second < j.second;
}
int main() {
// added the two lines below
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
map<char, int> m;
int flag = 0;
for (int i = 0; i < s.size(); i++) {
m[s[i]]++;
}
for (auto i = m.begin(); i != m.end(); i++) {
if ((*i).second != 2) {
flag = 1;
break;
}
}
if (flag)
cout << "No";
else
cout << "Yes";
}
| delete | 39 | 44 | 39 | 39 | 0 | |
p02987 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
char *s;
cin >> s;
int count = 0;
int elc = 0;
char tmp1, tmp2;
tmp1 = *s;
tmp2 = *s;
s++;
count++;
for (int i = 0; i < 3; i++) {
if (*s != tmp1 && elc == 0) {
tmp2 = *s;
elc = 1;
}
if (*s == tmp1)
count++;
if (*s != tmp1 && *s != tmp2)
elc = -1;
s++;
}
if (count == 2 && elc == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
char *s = (char *)malloc(sizeof(char) * 5);
s[4] = 0;
cin >> s;
int count = 0;
int elc = 0;
char tmp1, tmp2;
tmp1 = *s;
tmp2 = *s;
s++;
count++;
for (int i = 0; i < 3; i++) {
if (*s != tmp1 && elc == 0) {
tmp2 = *s;
elc = 1;
}
if (*s == tmp1)
count++;
if (*s != tmp1 && *s != tmp2)
elc = -1;
s++;
}
if (count == 2 && elc == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| replace | 3 | 4 | 3 | 5 | -11 | |
p02987 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int NextInt() {
int x;
cin >> x;
return x;
}
int main() {
vector<char> m;
for (int i = 0; i < 4; i++)
cin >> m[i];
sort(m.begin(), m.end());
if (m[0] == m[1] && m[1] != m[2] && m[2] == m[3])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using lli = long long int;
int inf = 1000000007;
using namespace std;
int NextInt() {
int x;
cin >> x;
return x;
}
int main() {
vector<char> m(4);
for (int i = 0; i < 4; i++)
cin >> m[i];
sort(m.begin(), m.end());
if (m[0] == m[1] && m[1] != m[2] && m[2] == m[3])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | replace | 21 | 22 | 21 | 22 | -11 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int ar[10000];
memset(ar, 0, sizeof(ar));
string s;
cin >> s;
for (int i = 0; i < 4; i++) {
ar[(int)(s.at(i) - 'A')]++;
}
for (int i = 0; i < 100; i++) {
if (ar[i] == 1 || ar[i] == 4) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
int ar[10000];
memset(ar, 0, sizeof(ar));
string s;
cin >> s;
for (int i = 0; i < 4; i++) {
ar[(int)(s.at(i) - 'A')]++;
}
for (int i = 0; i < 100; i++) {
if (ar[i] == 1 || ar[i] == 4) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | replace | 6 | 10 | 6 | 7 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 0) >= this->size() (which is 0)
|
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
string s;
cin >> s;
if (count(s.begin(), s.end(), s.at(0)) == 2 &&
count(s.begin(), s.end(), s.at(1)) == 2 &&
count(s.begin(), s.end(), s.at(2)) == 2 &&
count(s.begin(), s.end(), s.at(3)) == 2) {
cout << "Yes"
<< "\n";
return 0;
}
cout << "No"
<< "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
// #ifndef ONLINE_JUDGE
// // for getting input from input.txt
// freopen("input.txt", "r", stdin);
// // for writing output to output.txt
// freopen("output.txt", "w", stdout);
// #endif
string s;
cin >> s;
if (count(s.begin(), s.end(), s.at(0)) == 2 &&
count(s.begin(), s.end(), s.at(1)) == 2 &&
count(s.begin(), s.end(), s.at(2)) == 2 &&
count(s.begin(), s.end(), s.at(3)) == 2) {
cout << "Yes"
<< "\n";
return 0;
}
cout << "No"
<< "\n";
return 0;
} | replace | 3 | 9 | 3 | 9 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 0) >= this->size() (which is 0)
|
p02987 | C++ | Runtime Error | #include <stdio.h>
int main(void) {
char *S;
scanf("%s", S);
int cnt = 0;
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
if (S[j] == S[i]) {
cnt++;
}
}
if (cnt != 2) {
printf("No");
return 0;
}
cnt = 0;
}
printf("Yes");
return 0;
} | #include <stdio.h>
int main(void) {
char S[4];
scanf("%s", S);
int cnt = 0;
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 4; i++) {
if (S[j] == S[i]) {
cnt++;
}
}
if (cnt != 2) {
printf("No");
return 0;
}
cnt = 0;
}
printf("Yes");
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
using namespace std;
const int maxn = 1e5 + 10;
char s[5];
int cnt = 0, vis[26];
int main() {
scanf("%s", s);
for (int i = 0; i < 4; i++) {
if (vis[s[i] - 'A'] != 0)
continue;
vis[s[i] - 'a'] = 1;
cnt++;
}
if (cnt == 2)
return puts("Yes"), 0;
puts("No");
return 0;
} | #include <bits/stdc++.h>
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
using namespace std;
const int maxn = 1e5 + 10;
char s[5];
int cnt = 0, vis[26];
int main() {
scanf("%s", s);
for (int i = 0; i < 4; i++) {
if (vis[s[i] - 'A'] != 0)
continue;
vis[s[i] - 'A'] = 1;
cnt++;
}
if (cnt == 2)
return puts("Yes"), 0;
puts("No");
return 0;
} | replace | 15 | 16 | 15 | 16 | -11 | |
p02987 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define DEBUG 1
#define fi first
#define se second
#define pb push_back
#define fore(i, a, b) for (int i = (a), _b = (b); i < (_b); ++i)
#define fort(i, a, b) for (int i = (a), _b = (b); i <= (_b); ++i)
#define ford(i, a, b) for (int i = (a), _b = (b); i >= (_b); --i)
using namespace std;
typedef long long LL;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
const int INF = 1e9 + 3;
const int MOD = 1e9 + 7;
int main() {
#ifndef ONLINE_JUDGE
freopen("in", "r", stdin);
ios_base::sync_with_stdio(false);
cin.tie(0);
#endif
string s;
cin >> s;
sort(s.begin(), s.end());
cout << ((s[0] == s[1] && s[2] == s[3] && s[0] != s[3]) ? "Yes\n" : "No\n");
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define DEBUG 1
#define fi first
#define se second
#define pb push_back
#define fore(i, a, b) for (int i = (a), _b = (b); i < (_b); ++i)
#define fort(i, a, b) for (int i = (a), _b = (b); i <= (_b); ++i)
#define ford(i, a, b) for (int i = (a), _b = (b); i >= (_b); --i)
using namespace std;
typedef long long LL;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
const int INF = 1e9 + 3;
const int MOD = 1e9 + 7;
int main() {
#ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(false);
cin.tie(0);
#endif
string s;
cin >> s;
sort(s.begin(), s.end());
cout << ((s[0] == s[1] && s[2] == s[3] && s[0] != s[3]) ? "Yes\n" : "No\n");
return 0;
}
| delete | 36 | 37 | 36 | 36 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// A
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
map<char, ll> m;
ll i;
for (i = 0; i < s.length(); i++) {
m[s[i]]++;
}
if (m.size() != 2) {
cout << "No";
} else {
map<char, ll>::iterator it;
for (it = m.begin(); it != m.end(); it++) {
if (it->second != 2) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// A
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
map<char, ll> m;
ll i;
for (i = 0; i < s.length(); i++) {
m[s[i]]++;
}
if (m.size() != 2) {
cout << "No";
} else {
map<char, ll>::iterator it;
for (it = m.begin(); it != m.end(); it++) {
if (it->second != 2) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
} | delete | 6 | 9 | 6 | 6 | 0 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
int cnt = 0;
rep(i, 4) {
if (s.at(i) != s.at(i + 1))
cnt++;
}
if (cnt == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
string s;
cin >> s;
map<char, int> mp;
rep(i, s.size()) { mp[s.at(i)]++; }
if (mp.size() == 2 && mp[s.at(0)] == 2)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | replace | 8 | 16 | 8 | 11 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 4) >= this->size() (which is 4)
|
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> s;
for (int i = 0; i < 4; i++) {
cin >> s.at(i);
}
sort(s.begin(), s.end());
if (s.at(0) == s.at(1) && s.at(1) != s.at(2) && s.at(2) == s.at(3)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> s(4);
for (int i = 0; i <= 3; i++) {
cin >> s.at(i);
}
sort(s.begin(), s.end());
if (s.at(0) == s.at(1) && s.at(1) != s.at(2) && s.at(2) == s.at(3)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| replace | 4 | 6 | 4 | 6 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 0) >= this->size() (which is 0)
|
p02987 | C++ | Runtime Error | // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define ffo(i, a, b) for (int i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
// #pragma GCC target ("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool comp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return ((a.ss < b.ss) || (a.ss == b.ss && a.ff < b.ff));
}
signed main() {
IOS io_set();
string s;
cin >> s;
unordered_map<char, ll> mpp;
rep(i, sz(s)) { mpp[s[i]]++; }
if (sz(mpp) == 2) {
ll f = 0;
for (auto it : mpp) {
if (it.ss != 2) {
f = 1;
break;
}
}
if (f) {
cout << "No\n";
} else {
cout << "Yes\n";
}
} else {
cout << "No\n";
}
return 0;
}
| // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define ffo(i, a, b) for (int i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
// #pragma GCC target ("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
bool comp(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return ((a.ss < b.ss) || (a.ss == b.ss && a.ff < b.ff));
}
signed main() {
IOS
// io_set();
string s;
cin >> s;
unordered_map<char, ll> mpp;
rep(i, sz(s)) { mpp[s[i]]++; }
if (sz(mpp) == 2) {
ll f = 0;
for (auto it : mpp) {
if (it.ss != 2) {
f = 1;
break;
}
}
if (f) {
cout << "No\n";
} else {
cout << "Yes\n";
}
} else {
cout << "No\n";
}
return 0;
}
| replace | 81 | 83 | 81 | 84 | 0 | |
p02987 | C++ | Runtime Error | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <stdio.h>
#include <time.h>
#include <unordered_set>
#include <vector>
#define prev askdnsajd
#define rank asasdmdnasd
#define next lsjndajbs
#define hash asmdklansd
#define index asdklnas
#define right sld
#define left sldl
using namespace std;
typedef long long ll;
typedef long double dbl;
template <class T> void print(vector<T> s) {
for (T x : s)
cout << x << " ";
cout << endl;
}
void solve() {}
int main() {
srand(17);
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen("a.in", "r", stdin);
string s;
cin >> s;
map<char, int> cnt;
for (int i = 0; i < 4; i++)
cnt[s[i]]++;
for (int i = 0; i < 4; i++) {
if (cnt[s[i]] != 2) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
} | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <stdio.h>
#include <time.h>
#include <unordered_set>
#include <vector>
#define prev askdnsajd
#define rank asasdmdnasd
#define next lsjndajbs
#define hash asmdklansd
#define index asdklnas
#define right sld
#define left sldl
using namespace std;
typedef long long ll;
typedef long double dbl;
template <class T> void print(vector<T> s) {
for (T x : s)
cout << x << " ";
cout << endl;
}
void solve() {}
int main() {
srand(17);
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("a.in", "r", stdin);
string s;
cin >> s;
map<char, int> cnt;
for (int i = 0; i < 4; i++)
cnt[s[i]]++;
for (int i = 0; i < 4; i++) {
if (cnt[s[i]] != 2) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
} | replace | 40 | 41 | 40 | 41 | 0 | |
p02987 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
sort(&s, &s + 4);
if (s[0] == s[1] && s[2] == s[3]) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s.at(0) == s.at(1) && s.at(1) != s.at(2) && s.at(2) == s.at(3)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | replace | 6 | 8 | 6 | 8 | -11 | |
p02987 | C++ | Runtime Error | #include <iostream>
int main(int argc, char *argv[]) {
if ((argv[1][0] == argv[1][1] && argv[1][2] == argv[1][3]) ||
(argv[1][0] == argv[1][2] && argv[1][1] == argv[1][3]) ||
(argv[1][0] == argv[1][3] && argv[1][1] == argv[1][2])) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
} | #include <iostream>
int main(int argc, char *argv[]) {
char c[5];
std::cin >> c;
if ((c[0] == c[1] && c[2] == c[3] && c[0] != c[2]) ||
(c[0] == c[2] && c[1] == c[3] && c[0] != c[1]) ||
(c[0] == c[3] && c[1] == c[2] && c[0] != c[1])) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
} | replace | 3 | 6 | 3 | 8 | -11 | |
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) && s.at(2) == s.at(3) && s.at(0) != s.at(2) ||
s.at(0) == s.at(2) && s.at(1) == s.at(3) && s.at(0) != s.at(1) ||
s.at(0) == s.at(4) && s.at(1) == s.at(3) && s.at(0) != s.at(1))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) && s.at(2) == s.at(3) && s.at(0) != s.at(2) ||
s.at(0) == s.at(2) && s.at(1) == s.at(3) && s.at(0) != s.at(1) ||
s.at(0) == s.at(3) && s.at(1) == s.at(2) && s.at(0) != s.at(1))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | replace | 10 | 11 | 10 | 11 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 4) >= this->size() (which is 4)
|
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
#define db(x) cout << #x << "=" << x << endl;
using namespace std;
char a[10];
int cnt[27];
int main() {
scanf("%s", a);
for (int i = 0; i < 4; i++)
cnt[a[i] - 'a']++;
bool flg = 0;
for (int i = 0; i < 26; i++)
if (cnt[i] && cnt[i] != 2)
flg = 1;
puts(flg ? "No" : "Yes");
return 0;
}
| #include <bits/stdc++.h>
#define db(x) cout << #x << "=" << x << endl;
using namespace std;
char a[10];
int cnt[27];
int main() {
scanf("%s", a);
for (int i = 0; i < 4; i++)
cnt[a[i] - 'A']++;
bool flg = 0;
for (int i = 0; i < 26; i++)
if (cnt[i] && cnt[i] != 2)
flg = 1;
puts(flg ? "No" : "Yes");
return 0;
}
| replace | 8 | 9 | 8 | 9 | -11 | |
p02987 | Python | Runtime Error | S = input()
print("Yes" if all(S.count(s) == 2 for s in input()) else "No")
| S = input()
print("Yes" if all(S.count(s) == 2 for s in S) else "No")
| replace | 2 | 3 | 2 | 3 | EOFError: EOF when reading a line | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s449749875.py", line 3, in <module>
print('Yes' if all(S.count(s) == 2 for s in input()) else 'No')
EOFError: EOF when reading a line
|
p02987 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
sort(S.begin(), S.end());
if (S.at(0) == S.at(1) && S.at(1) != S.at(2) && S.at(2) == S.at(3))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> S(4);
for (int i = 0; i < 4; i++)
cin >> S.at(i);
sort(S.begin(), S.end());
if (S.at(0) == S.at(1) && S.at(1) != S.at(2) && S.at(2) == S.at(3))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | replace | 4 | 5 | 4 | 7 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at: __n (which is 0) >= this->size() (which is 0)
|
p02987 | Python | Runtime Error | from collections import defaultdict
S = defaultdict(int)
for i in input():
S[i] += 1
a, b, *_ = S.values()
if a == b == 2:
print("Yes")
else:
print("No")
| from collections import defaultdict
S = defaultdict(int)
for i in input():
S[i] += 1
if len(S.values()) == 2:
a, b = S.values()
if a == b == 2:
print("Yes")
exit()
print("No")
| replace | 6 | 11 | 6 | 12 | 0 | |
p02987 | Python | Runtime Error | S = input()
if S[0] == S[1] and S[2] == S[3] and len(set(S)) == 2:
print("Yes")
elif S[0] == S[2] and S[1] == S[4] and len(set(S)) == 2:
print("Yes")
elif S[0] == S[3] and S[1] == S[2] and len(set(S)) == 2:
print("Yes")
else:
print("No")
| S = input()
if S[0] == S[1] and S[2] == S[3] and len(set(S)) == 2:
print("Yes")
elif S[0] == S[2] and S[1] == S[3] and len(set(S)) == 2:
print("Yes")
elif S[0] == S[3] and S[1] == S[2] and len(set(S)) == 2:
print("Yes")
else:
print("No")
| replace | 3 | 4 | 3 | 4 | 0 | |
p02987 | Python | Runtime Error | s = list(input())
t = set[s]
if len(t) == 2 and s.count(t[0]) == 2:
print("Yes")
else:
print("No")
| s = list(input())
t = list(set(s))
if len(t) == 2 and s.count(t[0]) == 2:
print("Yes")
else:
print("No")
| replace | 1 | 2 | 1 | 2 | TypeError: object of type 'types.GenericAlias' has no len() | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s708958303.py", line 3, in <module>
if len(t) == 2 and s.count(t[0]) == 2 :
TypeError: object of type 'types.GenericAlias' has no len()
|
p02987 | Python | Runtime Error | S = input()
S = S.strip(S[0])
if len(S[0]) > 0:
S = S.strip(S[0])
if len(S) == 0:
print("Yes")
else:
print("No")
else:
print("No")
| S = input()
S = S.replace(S[0], "")
if len(S) > 0:
S = S.replace(S[0], "")
if len(S) == 0:
print("Yes")
else:
print("No")
else:
print("No")
| replace | 1 | 5 | 1 | 4 | 0 | |
p02987 | Python | Runtime Error | s = input()
s.sort()
ans = "No"
if s[0] == s[1] and s[2] == s[3]:
if s[1] != s[2]:
ans = "Yes"
print(ans)
| s = list(input())
s.sort()
ans = "No"
if s[0] == s[1] and s[2] == s[3]:
if s[1] != s[2]:
ans = "Yes"
print(ans)
| replace | 0 | 1 | 0 | 1 | AttributeError: 'str' object has no attribute 'sort' | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s791520641.py", line 2, in <module>
s.sort()
AttributeError: 'str' object has no attribute 'sort'
|
p02987 | Python | Runtime Error | S = input()
S2 = set(list(S))
print("Yes") if len(S2) == 2 and S.count(S2[0]) == S.count(S2[1]) else print("No")
| S = input()
S2 = list(set(S))
print("Yes") if len(S2) == 2 and S.count(S2[0]) == S.count(S2[1]) else print("No")
| replace | 1 | 2 | 1 | 2 | TypeError: 'set' object is not subscriptable | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s874997723.py", line 3, in <module>
print('Yes') if len(S2) == 2 and S.count(S2[0]) == S.count(S2[1]) else print('No')
TypeError: 'set' object is not subscriptable
|
p02987 | Python | Runtime Error | from collections import Counter
s = input()
c = Counter(s)
if len(c) == 2 and c.most_common(1)[1] == 2:
print("Yes")
else:
print("No")
| from collections import Counter
s = input()
c = Counter(s)
if len(c) == 2 and c.most_common(1)[0][1] == 2:
print("Yes")
else:
print("No")
| replace | 5 | 6 | 5 | 6 | IndexError: list index out of range | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s756840059.py", line 6, in <module>
if len(c) == 2 and c.most_common(1)[1] == 2:
IndexError: list index out of range
|
p02987 | Python | Runtime Error | import sys
s = sys.argv[1]
if len(s) == 4:
if s.count(s[0]) == 2:
if s.count(s[1]) == 2:
if s.count(s[2]) == 2:
if s.count(s[3]) == 2:
print("Yes")
exit()
print("No")
exit()
| import sys
# s = sys.argv[1]
s = input()
if len(s) == 4:
if s.count(s[0]) == 2:
if s.count(s[1]) == 2:
if s.count(s[2]) == 2:
if s.count(s[3]) == 2:
print("Yes")
exit()
print("No")
exit()
| replace | 3 | 5 | 3 | 5 | IndexError: list index out of range | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02987/Python/s870683023.py", line 4, in <module>
s = sys.argv[1]
IndexError: list index out of range
|
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define repm(i, m, n) for (int i = m; i < (n); i++)
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
int main() {
int n;
cin >> n;
vi p(n);
rep(i, n) cin >> p.at(i);
int ans = 0;
rep1(i, n - 1) {
if (p.at(i - 1) < p.at(i) && p.at(i) < p.at(i + 1))
ans++;
else if (p.at(i - 1) > p.at(i) && p.at(i) > p.at(i + 1))
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define repm(i, m, n) for (int i = m; i < (n); i++)
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
int main() {
int n;
cin >> n;
vi p(n);
rep(i, n) cin >> p.at(i);
int ans = 0;
rep1(i, n - 2) {
if (p.at(i - 1) < p.at(i) && p.at(i) < p.at(i + 1))
ans++;
else if (p.at(i - 1) > p.at(i) && p.at(i) > p.at(i + 1))
ans++;
}
cout << ans << endl;
return 0;
} | replace | 18 | 19 | 18 | 19 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 5) >= this->size() (which is 5)
|
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
vector<int> p;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (p[i - 1] < p[i] && p[i] < p[i + 1])
cnt++;
else if (p[i - 1] > p[i] && p[i] > p[i + 1])
cnt++;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
vector<int> p;
cin >> n;
p.resize(n + 1);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (p[i - 1] < p[i] && p[i] < p[i + 1])
cnt++;
else if (p[i - 1] > p[i] && p[i] > p[i + 1])
cnt++;
}
cout << cnt << endl;
} | insert | 9 | 9 | 9 | 11 | -11 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> P(N);
for (int i = 0; i < N; i++) {
cin >> P.at(i);
}
int count = 0;
for (int k = 0; k < N - 1; k++) {
if ((P.at(k) - P.at(k - 1)) * (P.at(k + 1) - P.at(k)) > 0) {
count++;
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> P(N);
for (int i = 0; i < N; i++) {
cin >> P.at(i);
}
int count = 0;
for (int k = 1; k < N - 1; k++) {
if ((P.at(k) - P.at(k - 1)) * (P.at(k + 1) - P.at(k)) > 0) {
count++;
}
}
cout << count << endl;
}
| replace | 11 | 12 | 11 | 12 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 18446744073709551615) >= this->size() (which is 5)
|
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
}
int count = 0;
for (int i = 1; i < n - 1; i++) {
if (data.at(i + 1) < max(data.at(i - 1), data.at(i + 2)) &&
data.at(i + 1) > min(data.at(i - 1), data.at(i + 2))) {
count++;
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
}
int count = 0;
for (int i = 0; i < n - 2; i++) {
int a = max(data.at(i), data.at(i + 2));
int b = min(data.at(i), data.at(i + 2));
if (data.at(i + 1) < a && data.at(i + 1) > b) {
count++;
}
}
cout << count << endl;
}
| replace | 12 | 15 | 12 | 17 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 5) >= this->size() (which is 5)
|
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// B
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll i;
ll a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
ll c = 0;
for (i = 1; i < n - 1; i++) {
if ((a[i] > a[i - 1] && a[i] < a[i + 1]) ||
(a[i] < a[i - 1] && a[i] > a[i + 1]))
c++;
}
cout << c;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// B
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll i;
ll a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
ll c = 0;
for (i = 1; i < n - 1; i++) {
if ((a[i] > a[i - 1] && a[i] < a[i + 1]) ||
(a[i] < a[i - 1] && a[i] > a[i + 1]))
c++;
}
cout << c;
} | delete | 6 | 9 | 6 | 6 | -11 | |
p02988 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, ans;
ans = 0;
cin >> n;
vector<int> P(n);
rep(i, n) cin >> P[i];
rep(i, n - 1) if (P[i] < P[i + 1] && P[i + 1] < P[i + 2]) ans += 1;
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, ans;
ans = 0;
cin >> n;
vector<int> P(n);
rep(i, n) cin >> P[i];
rep(i, n - 2) if (P[i] < P[i + 1] && P[i + 1] < P[i + 2]) ans++;
else if ((P[i] > P[i + 1]) && (P[i + 1] > P[i + 2])) ans++;
cout << ans << endl;
} | replace | 11 | 12 | 11 | 13 | 0 | |
p02988 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define DEBUG 1
#define fi first
#define se second
#define pb push_back
#define fore(i, a, b) for (int i = (a), _b = (b); i < (_b); ++i)
#define fort(i, a, b) for (int i = (a), _b = (b); i <= (_b); ++i)
#define ford(i, a, b) for (int i = (a), _b = (b); i >= (_b); --i)
using namespace std;
typedef long long LL;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
const int INF = 1e9 + 3;
const int MOD = 1e9 + 7;
int main() {
#ifndef ONLINE_JUDGE
freopen("in", "r", stdin);
ios_base::sync_with_stdio(false);
cin.tie(0);
#endif
int n;
cin >> n;
vi p(n);
for (int &x : p)
cin >> x;
int cnt = 0;
fore(i, 1, n - 1) if ((p[i - 1] <= p[i] && p[i] <= p[i + 1]) ||
(p[i - 1] >= p[i] && p[i] >= p[i + 1]))++ cnt;
cout << cnt << '\n';
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define DEBUG 1
#define fi first
#define se second
#define pb push_back
#define fore(i, a, b) for (int i = (a), _b = (b); i < (_b); ++i)
#define fort(i, a, b) for (int i = (a), _b = (b); i <= (_b); ++i)
#define ford(i, a, b) for (int i = (a), _b = (b); i >= (_b); --i)
using namespace std;
typedef long long LL;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
const int INF = 1e9 + 3;
const int MOD = 1e9 + 7;
int main() {
#ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(false);
cin.tie(0);
#endif
int n;
cin >> n;
vi p(n);
for (int &x : p)
cin >> x;
int cnt = 0;
fore(i, 1, n - 1) if ((p[i - 1] <= p[i] && p[i] <= p[i + 1]) ||
(p[i - 1] >= p[i] && p[i] >= p[i + 1]))++ cnt;
cout << cnt << '\n';
return 0;
}
| replace | 36 | 37 | 36 | 37 | 0 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int num;
int i;
int pn[4];
int count = 0;
cin >> num;
for (i = 0; i < num; i++)
cin >> pn[i];
for (i = 1; i < num - 1; i++) {
if (pn[i - 1] < pn[i] && pn[i] < pn[i + 1])
count++;
else if (pn[i + 1] < pn[i] && pn[i] < pn[i - 1])
count++;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int num;
int i;
int pn[20];
int count = 0;
cin >> num;
for (i = 0; i < num; i++)
cin >> pn[i];
for (i = 1; i < num - 1; i++) {
if (pn[i - 1] < pn[i] && pn[i] < pn[i + 1])
count++;
else if (pn[i + 1] < pn[i] && pn[i] < pn[i - 1])
count++;
}
cout << count << endl;
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
if (i > 1) {
if (((vec.at(i) < vec.at(i - 1)) && (vec.at(i - 1) < vec.at(i - 2)) ||
((vec.at(i) > vec.at(i - 1))) && (vec.at(i - 1) > vec.at(i + 2)))) {
ans++;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
if (i > 1) {
if (((vec.at(i) < vec.at(i - 1)) && (vec.at(i - 1) < vec.at(i - 2)) ||
((vec.at(i) > vec.at(i - 1))) && (vec.at(i - 1) > vec.at(i - 2)))) {
ans++;
}
}
}
cout << ans << endl;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++)
cin >> p.at(i);
int k = 0;
for (int i = 0; i < n - 2; i++) {
if (p.at(i - 1) < p.at(i) && p.at(i) < p.at(i + 1))
k++;
else if (p.at(i + 1) < p.at(i) && p.at(i) < p.at(i - 1))
k++;
}
cout << k << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++)
cin >> p.at(i);
int k = 0;
for (int i = 1; i < n - 1; i++) {
if (p.at(i - 1) < p.at(i) && p.at(i) < p.at(i + 1))
k++;
else if (p.at(i + 1) < p.at(i) && p.at(i) < p.at(i - 1))
k++;
}
cout << k << endl;
} | replace | 12 | 13 | 12 | 13 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 18446744073709551615) >= this->size() (which is 5)
|
p02988 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int ans = 0;
for (int i = 0; i < n - 2; i) {
if (p[i] < p[i + 1] < p[i + 2]) {
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int ans = 0;
for (int i = 0; i < n - 2; i++) {
if (p[i] < p[i + 1] && p[i + 1] < p[i + 2]) {
ans++;
} else if (p[i] > p[i + 1] && p[i + 1] > p[i + 2]) {
ans++;
}
}
cout << ans << endl;
return 0;
} | replace | 12 | 14 | 12 | 16 | TLE | |
p02988 | C++ | Runtime Error | #include <stdio.h>
#define max(a, b) (a < b ? b : a)
#define min(a, b) (a < b ? a : b)
int main(void) {
int N;
scanf("%d", &N);
int p[20];
for (int i = 0; i < N; i++) {
scanf("%d", p[i]);
}
int cnt = 0;
for (int i = 1; i < N - 1; i++) {
int ma = max(max(p[i - 1], p[i]), p[i + 1]);
int mi = min(min(p[i - 1], p[i]), p[i + 1]);
if ((ma != p[i]) && (mi != p[i])) {
cnt++;
}
}
printf("%d", cnt);
} | #include <stdio.h>
#define max(a, b) (a < b ? b : a)
#define min(a, b) (a < b ? a : b)
int main(void) {
int N;
scanf("%d", &N);
int p[20];
for (int i = 0; i < N; i++) {
scanf("%d", &p[i]);
}
int cnt = 0;
for (int i = 1; i < N - 1; i++) {
int ma = max(max(p[i - 1], p[i]), p[i + 1]);
int mi = min(min(p[i - 1], p[i]), p[i + 1]);
if ((ma != p[i]) && (mi != p[i])) {
cnt++;
}
}
printf("%d", cnt);
} | replace | 11 | 12 | 11 | 12 | -11 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long li;
typedef long double ld;
void solve();
int32_t main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int t = 1;
// cin >> t;
while (t--) {
solve();
}
return 0;
}
const int N = 2e5;
int n;
int p[N];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
int ans = 0;
for (int i = 2; i < n; ++i) {
vector<int> lol;
lol.push_back(p[i]);
lol.push_back(p[i - 1]);
lol.push_back(p[i + 1]);
sort(lol.begin(), lol.end());
if (lol[1] == p[i])
ans++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long li;
typedef long double ld;
void solve();
int32_t main() {
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
#endif
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int t = 1;
// cin >> t;
while (t--) {
solve();
}
return 0;
}
const int N = 2e5;
int n;
int p[N];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
int ans = 0;
for (int i = 2; i < n; ++i) {
vector<int> lol;
lol.push_back(p[i]);
lol.push_back(p[i - 1]);
lol.push_back(p[i + 1]);
sort(lol.begin(), lol.end());
if (lol[1] == p[i])
ans++;
}
cout << ans;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p02988 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> s(n);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int ans = 0;
for (int i = 1; i < n - 1; i++) {
if (s[i] < s[i + 1] || s[i] < s[i - 1]) {
if (s[i] > s[i + 1] || s[i] > s[i - 1]) {
++ans;
// cout<<s[i]<<endl;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> s(30);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int ans = 0;
for (int i = 1; i < n - 1; i++) {
if (s[i] < s[i + 1] || s[i] < s[i - 1]) {
if (s[i] > s[i + 1] || s[i] > s[i - 1]) {
++ans;
// cout<<s[i]<<endl;
}
}
}
cout << ans << endl;
return 0;
}
| replace | 5 | 6 | 5 | 6 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02989 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int index(vector<int> d, int x) {
rep(i, d.size()) {
if (d[i] >= x)
return i;
}
return -1;
}
int main() {
int n, ans = 0;
cin >> n;
vector<int> d(n);
int halfn = n / 2;
rep(i, n) cin >> d[i];
::sort(d.begin(), d.end());
int maximum = d[n - 1];
for (int i = 1; i <= maximum; i++) {
int kindex = index(d, i);
if (kindex == halfn)
ans++;
else if (kindex > halfn) {
cout << ans << endl;
return 0;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int index(vector<int> d, int x) {
rep(i, d.size()) {
if (d[i] >= x)
return i;
}
return -1;
}
int main() {
int n, ans = 0;
cin >> n;
vector<int> d(n);
int halfn = n / 2;
rep(i, n) cin >> d[i];
::sort(d.begin(), d.end());
cout << d[halfn] - d[halfn - 1] << endl;
} | replace | 23 | 34 | 23 | 24 | TLE | |
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
cout << a[n / 2] - a[(n / 2) - 1];
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
cout << a[n / 2] - a[(n / 2) - 1];
}
| delete | 7 | 11 | 7 | 7 | -11 | |
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(a, b, c) for (int a = b, a##end = c; a <= a##end; ++a)
#define drep(a, b, c) for (int a = b, a##end = c; a >= a##end; --a)
char IO;
int rd() {
int s = 0, f = 0;
while (IO = getchar(), IO < '0' || IO > '9')
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (IO = getchar(), IO >= '0' && IO <= '9');
return f ? -s : s;
}
const int N = 300, K = 50;
int n;
int a[N];
int main() {
rep(i, 1, n = rd()) a[i] = rd();
sort(a + 1, a + n + 1);
if (n & 1)
return puts("0"), 0;
int mid = n / 2;
printf("%d\n", a[mid + 1] - a[mid]);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(a, b, c) for (int a = b, a##end = c; a <= a##end; ++a)
#define drep(a, b, c) for (int a = b, a##end = c; a >= a##end; --a)
char IO;
int rd() {
int s = 0, f = 0;
while (IO = getchar(), IO < '0' || IO > '9')
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (IO = getchar(), IO >= '0' && IO <= '9');
return f ? -s : s;
}
const int N = 1e5 + 10, K = 50;
int n;
int a[N];
int main() {
rep(i, 1, n = rd()) a[i] = rd();
sort(a + 1, a + n + 1);
if (n & 1)
return puts("0"), 0;
int mid = n / 2;
printf("%d\n", a[mid + 1] - a[mid]);
}
| replace | 20 | 21 | 20 | 21 | 0 | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MEM(a, b) memset((a), (b), sizeof(a))
const LL INF = 1e9 + 7;
const int N = 1e3 + 10;
int a[N];
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
cout << a[n / 2 + 1] - a[n / 2] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MEM(a, b) memset((a), (b), sizeof(a))
const LL INF = 1e9 + 7;
const int N = 2e5 + 10;
int a[N];
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + n + 1);
cout << a[n / 2 + 1] - a[n / 2] << endl;
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
char N;
int d[100005];
int ans = 0;
signed main() {
scanf("%lld", &N);
rep(i, N) { scanf("%lld", &d[i]); }
sort(d, d + N);
ans = d[(N / 2)] - d[(N / 2) - 1];
printf("%lld\n", ans);
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
int N;
int d[100005];
int ans = 0;
signed main() {
scanf("%lld", &N);
rep(i, N) { scanf("%lld", &d[i]); }
sort(d, d + N);
ans = d[(N / 2)] - d[(N / 2) - 1];
printf("%lld\n", ans);
}
| replace | 17 | 18 | 17 | 18 | 0 | |
p02989 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> d(N);
for (int i = 0; i < N; i++)
cin >> d.at(i);
int count = 0;
sort(d.begin(), d.end());
for (int i = d.at(N / 2 - 1); i < d.at(N / 2); i++) {
int r = 0, b = 0;
for (int j = 0; j < N; j++) {
if (i < d.at(j))
r++;
else
b++;
}
if (r == b)
count++;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> d(N);
for (int i = 0; i < N; i++)
cin >> d.at(i);
int count = 0;
sort(d.begin(), d.end());
count = d.at(N / 2) - d.at(N / 2 - 1);
cout << count << endl;
}
| replace | 13 | 24 | 13 | 15 | TLE | |
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
ll n;
cin >> n;
ll d[n];
for (ll i = 0; i < n; i++)
cin >> d[i];
sort(d, d + n);
cout << d[n / 2] - d[n / 2 - 1];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll d[n];
for (ll i = 0; i < n; i++)
cin >> d[i];
sort(d, d + n);
cout << d[n / 2] - d[n / 2 - 1];
} | delete | 6 | 12 | 6 | 6 | -11 | |
p02989 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[N];
int temp;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
int length = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (arr[i] > arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
int mid = length / 2;
int result;
if (arr[mid - 1] == arr[mid]) {
result = 0;
} else {
result = arr[mid] - arr[mid - 1];
}
cout << result;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[N];
int temp;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
int length = sizeof(arr) / sizeof(arr[0]);
sort(arr, arr + length);
int mid = length / 2;
int result;
if (arr[mid - 1] == arr[mid]) {
result = 0;
} else {
result = arr[mid] - arr[mid - 1];
}
cout << result;
return 0;
} | replace | 12 | 21 | 12 | 13 | TLE | |
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
int main(void) {
int n;
cin >> n;
vector<int> d(n);
for (auto &i : d)
cin >> i;
sort(d.begin(), d.end());
cout << d.at(n / 2 + 1) - d.at(n / 2) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
int main(void) {
int n;
cin >> n;
vector<int> d(n);
for (auto &i : d)
cin >> i;
sort(d.begin(), d.end());
cout << (d.at(n / 2) - d.at(n / 2 - 1)) << endl;
return 0;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[N];
sort(v.begin(), v.end());
int answer = v[v.size() / 2] - v[v.size() / 2 - 1];
cout << answer << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++)
cin >> v[i];
sort(v.begin(), v.end());
int answer = v[v.size() / 2] - v[v.size() / 2 - 1];
cout << answer << endl;
} | replace | 11 | 12 | 11 | 12 | -6 | Fatal glibc error: malloc assertion failure in sysmalloc: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)
|
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int X = 0; X < N; X++) {
cin >> vec.at(N);
}
sort(vec.begin(), vec.end());
cout << vec.at(N / 2) - vec.at(N / 2 - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int X = 0; X < N; X++) {
cin >> vec.at(X);
}
sort(vec.begin(), vec.end());
cout << vec.at(N / 2) - vec.at(N / 2 - 1) << endl;
} | replace | 8 | 9 | 8 | 9 | -6 | terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 6) >= this->size() (which is 6)
|
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9')
c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
const int N = 1e5 + 9;
int a[25], n, ans;
int main() {
n = read();
for (int i = 1; i <= n; i++)
a[i] = read();
sort(a + 1, a + n + 1);
for (int i = 1; i <= 100000; i++) {
int p = lower_bound(a + 1, a + n + 1, i) - a;
int num1 = p - 1, num2 = n - p + 1;
if (num1 == num2)
ans++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9')
c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
const int N = 1e5 + 9;
int a[N], n, ans;
int main() {
n = read();
for (int i = 1; i <= n; i++)
a[i] = read();
sort(a + 1, a + n + 1);
for (int i = 1; i <= 100000; i++) {
int p = lower_bound(a + 1, a + n + 1, i) - a;
int num1 = p - 1, num2 = n - p + 1;
if (num1 == num2)
ans++;
}
cout << ans;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p02989 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
#define pi 3.14159265358979323846264338327950
int main() {
int N;
std::cin >> N;
std::vector<int> D(N);
for (auto &r : D)
std::cin >> r;
int ans = 0;
for (int i = 1; i <= 100000; ++i) {
int count_e = 0;
int count_h = 0;
for (auto &r : D) {
if (r > i)
++count_e;
if (r <= i)
++count_h;
}
if (count_e == count_h)
++ans;
}
std::cout << ans << std::endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
#define pi 3.14159265358979323846264338327950
int main() {
int N;
std::cin >> N;
std::vector<int> D(N);
for (auto &r : D)
std::cin >> r;
std::sort(D.begin(), D.end());
std::cout << D[N / 2] - D[N / 2 - 1] << std::endl;
return 0;
} | replace | 14 | 28 | 14 | 16 | TLE | |
p02989 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const ll MOD = 1000000007;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll n;
vector<ll> d;
bool solve(ll k) {
ll abc = 0, arc = 0;
for (auto v : d) {
if (v >= k) {
arc++;
} else {
abc++;
}
}
return abc == arc;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
d.resize(n);
for (auto &v : d) {
cin >> v;
}
sort(begin(d), end(d));
ll left = *min_element(begin(d), end(d));
ll right = *max_element(begin(d), end(d));
ll ans = 0;
bool isFrist = true;
for (ll i = left; i <= right; i++) {
if (solve(i)) {
ans++;
isFrist = false;
continue;
}
if (!isFrist) {
break;
}
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
const double PI = 3.1415926535897932384626433832795;
const ll MOD = 1000000007;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : abs(x); }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll n;
vector<ll> d;
bool solve(ll k) {
ll abc = 0, arc = 0;
for (auto v : d) {
if (v >= k) {
arc++;
} else {
abc++;
}
}
return abc == arc;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
d.resize(n);
for (auto &v : d) {
cin >> v;
}
sort(begin(d), end(d));
ll ans = d[n / 2] - d[n / 2 - 1];
cout << ans << endl;
return 0;
}
| replace | 45 | 65 | 45 | 46 | TLE | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define ll long long
#define imfor(i, n) for (int i = 0; i < n; i++)
using namespace std;
ll MOD = 1000000007;
int main() {
int n;
int d[10010];
cin >> n;
imfor(i, n) { cin >> d[i]; }
sort(d, d + n);
int ans = d[(n / 2)] - d[(n / 2) - 1];
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define ll long long
#define imfor(i, n) for (int i = 0; i < n; i++)
using namespace std;
ll MOD = 1000000007;
int main() {
int n;
int d[100010];
cin >> n;
imfor(i, n) { cin >> d[i]; }
sort(d, d + n);
int ans = d[(n / 2)] - d[(n / 2) - 1];
cout << ans << endl;
} | replace | 23 | 24 | 23 | 24 | 0 | |
p02989 | Python | Time Limit Exceeded | n = int(input())
p = list(map(int, input().split()))
ans = 0
for k in range(1, max(p) + 1):
abc = 0
arc = 0
for i in p:
if i < k:
abc += 1
else:
arc += 1
if abc == arc:
ans += 1
print(ans)
| n = int(input())
p = sorted(list(map(int, input().split())))
a = int(len(p) / 2)
if p[a - 1] == p[a]:
print(0)
else:
print(p[a] - p[a - 1])
| replace | 1 | 14 | 1 | 7 | TLE | |
p02989 | C++ | Runtime Error | /*------------------------------------
........Bismillahir Rahmanir Rahim....
..........created by Abdul Aziz.......
------------------------------------*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <vector>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define ff first
#define ss second
#define pii pair<int, int>
using namespace std;
inline void solve() {
int n;
cin >> n;
int res[n];
for (int i = 1; i <= n; i++) {
cin >> res[i];
}
sort(res + 1, res + n + 1);
if (res[n / 2] == res[(n / 2) + 1])
cout << 0 << endl;
else
cout << (res[n / 2 + 1] - res[n / 2]) << endl;
}
signed main() {
int n = 1; // cin>>n;
while (n--)
solve();
return 0;
}
| /*------------------------------------
........Bismillahir Rahmanir Rahim....
..........created by Abdul Aziz.......
------------------------------------*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <vector>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define ff first
#define ss second
#define pii pair<int, int>
using namespace std;
inline void solve() {
int n;
cin >> n;
int res[n + 1];
for (int i = 1; i <= n; i++) {
cin >> res[i];
}
sort(res + 1, res + n + 1);
if (res[n / 2] == res[(n / 2) + 1])
cout << 0 << endl;
else
cout << (res[n / 2 + 1] - res[n / 2]) << endl;
}
signed main() {
int n = 1; // cin>>n;
while (n--)
solve();
return 0;
}
| replace | 29 | 30 | 29 | 30 | 0 | |
p02989 | Python | Runtime Error | N = input()
D = sorted([int(v) for v in input().split()])
arc = N // 2
abc = arc - 1
print(D[arc] - D[abc])
| N = int(input())
D = sorted([int(v) for v in input().split()])
arc = N // 2
abc = arc - 1
print(D[arc] - D[abc])
| replace | 0 | 1 | 0 | 1 | TypeError: unsupported operand type(s) for //: 'str' and 'int' | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02989/Python/s961124695.py", line 4, in <module>
arc = N // 2
TypeError: unsupported operand type(s) for //: 'str' and 'int'
|
p02989 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int d[10000], n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
sort(d, d + n);
cout << abs(d[n / 2 - 1] - d[n / 2]) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
int main(void) {
int d[100000], n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
sort(d, d + n);
cout << abs(d[n / 2 - 1] - d[n / 2]) << endl;
return 0;
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02989 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
int c = 0, cR, cB;
for (int i = vec.at(0); i <= vec.at(N - 1); i++) {
cR = 0;
cB = 0;
for (int j = 0; j < N; j++) {
if (i <= vec.at(j))
cR++;
else
cB++;
}
if (cR == cB)
c++;
}
cout << c;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
cout << vec.at(N / 2) - vec.at(N / 2 - 1);
} | replace | 11 | 25 | 11 | 12 | TLE | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int n, arr[10000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int sum = arr[n / 2] - arr[n / 2 - 1];
cout << sum;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int n, arr[100000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int sum = arr[n / 2] - arr[n / 2 - 1];
cout << sum;
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02989 | Python | Runtime Error | N = int(input())
D = list(map(int, input().split()))
D.sort()
count = 0
cur = 0
for i in range(10**5 + 1):
if cur == N / 2:
count += 1
if cur > N / 2:
break
if D[cur] < i and cur < N:
cur += 1
while D[cur - 1] == D[cur]:
cur += 1
print(count)
| N = int(input())
D = list(map(int, input().split()))
D.sort()
ans = D[int(N / 2)] - D[int((N / 2) - 1)]
print(ans)
| replace | 4 | 16 | 4 | 6 | 0 | |
p02989 | Python | Runtime Error | # coding: utf-8
def main():
N = int(input())
d = sorted(list(map(int, input().split())))
ans = 0
if d[N / 2] != d[N / 2 - 1]:
ans = d[N / 2] - d[N / 2 - 1]
print(ans)
if __name__ == "__main__":
main()
| # coding: utf-8
def main():
N = int(input())
d = sorted(list(map(int, input().split())))
ans = 0
if d[N // 2] != d[N // 2 - 1]:
ans = d[N // 2] - d[N // 2 - 1]
print(ans)
if __name__ == "__main__":
main()
| replace | 7 | 9 | 7 | 9 | TypeError: list indices must be integers or slices, not float | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02989/Python/s312181382.py", line 14, in <module>
main()
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02989/Python/s312181382.py", line 7, in main
if d[N / 2] != d[N / 2 - 1]:
TypeError: list indices must be integers or slices, not float
|
p02989 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll n, a[200];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + 1 + n);
int l = a[n / 2];
int r = a[n / 2 + 1];
// cout<<l<<" "<<r<<endl;
cout << r - l;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll n, a[100005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
sort(a + 1, a + 1 + n);
int l = a[n / 2];
int r = a[n / 2 + 1];
// cout<<l<<" "<<r<<endl;
cout << r - l;
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p02989 | Python | Runtime Error | N = int(input())
D = list(map(int, input().split())).sort()
print(D[N // 2] - D[(N // 2) - 1])
| N = int(input())
D = sorted(list(map(int, input().split())))
print(D[N // 2] - D[(N // 2) - 1])
| replace | 1 | 2 | 1 | 2 | TypeError: 'NoneType' object is not subscriptable | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02989/Python/s599840912.py", line 3, in <module>
print(D[N // 2] - D[(N // 2) - 1])
TypeError: 'NoneType' object is not subscriptable
|
p02989 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
int d[30]; // 最大 100 個ですが余裕をもたせます
cin >> N;
for (int i = 0; i < N; ++i)
cin >> d[i];
sort(d, d + N);
cout << d[N / 2] - d[N / 2 - 1] << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
int d[100100]; // 最大 100 個ですが余裕をもたせます
cin >> N;
for (int i = 0; i < N; ++i)
cin >> d[i];
sort(d, d + N);
cout << d[N / 2] - d[N / 2 - 1] << endl;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p02989 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef long double ld;
#define pa pair<int, int>
#define sc(n) scanf("%lld", &n)
#define fo(i, a, b) for (int i = a; i < b; i++)
#define mem(a, b) memset(a, b, sizeof a)
using namespace std;
int n, m;
unordered_map<char, int> mp;
int a[50], b[50];
// struct cmp
//{
// bool operator () (int x, int y)
// {
// return x > y;
// }
// };
int main() {
int t;
int cnt = 0;
sc(n);
fo(i, 0, n) sc(a[i]);
sort(a, a + n);
int l = n / 2 - 1, r = l + 1;
cout << a[r] - a[l] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef long double ld;
#define pa pair<int, int>
#define sc(n) scanf("%lld", &n)
#define fo(i, a, b) for (int i = a; i < b; i++)
#define mem(a, b) memset(a, b, sizeof a)
using namespace std;
int n, m;
unordered_map<char, int> mp;
int a[N], b[N];
// struct cmp
//{
// bool operator () (int x, int y)
// {
// return x > y;
// }
// };
int main() {
int t;
int cnt = 0;
sc(n);
fo(i, 0, n) sc(a[i]);
sort(a, a + n);
int l = n / 2 - 1, r = l + 1;
cout << a[r] - a[l] << endl;
return 0;
} | replace | 26 | 27 | 26 | 27 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.