submission_id stringlengths 10 10 | problem_id stringlengths 6 6 | language stringclasses 3
values | code stringlengths 1 522k | compiler_output stringlengths 43 10.2k |
|---|---|---|---|---|
s754739583 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
#define int long long
#define ar array
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto& x: a)
template<class T>
bool umin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template<class T>
bool umax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template<class A>
void read(vt<A> &v);
template<class A, size_t S>
void read(ar<A, S> &a);
template<class T>
void read(T &x) {
cin >> x;
}
void read(double &d) {
string t;
read(t);
d = stod(t);
}
void read(long double &d) {
string t;
read(t);
d = stold(t);
}
template<class H, class... T>
void read(H &h, T &... t) {
read(h);
read(t...);
}
template<class A>
void read(vt<A> &x) {
EACH(a, x)read(a);
}
template<class A, size_t S>
void read(array<A, S> &x) {
EACH(a, x)read(a);
}
string to_string(char c) {
return string(1, c);
}
string to_string(bool b) {
return b ? "true" : "false";
}
string to_string(const char *s) {
return string(s);
}
string to_string(string s) {
return s;
}
string to_string(vt<bool> v) {
string res;
FOR(sz(v))res += char('0' + v[i]);
return res;
}
template<size_t S>
string to_string(bitset<S> b) {
string res;
FOR(S)res += char('0' + b[i]);
return res;
}
template<class T>
string to_string(T v) {
bool f = 1;
string res;
EACH(x, v) {
if (!f)
res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
template<class A>
void write(A x) {
cout << to_string(x);
}
template<class H, class... T>
void write(const H &h, const T &... t) {
write(h);
write(t...);
}
void print() {
write("\n");
}
template<class H, class... T>
void print(const H &h, const T &... t) {
write(h);
if (sizeof...(t))
write(' ');
print(t...);
}
template<class T, class U>
void vti(vt<T> &v, U x, size_t n) {
v = vt<T>(n, x);
}
template<class T, class U>
void vti(vt<T> &v, U x, size_t n, size_t m...) {
v = vt<T>(n);
EACH(a, v)vti(a, x, m);
}
const int mxN = 1e5;
vt<ar<int, 3>> E;
int link[mxN], size[mxN];
int find(int x) {
if (link[x] == x) {
return x;
}
return find(link[x]);
}
bool same(int a, int b) {
return find(a) == find(b);
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (size[a] < size[b]) swap(a, b);
size[a] += size[b];
link[b] = a;
}
void solve() {
int n;
read(n);
vt<ar<int, 2>> xv, yv;
map<ar<int, 2>, int> mp;
FOR(n) {
int x, y;
read(x, y);
mp[{x, y}] = i;
xv.pb({x, y});
yv.pb({y, x});
}
sort(all(xv));
sort(all(yv));
FOR(i, 1, n) {
int x = abs(xv[i][0] - xv[i - 1][0]);
int y = mp[{xv[i - 1][0], xv[i - 1][1]}];
int z = mp[{xv[i][0], xv[i][1]}];
E.pb({x, y, z});
x = abs(yv[i][0] - yv[i - 1][0]);
y = mp[{yv[i - 1][1], yv[i - 1][0]}];
z = mp[{yv[i][1], yv[i][0]}];
E.pb({x, y, z});
}
sort(all(E));
FOR(n) {
link[i] = i;
size[i] = 1;
}
int ans = 0;
EACH(x, E) {
if (!same(x[1], x[2])) {
ans += x[0];
unite(x[1], x[2]);
}
}
print(ans);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tt = 1;
//read(tt);
FOR(tt) {
//write("Case #", i + 1, ": ");
solve();
}
}
| a.cc:149:13: error: 'long long int link [100000]' redeclared as different kind of entity
149 | int link[mxN], size[mxN];
| ^
In file included from /usr/include/x86_64-linux-gnu/bits/sigstksz.h:24,
from /usr/include/signal.h:328,
from /usr/include/c++/14/csignal:42,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:116,
from a.cc:1:
/usr/include/unistd.h:819:12: note: previous declaration 'int link(const char*, const char*)'
819 | extern int link (const char *__from, const char *__to)
| ^~~~
a.cc: In function 'long long int find(long long int)':
a.cc:152:15: warning: pointer to a function used in arithmetic [-Wpointer-arith]
152 | if (link[x] == x) {
| ^
a.cc:152:17: error: ISO C++ forbids comparison between pointer and integer [-fpermissive]
152 | if (link[x] == x) {
| ~~~~~~~~^~~~
a.cc:155:23: warning: pointer to a function used in arithmetic [-Wpointer-arith]
155 | return find(link[x]);
| ^
a.cc:155:16: error: no matching function for call to 'find(int (&)(const char*, const char*) noexcept)'
155 | return find(link[x]);
| ~~~~^~~~~~~~~
a.cc:151:5: note: candidate: 'long long int find(long long int)' (near match)
151 | int find(int x) {
| ^~~~
a.cc:151:5: note: conversion of argument 1 would be ill-formed:
a.cc:155:23: error: invalid conversion from 'int (*)(const char*, const char*) noexcept' to 'long long int' [-fpermissive]
155 | return find(link[x]);
| ~~~~~~^
| |
| int (*)(const char*, const char*) noexcept
In file included from /usr/include/c++/14/algorithm:61,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51:
/usr/include/c++/14/bits/stl_algo.h:3842:5: note: candidate: 'template<class _IIter, class _Tp> _IIter std::find(_IIter, _IIter, const _Tp&)'
3842 | find(_InputIterator __first, _InputIterator __last,
| ^~~~
/usr/include/c++/14/bits/stl_algo.h:3842:5: note: candidate expects 3 arguments, 1 provided
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:60:1: note: candidate: 'template<class _ExecutionPolicy, class _ForwardIterator, class _Tp> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> std::find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&)'
60 | find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
| ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:60:1: note: candidate expects 4 arguments, 1 provided
In file included from /usr/include/c++/14/iterator:66,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:54:
/usr/include/c++/14/bits/streambuf_iterator.h:435:5: note: candidate: 'template<class _CharT2> typename __gnu_cxx::__enable_if<std::__is_char<_CharT2>::__value, std::istreambuf_iterator<_CharT, std::char_traits<_CharT> > >::__type std::find(istreambuf_iterator<_CharT, char_traits<_CharT> >, istreambuf_iterator<_CharT, char_traits<_CharT> >, const _CharT2&)'
435 | find(istreambuf_iterator<_CharT> __first,
| ^~~~
/usr/include/c++/14/bits/streambuf_iterator.h:435:5: note: candidate expects 3 arguments, 1 provided
a.cc: In function 'void unite(long long int, long long int)':
a.cc:166:9: error: reference to 'size' is ambiguous
166 | if (size[a] < size[b]) swap(a, b);
| ^~~~
In file included from /usr/include/c++/14/string:53,
from /usr/include/c++/14/bitset:52,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:149:16: note: 'long long int size [100000]'
149 | int link[mxN], size[mxN];
| ^~~~
a.cc:166:19: error: reference to 'size' is ambiguous
166 | if (size[a] < size[b]) swap(a, b);
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:149:16: note: 'long long int size [100000]'
149 | int link[mxN], size[mxN];
| ^~~~
a.cc:168:5: error: reference to 'size' is ambiguous
168 | size[a] += size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:149:16: note: 'long long int size [100000]'
149 | int link[mxN], size[mxN];
| ^~~~
a.cc:168:16: error: reference to 'size' is ambiguous
168 | size[a] += size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:149:16: note: 'long long int size [100000]'
149 | int link[mxN], size[mxN];
| ^~~~
a.cc:169:11: warning: pointer to a function used in arithmetic [-Wpointer-arith]
169 | link[b] = a;
| ^
a.cc:169:13: error: assignment of read-only location '*(link + ((sizetype)b))'
169 | link[b] = a;
| ~~~~~~~~^~~
a.cc: In function 'void solve()':
a.cc:203:15: warning: pointer to a function used in arithmetic [-Wpointer-arith]
203 | link[i] = i;
| ^
a.cc:203:17: error: assignment of read-only location '*(link + ((sizetype)i))'
203 | link[i] = i;
| ~~~~~~~~^~~
a.cc:204:9: error: reference to 'size' is ambiguous
204 | size[i] = 1;
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:149:16: note: 'long long int size [100000]'
149 | int link[mxN], size[mxN];
| ^~~~
|
s456217947 | p03682 | C++ | #include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
#define ll long long
#define rep(i,n) for (ll i = 0; i < (n); i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORR(i,a,b)for(ll i=(a);i<=(b);i++)
#define repR(i,n) for(ll i=n;i>=0;i--)
#define all(v)(v).begin(),(v).end()
#define rall(v)(v).rbegin(),(v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout<<(x)<<"\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,vector<ll>,greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n" )
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n" )
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template<class T> inline bool chmax(T& a, T b) {
if (a < b) { a = b; return true; } return false;
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) { a = b; return true; } return false;
}
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
ll dx[4]={0,1,0,-1};
ll dy[4]={1,0,-1,0};
int main(){
ll n;
cin>>n;
vector<pll> p;
rep(i,n){
ll x,y;
cin>>x>>y;
p[i]=pll(x,y);
}
sort(all(p));
set<ll> s;
ll ans=0;
rep(i,n){
if(i==0){
s.insert(p[i].S);
continue;
}
ll cu=p[i].F-p[i-1].F;
ll ccu;
if(*rbegin(s)<p[i].S){
ccu=p[i].S-*rbegin(s);
s.insert(p[i].S);
}
else{
auto itr=s.lowerbound(p[i].S);
ccu=*itr-p[i].S;
s.insert(p[i].S);
}
ans+=min(ccu,cu);
}
COUT(ans);
} | a.cc: In function 'int main()':
a.cc:71:18: error: 'class std::set<long long int>' has no member named 'lowerbound'; did you mean 'lower_bound'?
71 | auto itr=s.lowerbound(p[i].S);
| ^~~~~~~~~~
| lower_bound
|
s720938263 | p03682 | C++ | /**
* author: FromDihPout
* created: 2020-08-01
**/
#include <bits/stdc++.h>
using namespace std;
int find(int node, vector<int> &link) {
while (link[node] != node) {
node = link[node];
}
return node;
}
bool same(int node1, int node2, vector<int> &link) {
return find(node1, link) == find(node2, link);
}
void unite(int node1, int node2, vector<int> &link, vector<int> &len) {
node1 = find(node1, link);
node2 = find(node2, link);
if (len[node1] < len[node2]) {
swap(node1, node2);
}
len[node1] += len[node2];
link[node2] = node1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int,int>> x(n), y(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
x[i] = {a, i};
y[i] = {b, i};
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
vector<pair<int, pair<int,int>>> edges(2 * (n - 1));
for (int i = 0; i < n - 1; i++) {
edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
}
for (int i = 0; i < n - 1; i++) {
edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
}
sort(edges.begin(), edges.end());
long long ans = 0;
vector<int> link(n), len(n);
for (int i = 0; i < n; i++) {
link[i] = i;
}
for (int i = 0; i < edges.size(); i++) {
if (!same(edges[i].s.f, edges[i].s.s, link)) {
unite(edges[i].s.f, edges[i].s.s, link, len);
ans += edges[i].f;
}
}
cout << ans << '\n';
return 0;
}
| a.cc: In function 'int main()':
a.cc:49:28: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 'f'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
a.cc:49:37: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 'f'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
a.cc:49:46: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 's'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
a.cc:49:56: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 's'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
a.cc:49:58: error: no match for 'operator=' (operand types are '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, std::pair<int, int> > >, std::pair<int, std::pair<int, int> > >::value_type' {aka 'std::pair<int, std::pair<int, int> >'} and '<brace-enclosed initializer list>')
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
In file included from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:6:
/usr/include/c++/14/bits/stl_pair.h:946:9: note: candidate: 'template<class _U1, class _U2> typename std::enable_if<std::__and_<std::is_assignable<_T1&, const _U1&>, std::is_assignable<_T2&, const _U2&> >::value, std::pair<_T1, _T2>&>::type std::pair<_T1, _T2>::operator=(const std::pair<_U1, _U2>&) [with _U2 = _U1; _T1 = int; _T2 = std::pair<int, int>]'
946 | operator=(const pair<_U1, _U2>& __p)
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:946:9: note: template argument deduction/substitution failed:
a.cc:49:58: note: couldn't deduce template parameter '_U1'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
/usr/include/c++/14/bits/stl_pair.h:957:9: note: candidate: 'template<class _U1, class _U2> typename std::enable_if<std::__and_<std::is_assignable<_T1&, _U1&&>, std::is_assignable<_T2&, _U2&&> >::value, std::pair<_T1, _T2>&>::type std::pair<_T1, _T2>::operator=(std::pair<_U1, _U2>&&) [with _U2 = _U1; _T1 = int; _T2 = std::pair<int, int>]'
957 | operator=(pair<_U1, _U2>&& __p)
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:957:9: note: template argument deduction/substitution failed:
a.cc:49:58: note: couldn't deduce template parameter '_U1'
49 | edges[i] = {x[i+1].f - x[i].f, {x[i].s, x[i+1].s}};
| ^
/usr/include/c++/14/bits/stl_pair.h:921:7: note: candidate: 'std::pair<_T1, _T2>& std::pair<_T1, _T2>::operator=(std::__conditional_t<((bool)std::__and_<std::is_copy_assignable<_T1>, std::is_copy_assignable<_T2> >::value), const std::pair<_T1, _T2>&, const std::__nonesuch&>) [with _T1 = int; _T2 = std::pair<int, int>; std::__conditional_t<((bool)std::__and_<std::is_copy_assignable<_T1>, std::is_copy_assignable<_T2> >::value), const std::pair<_T1, _T2>&, const std::__nonesuch&> = const std::pair<int, std::pair<int, int> >&]'
921 | operator=(__conditional_t<__and_<is_copy_assignable<_T1>,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:923:65: note: no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'std::__conditional_t<true, const std::pair<int, std::pair<int, int> >&, const std::__nonesuch&>' {aka 'const std::pair<int, std::pair<int, int> >&'}
921 | operator=(__conditional_t<__and_<is_copy_assignable<_T1>,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
922 | is_copy_assignable<_T2>>::value,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
923 | const pair&, const __nonesuch&> __p)
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_pair.h:931:7: note: candidate: 'std::pair<_T1, _T2>& std::pair<_T1, _T2>::operator=(std::__conditional_t<((bool)std::__and_<std::is_move_assignable<_Tp>, std::is_move_assignable<_T2> >::value), std::pair<_T1, _T2>&&, std::__nonesuch&&>) [with _T1 = int; _T2 = std::pair<int, int>; std::__conditional_t<((bool)std::__and_<std::is_move_assignable<_Tp>, std::is_move_assignable<_T2> >::value), std::pair<_T1, _T2>&&, std::__nonesuch&&> = std::pair<int, std::pair<int, int> >&&]'
931 | operator=(__conditional_t<__and_<is_move_assignable<_T1>,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:933:55: note: no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'std::__conditional_t<true, std::pair<int, std::pair<int, int> >&&, std::__nonesuch&&>' {aka 'std::pair<int, std::pair<int, int> >&&'}
931 | operator=(__conditional_t<__and_<is_move_assignable<_T1>,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
932 | is_move_assignable<_T2>>::value,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
933 | pair&&, __nonesuch&&> __p)
| ~~~~~~~~~~~~~~~~~~~~~~^~~
a.cc:52:36: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 'f'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
a.cc:52:45: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 'f'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
a.cc:52:54: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 's'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
a.cc:52:64: error: '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, int> >, std::pair<int, int> >::value_type' {aka 'struct std::pair<int, int>'} has no member named 's'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
a.cc:52:66: error: no match for 'operator=' (operand types are '__gnu_cxx::__alloc_traits<std::allocator<std::pair<int, std::pair<int, int> > >, std::pair<int, std::pair<int, int> > >::value_type' {aka 'std::pair<int, std::pair<int, int> >'} and '<brace-enclosed initializer list>')
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
/usr/include/c++/14/bits/stl_pair.h:946:9: note: candidate: 'template<class _U1, class _U2> typename std::enable_if<std::__and_<std::is_assignable<_T1&, const _U1&>, std::is_assignable<_T2&, const _U2&> >::value, std::pair<_T1, _T2>&>::type std::pair<_T1, _T2>::operator=(const std::pair<_U1, _U2>&) [with _U2 = _U1; _T1 = int; _T2 = std::pair<int, int>]'
946 | operator=(const pair<_U1, _U2>& __p)
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:946:9: note: template argument deduction/substitution failed:
a.cc:52:66: note: couldn't deduce template parameter '_U1'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
/usr/include/c++/14/bits/stl_pair.h:957:9: note: candidate: 'template<class _U1, class _U2> typename std::enable_if<std::__and_<std::is_assignable<_T1&, _U1&&>, std::is_assignable<_T2&, _U2&&> >::value, std::pair<_T1, _T2>&>::type std::pair<_T1, _T2>::operator=(std::pair<_U1, _U2>&&) [with _U2 = _U1; _T1 = int; _T2 = std::pair<int, int>]'
957 | operator=(pair<_U1, _U2>&& __p)
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:957:9: note: template argument deduction/substitution failed:
a.cc:52:66: note: couldn't deduce template parameter '_U1'
52 | edges[i + n - 1] = {y[i+1].f - y[i].f, {y[i].s, y[i+1].s}};
| ^
/usr/include/c++/14/bits/stl_pair.h:921:7: note: candidate: 'std::pair<_T1, _T2>& std::pair<_T1, _T2>::operator=(std::__conditional_t<((bool)std::__and_<std::is_copy_assignable<_T1>, std::is_copy_assignable<_T2> >::value), const std::pair<_T1, _T2>&, const std::__nonesuch&>) [with _T1 = int; _T2 = std::pair<int, int>; std::__conditional_t<((bool)std::__and_<std::is_copy_assignable<_T1>, std::is_copy_assignable<_T2> >::value), const std::pair<_T1, _T2>&, const std::__nonesuch&> = const std::pair<int, std::pair<int, int> >&]'
921 | operator=(__conditional_t<__and_<is_copy_assignable<_T1>,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_pair.h:923:65: note: no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'std::__conditional_t<true, const std::pair<int, std::pair<int, int> >&, const std::__nonesuch&>' {aka 'const std::pair<int, std::pair<int, int> >&'}
921 | operator=(__conditional_t<__and_<is_copy_assignable<_T1>,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
922 | is_copy_ass |
s222599338 | p03682 | C++ | #include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<iostream>
#include<map>
#include<string>
#define INF 100093100
using namespace std;
vector<tuple<int,int,int>> road;
int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
int find(int a){
if(root[a]==a)
return root[a];
else
return root[a]=find(root[a]);
}
bool same(int a,int b){
return find(a)==find(b);
}
void unite(int a,int b){
a=find(a);
b=find(b);
if(size[b]>size[a])
swap(a,b);
size[a]+=size[b];
root[b]=a;
}
bool cmp(tuple<int,int,int>a,tuple<int,int,int>b){
int o=get<2>(a);
int p=get<2>(b);
return o<p;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d%d",&x[i],&y[i]);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++){
dix=abs(x[i]-x[j]);
diy=abs(y[i]-y[j]);
road.push_back({i,j,min(dix,diy)});
}
sort(road.begin(),road.end(),cmp);
for(int i=1;i<=n;i++){
root[i]=i;
size[i]=1;
}
for(auto k:road){
tie(q,w,e)=k;
if(!same(q,w)){
unite(q,w);
ans+=e;
finish++;
}
if(finish==n)
break;
}
printf("%d",ans);
}
| a.cc: In function 'void unite(int, int)':
a.cc:27:8: error: reference to 'size' is ambiguous
27 | if(size[b]>size[a])
| ^~~~
In file included from /usr/include/c++/14/vector:69,
from a.cc:5:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:27:16: error: reference to 'size' is ambiguous
27 | if(size[b]>size[a])
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:29:5: error: reference to 'size' is ambiguous
29 | size[a]+=size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:29:14: error: reference to 'size' is ambiguous
29 | size[a]+=size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc: In function 'int main()':
a.cc:50:9: error: reference to 'size' is ambiguous
50 | size[i]=1;
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
|
s520634692 | p03682 | C++ | #include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<iostream>
#include<map>
#include<string>
#define INF 100093100
using namespace std;
vector<tuple<int,int,int>> road;
int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
int find(int a){
if(root[a]==a)
return root[a];
else
return root[a]=find(root[a]);
}
bool same(int a,int b){
return find(a)==find(b);
}
void unite(int a,int b){
a=find(a);
b=find(b);
if(size[b]>size[a])
swap(a,b);
size[a]+=size[b];
root[b]=a;
}
bool cmp(tuple<int,int,int>a,tuple<int,int,int>b){
int o=get<2>(a);
int p=get<2>(b);
return o<p;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d%d",&x[i],&y[i]);
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++){
dix=abs(x[i]-x[j]);
diy=abs(y[i]-y[j]);
road.push_back({i,j,min(dix,diy)});
}
sort(road.begin(),road.end(),cmp);
for(int i=1;i<=n;i++){
root[i]=i;
size[i]=1;
}
for(auto k:road){
tie(q,w,e)=k;
if(!same(q,w)){
unite(q,w);
ans+=e;
finish++;
}
if(finish==n)
break;
}
printf("%d",ans);
} | a.cc: In function 'void unite(int, int)':
a.cc:27:8: error: reference to 'size' is ambiguous
27 | if(size[b]>size[a])
| ^~~~
In file included from /usr/include/c++/14/vector:69,
from a.cc:5:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:27:16: error: reference to 'size' is ambiguous
27 | if(size[b]>size[a])
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:29:5: error: reference to 'size' is ambiguous
29 | size[a]+=size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc:29:14: error: reference to 'size' is ambiguous
29 | size[a]+=size[b];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
a.cc: In function 'int main()':
a.cc:50:9: error: reference to 'size' is ambiguous
50 | size[i]=1;
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:14:40: note: 'int size [100005]'
14 | int x[100005],y[100005],n,root[100005],size[100005],dix,diy,q,w,e,ans=0,finish=1;
| ^~~~
|
s196076628 | p03682 | C++ | #include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
typedef pair<ll, ll> P;
struct edge
{
ll from, end, cost
};
ll prim(vector<bool> &visit, vector<vector<P>> &E)
{
ll total_cost = 0;
priority_queue<P, vector<P>, greater<P>> S;
visit[0] = 1;
ll num0 = 0;
ll cost0 = INFNITY;
for (P u_pair : E[0])
{
S.push(u_pair);
}
while (!S.empty())
{
ll cost = S.top().first;
ll u = S.top().second();
S.pop();
if (visit[u] == 0)
{
visit[[u] =1;
total_cost +=cost;
}
for (P v_pair : E[u])
{
if (visit[v_pair.second] == 0)
{
S.push(v_pair);
}
}
}
return total_cost;
}
int main()
{
int N;
vector<P> xs(N);
vector<P> ys(N);
vector<ll> xi(N);
vector<ll> yi(N);
vector<pair<>> xs;
cin >> N;
for (int i = 0; i < N; i++)
{
ll x, y;
cin >> x >> y;
xs[i] = P(x, i);
ys[i] = P(y, i);
xi[i] = x;
yi[i] = y;
}
sort(xs.begin(), xs.end());
sort(ys.begin(), ys.end());
vector<vector<edge>> E(N, vector<P>(0));
for (int i = 0; i < N - 1; i++)
{
P e1;
e1.second = xs[i + 1].second;
e1.first = abs(xi[xs[i + 1].second] - xi[xs[i].second]);
P e2;
e2.second = xs[i].second;
e2.first = abs(xi[xs[i + 1].second] - xi[xs[i].second]);
E[xs[i + 1].second].push_back(e2);
E[xs[i].second].push_back(e1);
}
for (int i = 0; i < N - 1; i++)
{
P e1;
e1.second = ys[i + 1].second;
e1.first = abs(yi[ys[i + 1].second] - yi[ys[i].second]);
P e2;
e2.second = ys[i].second;
e2.first = abs(yi[ys[i + 1].second] - yi[ys[i].second]);
E[ys[i + 1].second].push_back(e2);
E[ys[i].second].push_back(e1);
}
vector<bool> vist(N, 0);
ll ans = prim(visit, E);
cout << ans << endl;
} | a.cc:10:19: error: expected ';' at end of member declaration
10 | ll from, end, cost
| ^~~~
| ;
a.cc: In function 'll prim(std::vector<bool>&, std::vector<std::vector<std::pair<long long int, long long int> > >&)':
a.cc:21:16: error: 'INFNITY' was not declared in this scope; did you mean 'INFINITY'?
21 | ll cost0 = INFNITY;
| ^~~~~~~
| INFINITY
a.cc:32:30: error: expression cannot be used as a function
32 | ll u = S.top().second();
| ~~~~~~~~~~~~~~^~
a.cc:37:19: error: two consecutive '[' shall only introduce an attribute before '[' token
37 | visit[[u] =1;
| ^
a.cc: In function 'int main()':
a.cc:64:16: error: wrong number of template arguments (0, should be 2)
64 | vector<pair<>> xs;
| ^
In file included from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/stl_pair.h:89:12: note: provided for 'template<class _T1, class _T2> struct std::pair'
89 | struct pair;
| ^~~~
a.cc:64:17: error: template argument 1 is invalid
64 | vector<pair<>> xs;
| ^~
a.cc:64:17: error: template argument 2 is invalid
a.cc:64:20: error: conflicting declaration 'int xs'
64 | vector<pair<>> xs;
| ^~
a.cc:58:15: note: previous declaration as 'std::vector<std::pair<long long int, long long int> > xs'
58 | vector<P> xs(N);
| ^~
a.cc:85:43: error: no matching function for call to 'std::vector<std::vector<edge> >::vector(int&, std::vector<std::pair<long long int, long long int> >)'
85 | vector<vector<edge>> E(N, vector<P>(0));
| ^
In file included from /usr/include/c++/14/vector:66,
from /usr/include/c++/14/functional:64,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:53:
/usr/include/c++/14/bits/stl_vector.h:707:9: note: candidate: 'template<class _InputIterator, class> std::vector<_Tp, _Alloc>::vector(_InputIterator, _InputIterator, const allocator_type&) [with <template-parameter-2-2> = _InputIterator; _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >]'
707 | vector(_InputIterator __first, _InputIterator __last,
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:707:9: note: template argument deduction/substitution failed:
a.cc:85:43: note: deduced conflicting types for parameter '_InputIterator' ('int' and 'std::vector<std::pair<long long int, long long int> >')
85 | vector<vector<edge>> E(N, vector<P>(0));
| ^
/usr/include/c++/14/bits/stl_vector.h:678:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::initializer_list<_Tp>, const allocator_type&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; allocator_type = std::allocator<std::vector<edge> >]'
678 | vector(initializer_list<value_type> __l,
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:678:43: note: no known conversion for argument 1 from 'int' to 'std::initializer_list<std::vector<edge> >'
678 | vector(initializer_list<value_type> __l,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:659:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, std::__type_identity_t<_Alloc>&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; std::__type_identity_t<_Alloc> = std::allocator<std::vector<edge> >]'
659 | vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:659:23: note: no known conversion for argument 1 from 'int' to 'std::vector<std::vector<edge> >&&'
659 | vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
| ~~~~~~~~~^~~~
/usr/include/c++/14/bits/stl_vector.h:640:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, const allocator_type&, std::false_type) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; allocator_type = std::allocator<std::vector<edge> >; std::false_type = std::false_type]'
640 | vector(vector&& __rv, const allocator_type& __m, false_type)
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:640:7: note: candidate expects 3 arguments, 2 provided
/usr/include/c++/14/bits/stl_vector.h:635:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&, const allocator_type&, std::true_type) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; allocator_type = std::allocator<std::vector<edge> >; std::true_type = std::true_type]'
635 | vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:635:7: note: candidate expects 3 arguments, 2 provided
/usr/include/c++/14/bits/stl_vector.h:624:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&, std::__type_identity_t<_Alloc>&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; std::__type_identity_t<_Alloc> = std::allocator<std::vector<edge> >]'
624 | vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:624:28: note: no known conversion for argument 1 from 'int' to 'const std::vector<std::vector<edge> >&'
624 | vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
| ~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:620:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>&&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >]'
620 | vector(vector&&) noexcept = default;
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:620:7: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:601:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >]'
601 | vector(const vector& __x)
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:601:7: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:569:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(size_type, const value_type&, const allocator_type&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; size_type = long unsigned int; value_type = std::vector<edge>; allocator_type = std::allocator<std::vector<edge> >]'
569 | vector(size_type __n, const value_type& __value,
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:569:47: note: no known conversion for argument 2 from 'std::vector<std::pair<long long int, long long int> >' to 'const std::vector<std::vector<edge> >::value_type&' {aka 'const std::vector<edge>&'}
569 | vector(size_type __n, const value_type& __value,
| ~~~~~~~~~~~~~~~~~~^~~~~~~
/usr/include/c++/14/bits/stl_vector.h:556:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(size_type, const allocator_type&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; size_type = long unsigned int; allocator_type = std::allocator<std::vector<edge> >]'
556 | vector(size_type __n, const allocator_type& __a = allocator_type())
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:556:51: note: no known conversion for argument 2 from 'std::vector<std::pair<long long int, long long int> >' to 'const std::vector<std::vector<edge> >::allocator_type&' {aka 'const std::allocator<std::vector<edge> >&'}
556 | vector(size_type __n, const allocator_type& __a = allocator_type())
| ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:542:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(const allocator_type&) [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >; allocator_type = std::allocator<std::vector<edge> >]'
542 | vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:542:7: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_vector.h:531:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector() [with _Tp = std::vector<edge>; _Alloc = std::allocator<std::vector<edge> >]'
531 | vector() = default;
| ^~~~~~
/usr/include/c++/14/bits/stl_vector.h:531:7: note: candidate expects 0 arguments, 2 provided
a.cc:96:38: error: no matching function for call to 'std::vector<edge>::push_back(P&)'
96 | E[xs[i + 1].second].push_back(e2);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
/usr/include/c++/14/bits/stl_vector.h:1283:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = edge; _Alloc = std::allocator<edge>; value_type = edge]'
1283 | push_back(const value_type& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1283:35: note: no known conversion for argument 1 from 'P' {aka 'std::pair<long long int, long long int>'} to 'const std::vector<edge>::value_type&' {aka 'const edge&'}
1283 | push_back(const value_type& __x)
| ~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:1300:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(value_type&&) [with _Tp = edge; _Alloc = std::allocator<edge>; value_type = edge]'
1300 | push_back(value_type&& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1300:30: note: no known conversion for argument 1 from 'P' {aka 'std::pair<long long int, long long int>'} to 'std::vector<edge>::value_type&&' {aka 'edge&&'}
1300 | push_b |
s687018272 | p03682 | C++ |
// Problem : D - Built?
// Contest : AtCoder - AtCoder Beginner Contest 065
// URL : https://atcoder.jp/contests/abc065/tasks/arc076_b
// Memory Limit : 256 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC target("avx,avx2,fma")
#include<bits/stdc++.h>
#define eb emplace_back
#define pb push_back
#define size(s) (int)s.size()
#define int long long
#define vi vector<int>
#define vs vector<string>
#define vv vector<vector<int>>
#define pii pair<int,int>
#define m_p(x,y) make_pair(x,y)
#define vp vector<pair<int,int>>
#define setbits(x) __builtin_popcountll(x)
#define f first
#define se second
#define inc(v,n,x) v.assign(n,x)
#define incd(v,n) v.resize(n)
#define iniz(n) memset(n,0,sizeof(n))
#define inin(n) memset(n,-1,sizeof(n))
#define inimi(n) memset(n,0xc0,sizeof(n))
#define inima(n) memset(n,0x3f,sizeof(n))
#define all(v) (v).begin(),(v).end()
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream &is, vector<pair<T1,T2>> &v) { for (pair<T1,T2> &t : v) is >> t.f>>t.se; return is; }
template<typename T>istream &operator>>(istream &is, vector<T> &v) { for (T &t : v) is >> t; return is; }
template<typename T>ostream &operator<<(ostream &os, const vector<T> &v) { for (const T &t : v) {os << t <<" ";} os << '\n'; return os; }
const int N=200001;
double pi=acos(-1.0);
int md=1e9+7;
const int INF=1e15;
int dx1[]={0,0,-1,1};
int dy1[]={1,-1,0,0};
template<class T>
T abst(T a)
{return a<0?-a:a;}
template<class T>
T max2(T a,T b){return a>b?a:b;}
template<class T>
T min2(T a,T b){return a<b?a:b;}
vi dsu,size;
void init_dsu(int n)
{
incd(dsu,n+1);
incd(size,n+1);
for(int i=0;i<=n;i++)
dsu[i]=i,size[i]=1;
}
int get_par(int x)
{
if(dsu[x]==x) return x;
return dsu[x]=get_par(dsu[x]);
}
void unite(int x,int y)
{
int p1=get_par(x);
int p2=get_par(y);
if(p1!=p2)
{
size[p1]+=size[p2];
dsu[p2]=p1;
}
}
int MST(vector<pair<int,pii>> edges,int n)
{
init_dsu(n+1);
int cost=0;
sort(all(edges));
for(auto i:edges)
{
pii p=i.se;
int x=get_par(p.f);
int y=get_par(p.se);
if(x!=y)
{
//cout<<x<<" "<<y<<" "<<i.f<<"\n";
unite(x,y);
cost+=i.f;
}
}
return cost;
}
void solve()
{
int n;cin>>n;
vector<pair<int,pii>> edges;
vp v1,v2;
int point=1;
map<pii,int> mp;
for(int i=0;i<n;i++)
{
int x,y;
cin>>x>>y;
if(mp.count({x,y}))continue;
else
{
mp[{x,y}]=point++;
v1.pb({x,point-1});
v2.pb({y,point-1});
}
}
sort(all(v1));
sort(all(v2));
for(int i=0;i<n-1;i++)
{
edges.pb({v1[i+1].f-v1[i].f,{v1[i].se,v1[i+1].se}});
edges.pb({v1[i+1].f-v1[i].f,{v1[i+1].se,v1[i].se}});
}
for(int i=0;i<n-1;i++)
{
edges.pb({v2[i+1].f-v2[i].f,{v2[i].se,v2[i+1].se}});
edges.pb({v2[i+1].f-v2[i].f,{v2[i+1].se,v2[i].se}});
}
cout<<MST(edges,point);
}
int32_t main(){
ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
int t=1;
//cin>>t;
for(int i=1;i<=t;i++)
{
solve();
}
return 0;
}
| a.cc: In function 'void init_dsu(long long int)':
a.cc:60:14: error: reference to 'size' is ambiguous
60 | incd(size,n+1);
| ^~~~
a.cc:27:19: note: in definition of macro 'incd'
27 | #define incd(v,n) v.resize(n)
| ^
In file included from /usr/include/c++/14/string:53,
from /usr/include/c++/14/bitset:52,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52,
from a.cc:12:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:56:8: note: 'std::vector<long long int> size'
56 | vi dsu,size;
| ^~~~
a.cc:62:18: error: reference to 'size' is ambiguous
62 | dsu[i]=i,size[i]=1;
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:56:8: note: 'std::vector<long long int> size'
56 | vi dsu,size;
| ^~~~
a.cc: In function 'void unite(long long int, long long int)':
a.cc:77:17: error: reference to 'size' is ambiguous
77 | size[p1]+=size[p2];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:56:8: note: 'std::vector<long long int> size'
56 | vi dsu,size;
| ^~~~
a.cc:77:27: error: reference to 'size' is ambiguous
77 | size[p1]+=size[p2];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:56:8: note: 'std::vector<long long int> size'
56 | vi dsu,size;
| ^~~~
|
s265295083 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define f first
#define s second
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) FOR(i, 0, a)
#define ROF(i, a, b) for (int i = (b); i >= (a); i--)
#define R0F(i, a) ROF(i, 0, a-1)
#define trav(x, a) for (auto& x: a)
const int MX = 2e5+5;
const int MOD = 1e9+7;
const ll INF = 1061109567; // 4557430888798830399LL
const ld EPS = 1e-9;
const ld PI = acos(-1);
struct DSU {
vi e; void init(int n) { e = vi(n,-1); }
int get(int x) { return e[x] < 0 ? x : e[x] = get(e[x]); }
bool sameSet(int a, int b) { return get(a) == get(b); }
int size(int x) { return -e[get(x)]; }
bool unite(int x, int y) { // union by size
x = get(x), y = get(y); if (x == y) return 0;
if (e[x] > e[y]) swap(x,y);
e[x] += e[y]; e[y] = x; return 1;
}
};
int N; DSU DS;
vector<tuple<int,int,int>> adj;
ll Kruskal() {
sort(all(adj)); DS.init(N); ll res = 0;
trav(x,adj) {
int u,v,w; tie(w,u,v) = x;s
if (unite(u,v)) {
res += w;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin >> N;
vector<tuple<int,int,int>> v;
F0R(i,N) {
int x,y; cin >> x >> y;
v.pb(tie(x,y,i));
}
sort(all(v));
F0R(i,N-1) {
int x1,y1,ii,x2,y2,jj;
tie(x1,y1,ii) = v[i];
tie(x2,y2,jj) = v[i+1];
int cost = min(abs(x1-x2),abs(y1-y2));
adj.pb(tie(cost,ii,jj));
}
F0R(i,N) {
int x1,y1,ii;
tie(x1,y1,ii) = v[i];
v[i] = tie(y1,x2,ii);
}
sort(all(v));
F0R(i,N-1) {
int x1,y1,ii,x2,y2,jj;
tie(x1,y1,ii) = v[i];
tie(x2,y2,jj) = v[i+1];
int cost = min(abs(x1-x2),abs(y1-y2));
adj.pb(tie(cost,ii,jj));
}
cout << Kruskal() << "\n";
}
| a.cc: In function 'll Kruskal()':
a.cc:11:11: error: 'second' was not declared in this scope
11 | #define s second
| ^~~~~~
a.cc:47:35: note: in expansion of macro 's'
47 | int u,v,w; tie(w,u,v) = x;s
| ^
a.cc: In function 'int main()':
a.cc:82:23: error: 'x2' was not declared in this scope; did you mean 'x1'?
82 | v[i] = tie(y1,x2,ii);
| ^~
| x1
|
s663469887 | p03682 | Java | import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BiFunction;
public class Main {
static Scanner scn = new Scanner(System.in);
static FastScanner sc = new FastScanner();
static Mathplus mp = new Mathplus();
static PrintWriter ot = new PrintWriter(System.out);
static Random rand = new Random();
static StringManager sm = new StringManager(" ");
static long mod = 1000000007;
static long modmod = mod * mod;
static long inf = (long)1e17;
static int[] dx = {0,1,0,-1};
static int[] dy = {1,0,-1,0};
static int[] dx8 = {-1,-1,-1,0,0,1,1,1};
static int[] dy8 = {-1,0,1,-1,1,-1,0,1};
static char[] dc = {'R','D','L','U'};
static String sp = " ";
public static void main(String[] args) {
int N = sc.nextInt();
int[] x = new int[N];
int[] y = new int[N];
Graph g = new Graph(N);
for(int i=0;i<N;i++) {
x[i] = sc.nextInt();
y[i] = sc.nextInt();
}
for(int i = 0; i < N-1; i++){
for(int j = i+1; j < N; j++){
g.addWeightedEdge(i,j,Math.min(Math.abs(x[i]-x[j]), Math.abs(y[i]-y[j])));
}
}
long L = g.Kruskal();
System.out.println(L);
}
}
class UnionFindTree {
int[] root;
int[] rank;
int[] size;
int[] edge;
int num;
UnionFindTree(int N){
root = new int[N];
rank = new int[N];
size = new int[N];
edge = new int[N];
num = N;
for(int i=0;i<N;i++){
root[i] = i;
size[i] = 1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int extraEdge(int x) {
int r = find(x);
return edge[r] - size[r] + 1;
}
public int find(int x){
if(root[x]==x){
return x;
}else{
return find(root[x]);
}
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
edge[x]++;
return;
}else{
num--;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
edge[y] += edge[x]+1;
}else{
root[y] = x;
size[x] += size[y];
edge[x] += edge[y]+1;
if(rank[x]==rank[y]){
rank[x]++;
}
}
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class LightUnionFindTree {
int[] par;
int num;
LightUnionFindTree(int N){
par = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return find(par[x]);
}
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return;
}else{
num--;
if(par[x]<par[y]){
par[x] += par[y];
par[y] = x;
}else{
par[y] += par[x];
par[x] = y;
}
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class ParticalEternalLastingUnionFindTree extends UnionFindTree{
int[] time;
int now;
ParticalEternalLastingUnionFindTree(int N){
super(N);
time = new int[N];
for(int i=0;i<N;i++) {
time[i] = 1000000007;
}
}
public int find(int t,int i) {
if(time[i]>t) {
return i;
}else {
return find(t,root[i]);
}
}
public void unite(int x,int y,int t) {
now = t;
x = find(t,x);
y = find(t,y);
if(x==y)return;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
time[x] = t;
}else{
root[y] = x;
size[x] += size[y];
if(rank[x]==rank[y]){
rank[x]++;
}
time[y] = t;
}
}
public int sametime(int x,int y) {
if(find(now,x)!=find(now,y)) return -1;
int ok = now;
int ng = 0;
while(ok-ng>1) {
int mid = (ok+ng)/2;
if(find(mid,x)==find(mid,y)) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
}
class Graph {
ArrayList<Edge>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
Graph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Edge>();
}
}
public long[] dicount(int s) {
long[] L = new long[size];
long[] c = new long[size];
int mod = 1000000007;
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
c[s] = 1;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
//System.out.println(C.b +" "+ D.to);
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
c[D.to] = c[C.b];
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}else if(L[D.to]==L[C.b]+D.cost) {
c[D.to] += c[C.b];
}
c[D.to] %= mod;
}
}
}
return c;
}
public long[] roots(int s) {
int[] in = new int[size];
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
long[] N = new long[size];
long mod = 1000000007;
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
N[s] = 1;
while(!q.isEmpty()) {
int v = q.poll();
for(Edge e:list[v]) {
N[e.to] += N[v];
if(N[e.to]>=mod)N[e.to]-= mod;
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
return N;
}
void addEdge(int a,int b){
list[a].add(new Edge(b,1));
}
void addWeightedEdge(int a,int b,long c){
list[a].add(new Edge(b,c));
}
void addEgdes(int[] a,int[] b){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],1));
}
}
void addWeightedEdges(int[] a ,int[] b ,int[] c){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],c[i]));
}
}
long[] bfs(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
long[][] bfswithrev(int s){
long[][] L = new long[2][size];
for(int i=0;i<size;i++){
L[0][i] = -1;
L[1][i] = -1;
}
L[0][s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[0][w]==-1){
L[0][w] = L[0][v] + c;
L[1][w] = v;
Q.add(w);
}
}
}
return L;
}
long[] bfs2(int[] d,int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int p = 0;
L[s] = 0;
d[s] = p;
p++;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
d[w] = p;
p++;
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
boolean bfs3(int s,long[] L, int[] vi){
if(vi[s]==1) return true;
vi[s] = 1;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(vi[e.to]==0) {
L[e.to] = (int)c - L[v];
Q.add(w);
vi[e.to] = 1;
}else {
if(L[e.to]!=(int)c - L[v]) {
return false;
}
}
}
}
return true;
}
int[] isTwoColor(){
int[] L = new int[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[0] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(0);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
return L;
}
void isTwoColor2(int i,int[] L){
L[i] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
}
long[] dijkstra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}
}
}
}
return L;
}
public long[] dijkstra2(int s, long mid) {
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
int lg = 1000000007;
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
if((L[D.to]==-1||L[D.to]>L[C.b]+D.cost%lg)&&L[C.b]+D.cost/lg<=mid) {
L[D.to]=L[C.b]+D.cost%lg;
Q.add(new LongIntPair(L[C.b]+D.cost%lg,D.to));
}
}
}
}
return L;
}
ArrayList<Graph> makeapart(){
ArrayList<Graph> ans = new ArrayList<Graph>();
boolean[] b = new boolean[size];
int[] num = new int[size];
for(int i=0;i<size;i++){
if(b[i])continue;
int sz = 0;
ArrayList<Integer> l = new ArrayList<Integer>();
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
b[i] = true;
while(!Q.isEmpty()){
int v = Q.poll();
num[v] = sz;
sz++;
l.add(v);
for(Edge e:list[v]){
if(!b[e.to]){
Q.add(e.to);
b[e.to] = true;
}
}
}
Graph H = new Graph(sz);
for(int e:l){
for(Edge E:list[e]){
H.addWeightedEdge(num[e],num[E.to],E.cost);
}
}
ans.add(H);
}
return ans;
}
long[] bellmanFord(int s) {
long inf = 1000000000;
inf *= inf;
long[] d = new long[size];
boolean[] n = new boolean[size];
d[s] = 0;
for(int i=1;i<size;i++){
d[i] = inf;
d[i] *= d[i];
}
for(int i=0;i<size-1;i++){
for(int j=0;j<size;j++){
for(Edge E:list[j]){
if(d[j]!=inf&&d[E.to]>d[j]+E.cost){
d[E.to]=d[j]+E.cost;
}
}
}
}
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
for(Edge e:list[j]){
if(d[j]==inf) continue;
if(d[e.to]>d[j]+e.cost) {
d[e.to]=d[j]+e.cost;
n[e.to] = true;
}
if(n[j])n[e.to] = true;
}
}
}
for(int i=0;i<size;i++) {
if(n[i])d[i] = inf;
}
return d;
}
long[][] WarshallFloyd(long[][] a){
int n = a.length;
long[][] ans = new long[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = a[i][j]==0?(long)1e16:a[i][j];
if(i==j)ans[i][j]=0;
}
}
for(int k=0;k<n;k++) {
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = Math.min(ans[i][j],ans[i][k]+ans[k][j]);
}
}
}
return ans;
}
long[] maxtra(int s,long l){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = -1;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator());
Q.add(new Pair(l,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.max(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long[] mintra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = s;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator().reversed());
Q.add(new Pair(s,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.min(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long Kruskal(){
long r = 0;
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
Edges.add(new LinkEdge(e.cost,i,e.to));
}
}
UnionFindTree UF = new UnionFindTree(size);
for(LinkEdge e:Edges){
if(e.a>=0&&e.b>=0) {
if(!UF.same(e.a,e.b)){
//System.out.println("a : " + e.a + " b : " + e.b + " c : " + e.L);
r += e.L;
UF.unite(e.a,e.b);
}
}
}
return r;
}
ArrayList<Integer> Kahntsort(){
ArrayList<Integer> ans = new ArrayList<Integer>();
PriorityQueue<Integer> q = new PriorityQueue<Integer>();
int[] in = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
while(!q.isEmpty()) {
int v = q.poll();
ans.add(v);
for(Edge e:list[v]) {
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
for(int i=0;i<size;i++) {
if(in[i]>0)return new ArrayList<Integer>();
}
return ans;
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
for(Edge e:list[i]) {
if(f[e.to]) continue;
if(v[e.to]&&!f[e.to]) {
return true;
}
if(findCycle(e.to,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
RootedTree dfsTree(int i) {
int[] u = new int[size];
RootedTree r = new RootedTree(size);
dfsTree(i,u,r);
return r;
}
private void dfsTree(int i, int[] u, RootedTree r) {
u[i] = 1;
for(Edge e:list[i]) {
if(u[e.to]==0) {
r.list[i].add(e);
u[e.to] = 1;
dfsTree(e.to,u,r);
}
}
}
}
class Tree extends Graph{
int[] trans;
public Tree(int N) {
super(N);
}
long[] tyokkei(){
long[] a = bfs(0);
int md = -1;
long m = 0;
for(int i=0;i<size;i++){
if(m<a[i]){
m = a[i];
md = i;
}
}
long[] b = bfs(md);
int md2 = -1;
long m2 = 0;
for(int i=0;i<size;i++){
if(m2<b[i]){
m2 = b[i];
md2 = i;
}
}
long[] r = {m2,md,md2};
return r;
}
}
class RootedTree extends Graph{
RootedTree(int N){
super(N);
}
}
class LinkEdge{
long L;
int a ;
int b;
int id;
LinkEdge(long l,int A,int B){
L = l;
a = A;
b = B;
}
LinkEdge(long l,int A,int B,int i){
L = l;
a = A;
b = B;
id = i;
}
public boolean equals(Object o){
LinkEdge O = (LinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.L==this.L;
}
public int hashCode(){
return Objects.hash(L,a,b);
}
}
class DoubleLinkEdge{
double D;
int a;
int b;
DoubleLinkEdge(double d,int A,int B){
D = d;
a = A;
b = B;
}
public boolean equals(Object o){
DoubleLinkEdge O = (DoubleLinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.D==this.D;
}
public int hashCode(){
return Objects.hash(D,a,b);
}
}
class Edge{
int to;
long cost;
Edge(int a,long b){
to = a;
cost = b;
}
}
class DoubleLinkEdgeComparator implements Comparator<DoubleLinkEdge>{
public int compare(DoubleLinkEdge P, DoubleLinkEdge Q) {
return Double.compare(P.D,Q.D);
}
}
class LinkEdgeComparator implements Comparator<LinkEdge>{
public int compare(LinkEdge P, LinkEdge Q) {
return Long.compare(P.L,Q.L);
}
}
class Pair{
long a;
long b;
Pair(long p,long q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class SampleComparator implements Comparator<Pair>{
public int compare(Pair P, Pair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b==Q.b)return 0;
return P.b>Q.b?1:-1;
}
return t>=0?1:-1;
}
}
class LongIntPair{
long a;
int b;
LongIntPair(long p,int q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
LongIntPair O = (LongIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class LongIntComparator implements Comparator<LongIntPair>{
public int compare(LongIntPair P, LongIntPair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b>Q.b){
return 1;
}else{
return -1;
}
}
return t>=0?1:-1;
}
}
class IntIntPair{
int a;
int b;
IntIntPair(int p,int q){
this.a = p;
this.b = q;
}
IntIntPair(int p,int q,String s){
if(s.equals("sort")) {
this.a = Math.min(p,q);
this.b = Math.max(p,q);
}
}
public boolean equals(Object o){
IntIntPair O = (IntIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class IntIntComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.a-Q.a;
if(t==0){
return P.b-Q.b;
}
return t;
}
}
class CIPair{
char c;
int i;
CIPair(char C,int I){
c = C;
i = I;
}
public boolean equals(Object o){
CIPair O = (CIPair) o;
return O.c==this.c&&O.i==this.i;
}
public int hashCode(){
return Objects.hash(c,i);
}
}
class DoublePair{
double a;
double b;
DoublePair(double p,double q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
DoublePair O = (DoublePair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class Triplet{
long a;
long b;
long c;
Triplet(long p,long q,long r){
a = p;
b = q;
c = r;
}
public boolean equals(Object o){
Triplet O = (Triplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class TripletComparator implements Comparator<Triplet>{
public int compare(Triplet P, Triplet Q) {
long t = P.a-Q.a;
if(t==0){
long tt = P.b-Q.b;
if(tt==0) {
if(P.c>Q.c) {
return 1;
}else if(P.c<Q.c){
return -1;
}else {
return 0;
}
}
return tt>0?1:-1;
}
return t>=0?1:-1;
}
}
class DDComparator implements Comparator<DoublePair>{
public int compare(DoublePair P, DoublePair Q) {
return P.a-Q.a>=0?1:-1;
}
}
class DoubleTriplet{
double a;
double b;
double c;
DoubleTriplet(double p,double q,double r){
this.a = p;
this.b = q;
this.c = r;
}
public boolean equals(Object o){
DoubleTriplet O = (DoubleTriplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class DoubleTripletComparator implements Comparator<DoubleTriplet>{
public int compare(DoubleTriplet P, DoubleTriplet Q) {
if(P.a==Q.a) return 0;
return P.a-Q.a>0?1:-1;
}
}
class FastScanner {
private final java.io.InputStream in = System.in;
private final byte[] b = new byte[1024];
private int p = 0;
private int bl = 0;
private boolean hNB() {
if (p<bl) {
return true;
}else{
p = 0;
try {
bl = in.read(b);
} catch (IOException e) {
e.printStackTrace();
}
if (bl<=0) {
return false;
}
}
return true;
}
private int rB() { if (hNB()) return b[p++]; else return -1;}
private static boolean iPC(int c) { return 33 <= c && c <= 126;}
private void sU() { while(hNB() && !iPC(b[p])) p++;}
public boolean hN() { sU(); return hNB();}
public String next() {
if (!hN()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = rB();
while(iPC(b)) {
sb.appendCodePoint(b);
b = rB();
}
return sb.toString();
}
public char nextChar() {
return next().charAt(0);
}
public long nextLong() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b=='-') {
m=true;
b=rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b - '0';
}else if(b == -1||!iPC(b)){
return (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int nextInt() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b == '-') {
m = true;
b = rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b-'0';
}else if(b==-1||!iPC(b)){
return (int) (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int[] nextInts(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = nextInt();
}
return a;
}
public int[] nextInts(int n,int s) {
int[] a = new int[n+s];
for(int i=s;i<n+s;i++) {
a[i] = nextInt();
}
return a;
}
public long[] nextLongs(int n) {
long[] a = new long[n];
for(int i=0;i<n;i++) {
a[i] = nextLong();
}
return a;
}
public int[][] nextIntses(int n,int m){
int[][] a = new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j] = nextInt();
}
}
return a;
}
void nextIntses(int n,int[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextInt();
}
}
}
void nextLongses(int n,long[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextLong();
}
}
}
Graph nextyukoGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
}
return G;
}
Graph nextGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
G.addEdge(b,a);
}
return G;
}
Graph nextWeightedGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
long c = nextLong();
G.addWeightedEdge(a,b,c);
G.addWeightedEdge(b,a,c);
}
return G;
}
Tree nextTree(int n) {
Tree T = new Tree(n);
for(int i=0;i<n-1;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
T.addEdge(a,b);
T.addEdge(b,a);
}
return T;
}
}
class Mathplus{
long mod = 1000000007;
long[] fac;
long[] revfac;
long[][] comb;
long[] pow;
long[] revpow;
boolean isBuild = false;
boolean isBuildc = false;
boolean isBuildp = false;
int mindex = -1;
int maxdex = -1;
int graydiff = 0;
int graymark = 0;
int color(int[][] diff,int N) {
int[] val = new int[1<<N];
val[0] = 1;
for(int i=0;i<(1<<N);i++) {
for(int j=0;j<N;j++) {
if(contains(i,j)) {
if(val[bitremove(i,j)]==1) {
boolean b = true;
for(int k=0;k<N;k++) {
if(contains(i,k)&&diff[j][k]==1) {
b = false;
}
}
if(b)val[i] = 1;
}
break;
}
}
}
int[] dp = new int[1<<N];
Arrays.fill(dp,N+1);;
dp[0] = 0;
for(int i=0;i<(1<<N);i++) {
for(int j=i;j>0;j=(j-1)&i) {
if(val[j]==1)dp[i]=Math.min(dp[i],dp[i^j]+1);
}
}
return dp[(1<<N)-1];
}
public void timeout() throws InterruptedException {
Thread.sleep(10000);
}
public int gray(int i) {
for(int j=0;j<20;j++) {
if(contains(i,j)) {
graydiff = j;
if(contains(i,j+1))graymark=-1;
else graymark = 1;
break;
}
}
return i ^ (i>>1);
}
public void hakidashi(long[] A) {
Arrays.sort(A);
int N = A.length;
int[] index = new int[61];
for(int i=0;i<=60;i++){
index[i] = -1;
}
int searching = 60;
int [] used = new int[N];
while(searching>=0){
boolean b = true;
for(int i=N-1;i>=0;i--){
for(int j=60;j>searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
//System.out.println(i+" changed by " + index[j]);
//System.out.println(A[i]);
}
}
}
if((A[i]>>searching&1)==1&&used[i]==0){
//System.out.println("find " + searching+" is "+i);
index[searching] = i;
searching--;
used[i] = 1;
b = false;
if(searching==-1){
searching = 0;
}
}
}
if(b){
searching--;
}
}
for(int i=N-1;i>=0;i--){
for(int j=60;j>=searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
}
}
}
}
Arrays.sort(A);
}
public void printjudge(boolean b, String y, String n) {
System.out.println(b?y:n);
}
public void printYN(boolean b) {
printjudge(b,"Yes","No");
}
public void printyn(boolean b) {
printjudge(b,"yes","no");
}
public void reverse(int[] x) {
int[] r = new int[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public void reverse(long[] x) {
long[] r = new long[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public DoubleTriplet Line(double x1,double y1,double x2,double y2) {
double a = y1-y2;
double b = x2-x1;
double c = x1*y2-x2*y1;
return new DoubleTriplet(a,b,c);
}
public double putx(DoubleTriplet T,double x) {
return -(T.a*x+T.c)/T.b;
}
public double puty(DoubleTriplet T,double y) {
return -(T.b*y+T.c)/T.a;
}
public double Distance(DoublePair P,DoublePair Q) {
return Math.sqrt((P.a-Q.a) * (P.a-Q.a) + (P.b-Q.b) * (P.b-Q.b));
}
public double DistanceofPointandLine(DoublePair P,Triplet T) {
return Math.abs(P.a*T.a+P.b*T.b+T.c) / Math.sqrt(T.a*T.a+T.b*T.b);
}
public boolean cross(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
public boolean dcross(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
void buildFac(){
fac = new long[10000003];
revfac = new long[10000003];
fac[0] = 1;
for(int i=1;i<=10000002;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[10000002] = rev(fac[10000002])%mod;
for(int i=10000001;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
void buildFacn(int n){
fac = new long[n+1];
revfac = new long[n+1];
fac[0] = 1;
for(int i=1;i<=n;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[n] = rev(fac[n])%mod;
for(int i=n-1;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
public long[] buildrui(int[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public int[][] ibuildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
int[][] ans = new int[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public void buildruin(int[][] a) {
int n = a.length;
int m = a[0].length;
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
a[i][j] += a[i][j-1] + a[i-1][j] - a[i-1][j-1];
}
}
}
public long[][] buildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
long[][] ans = new long[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public int getrui(int[][] r,int a,int b,int c,int d) {
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
public long getrui(long[][] r,int a,int b,int c,int d) {
if(a<0||b<0||c>=r.length||d>=r[0].length) return mod;
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
long divroundup(long n,long d) {
if(n==0)return 0;
return (n-1)/d+1;
}
public long sigma(long i) {
return i*(i+1)/2;
}
public int digit(long i) {
int ans = 1;
while(i>=10) {
i /= 10;
ans++;
}
return ans;
}
public int digitsum(long n) {
int ans = 0;
while(n>0) {
ans += n%10;
n /= 10;
}
return ans;
}
public int popcount(int i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public boolean contains(int S,int i) {return (S>>i&1)==1;}
public int bitremove(int S,int i) {return S&(~(1<<i));}
public int bitadd(int S,int i) {return S|(1<<i);}
public boolean isSubSet(int S,int T) {return (S-T)==(S^T);}
public boolean isDisjoint(int S,int T) {return (S+T)==(S^T);}
public boolean contains(long S,int i) {return (S>>i&1)==1;}
public long bitremove(long S,int i) {return S&(~(1<<i));}
public long bitadd(long S,int i) {return S|(1<<i);}
public boolean isSubSet(long S,long T) {return (S-T)==(S^T);}
public boolean isDisjoint(long S,long T) {return (S+T)==(S^T);}
public int isBigger(int[] d, int i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(int[] d, int i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(long[] d, long i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(long[] d, long i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Long> d, long i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Long> d, long i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public HashSet<Integer> primetable(int m) {
HashSet<Integer> pt = new HashSet<Integer>();
for(int i=2;i<=m;i++) {
boolean b = true;
for(int d:pt) {
if(i%d==0) {
b = false;
break;
}
}
if(b) {
pt.add(i);
}
}
return pt;
}
public ArrayList<Integer> primetablearray(int m) {
ArrayList<Integer> al = new ArrayList<Integer>();
Queue<Integer> q = new ArrayDeque<Integer>();
for(int i=2;i<=m;i++) {
q.add(i);
}
boolean[] b = new boolean[m+1];
while(!q.isEmpty()) {
int e = q.poll();
if(!b[e]) {
al.add(e);
for(int j=1;e*j<=1000000;j++) {
b[e*j] = true;
}
}
}
return al;
}
public boolean isprime(int e) {
if(e==1) return false;
for(int i=2;i*i<=e;i++) {
if(e%i==0) return false;
}
return true;
}
public MultiSet Factrization(int e) {
MultiSet ret = new MultiSet();
for(int i=2;i*i<=e;i++) {
while(e%i==0) {
ret.add(i);
e /= i;
}
}
if(e!=1)ret.add(e);
return ret;
}
public HashMap<Integer,Integer> hipPush(ArrayList<Integer> l){
HashMap<Integer,Integer> r = new HashMap<Integer,Integer>();
TreeSet<Integer> s = new TreeSet<Integer>();
for(int e:l)s.add(e);
int p = 0;
for(int e:s) {
r.put(e,p);
p++;
}
return r;
}
public TreeMap<Integer,Integer> thipPush(ArrayList<Integer> l){
TreeMap<Integer,Integer> r = new TreeMap<Integer,Integer>();
Collections.sort(l);
int b = -(1000000007+9393);
int p = 0;
for(int e:l) {
if(b!=e) {
r.put(e,p);
p++;
}
b=e;
}
return r;
}
int[] count(int[] a) {
int[] c = new int[max(a)+1];
for(int i=0;i<a.length;i++) {
c[a[i]]++;
}
return c;
}
long max(long[] a){
long M = Long.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
int max(int[] a){
int M = Integer.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
long min(long[] a){
long m = Long.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
int min(int[] a){
int m = Integer.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
long sum(long[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(int[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long gcd(long a, long b){
a = Math.abs(a);
b = Math.abs(b);
if(a==0)return b;
if(b==0)return a;
if(a%b==0) return b;
else return gcd(b,a%b);
}
int igcd(int a, int b) {
if(a%b==0) return b;
else return igcd(b,a%b);
}
long lcm(long a, long b) {return a / gcd(a,b) * b;}
public long perm(int a,int num) {
if(!isBuild)buildFac();
return fac[a]*(rev(fac[a-num]))%mod;
}
void buildComb(int N) {
comb = new long[N+1][N+1];
comb[0][0] = 1;
for(int i=1;i<=N;i++) {
comb[i][0] = 1;
for(int j=1;j<N;j++) {
comb[i][j] = comb[i-1][j-1]+comb[i-1][j];
if(comb[i][j]>mod)comb[i][j]-=mod;
}
comb[i][i] = 1;
}
}
public long comb(int a,int num){
if(a-num<0)return 0;
if(num<0)return 0;
if(!isBuild)buildFac();
return fac[a] * ((revfac[num]*revfac[a-num])%mod)%mod;
}
long mulchoose(int n,int k) {
if(k==0) return 1;
return comb(n+k-1,k);
}
long rev(long l) {return pow(l,mod-2);}
void buildpow(int l,int i) {
pow = new long[i+1];
pow[0] = 1;
for(int j=1;j<=i;j++) {
pow[j] = pow[j-1]*l;
if(pow[j]>mod)pow[j] %= mod;
}
}
void buildrevpow(int l,int i) {
revpow = new long[i+1];
revpow[0] = 1;
for(int j=1;j<=i;j++) {
revpow[j] = revpow[j-1]*l;
if(revpow[j]>mod) revpow[j] %= mod;
}
}
long pow(long l, long i) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow(l,i/2);
return val * val % mod;
}
else return pow(l,i-1) * l % mod;
}
}
long mon(int i) {
long ans = 0;
for(int k=2;k<=i;k++) {
ans += (k%2==0?1:-1) * revfac[k];
ans += mod;
}
ans %= mod;
ans *= fac[i];
return ans%mod;
}
long dictnum(int[] A) {
int N = A.length;
long ans = 0;
BinaryIndexedTree bit = new BinaryIndexedTree(N+1);
buildFacn(N);
for(int i=1;i<=N;i++) {
bit.add(i,1);
}
for(int i=1;i<=N;i++) {
int a = A[i-1];
ans += bit.sum(a-1) * fac[N-i] % mod;
bit.add(a,-1);
}
return (ans+1)%mod;
}
}
| Main.java:27: error: cannot find symbol
static StringManager sm = new StringManager(" ");
^
symbol: class StringManager
location: class Main
Main.java:1681: error: cannot find symbol
public MultiSet Factrization(int e) {
^
symbol: class MultiSet
location: class Mathplus
Main.java:27: error: cannot find symbol
static StringManager sm = new StringManager(" ");
^
symbol: class StringManager
location: class Main
Main.java:1682: error: cannot find symbol
MultiSet ret = new MultiSet();
^
symbol: class MultiSet
location: class Mathplus
Main.java:1682: error: cannot find symbol
MultiSet ret = new MultiSet();
^
symbol: class MultiSet
location: class Mathplus
Main.java:1856: error: cannot find symbol
BinaryIndexedTree bit = new BinaryIndexedTree(N+1);
^
symbol: class BinaryIndexedTree
location: class Mathplus
Main.java:1856: error: cannot find symbol
BinaryIndexedTree bit = new BinaryIndexedTree(N+1);
^
symbol: class BinaryIndexedTree
location: class Mathplus
7 errors
|
s449560456 | p03682 | C++ | /*temp*/
//
//
//
//
//#undef _DEBUG
//#pragma GCC optimize("Ofast")
//不動小数点の計算高速化
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#include <boost/multiprecision/cpp_int.hpp>
#ifdef _DEBUG
#include "template.h"
#else
#if __cplusplus >= 201703L
/*Atcoderでしか使えない(c++17 && このテンプレートが使えるならAtcoder)*/
#include <boost/sort/pdqsort/pdqsort.hpp>
#define fast_sort boost::sort::pdqsort
#endif
#endif
#ifndef _DEBUG
#ifndef UNTITLED15_TEMPLATE_H
#define UNTITLED15_TEMPLATE_H
#ifdef _DEBUG
#include "bits_stdc++.h"
#else
#include <bits/stdc++.h>
#endif
#ifndef fast_sort
#define fast_sort sort
#endif
//#define use_pq
#define use_for
#define use_for_each
#define use_sort
#define use_fill
#define use_rand
#define use_mgr
#define use_rui
#define use_compress
//
//
//
//
//
//
#define use_pbds
#ifdef use_pbds
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template<class T, class U, class W, class X> auto count(__gnu_pbds::gp_hash_table<T, U, W> &a, X k) { return a.find(k) != a.end(); }
#endif
using namespace std;
using namespace std::chrono;
/*@formatter:off*/
#define ll long long
using sig_dou = double;
//マクロ省略形 関数等
#define arsz(a) (sizeof(a)/sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define mt make_tuple
#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()
template<class T,class U> auto max(T a, U b){return a>b ? a: b;}
template<class T,class U> auto min(T a, U b){return a<b ? a: b;}
//optional<T>について下でオーバーロード(nullopt_tを左辺右辺について単位元として扱う)
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;}
//メタ系 meta
template<typename T, typename U = typename T::value_type>std::true_type value_type_tester(signed);
template<typename T>std::false_type value_type_tester(long);
template<typename T>struct has_value_type: decltype(value_type_tester<T>(0)){};
//A<T>でTを返す
template<class T>using decl_t = typename T::value_type;
//A<B<.....T>>でTを返す
template<class T, bool end = !has_value_type<T>::value> struct decl2_ {typedef T type;};
template<class T> struct decl2_<T, false> {typedef typename decl2_<decl_t<T>>::type type;};
template<class T> using decl2_t = typename decl2_<T>::type;
//#define decl_max(a, b) decltype(max(MAX<decltype(a)>(), MAX<decltype(b)>()))
#define is_same2(T, U) is_same<T, U>::value
template<class T>struct is_vector : std::false_type{};
template<class T>struct is_vector<std::vector<T>> : std::true_type{};
//大きい型を返す max_type<int, char>::type
//todo mintがlong long より小さいと判定されるためバグる
template<class T1, class T2, bool t1_bigger = (sizeof(T1) > sizeof(T2))>struct max_type{typedef T1 type;};
template<class T1, class T2> struct max_type<T1, T2, false>{typedef T2 type;};
template<class T> struct vec_rank : integral_constant<int, 0> {};
template<class T> struct vec_rank<vector<T>> : integral_constant<int, vec_rank<T>{} + 1> {};
//N個のTを並べたtupleを返す
//tuple_n<3, int>::type tuple<int, int, int>
template<size_t N, class T, class... Arg> struct tuple_n{typedef typename tuple_n<N-1, T, T, Arg...>::type type;};
template<class T, class...Arg> struct tuple_n<0, T, Arg...>{typedef tuple<Arg...> type;};
struct dummy_t1{};struct dummy_t2{};
struct dummy_t3{};struct dummy_t4{};
struct dummy_t5{};struct dummy_t6{};
//template<class T, require(is_integral<T>::value)>など
#define require_t(bo) enable_if_t<bo>* = nullptr
//複数でオーバーロードする場合、引数が同じだとうまくいかないため
//require_arg(bool, dummy_t1)
//require_arg(bool, dummy_t2)等とする
#define require_arg1(bo) enable_if_t<bo> * = nullptr
#define require_arg2(bo, dummy_type) enable_if_t<bo, dummy_type> * = nullptr
#define require_arg(...) over2(__VA_ARGS__,require_arg2,require_arg1)(__VA_ARGS__)
//->//enable_if_tのtを書き忘れそうだから
#define require_ret(bo, ret_type) enable_if_t<bo, ret_type>
#define int long long //todo 消したら動かない intの代わりにsignedを使う
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) # VariableName
//最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#ifdef _DEBUG
string message;
string res_mes;
bool was_deb = false;
[[ noreturn ]]
void my_exit(signed e = 0) {
if (was_deb && sz(res_mes)) {
cerr << "result = " << endl << res_mes << endl;
}
if (sz(message)) {
cerr << "****************************" << endl;
cerr << "Note." << endl;
cerr << message << endl;
cerr << "****************************" << endl;
}
exit(e);
}
#define exit my_exit
#endif
void assert2(bool b,const string& s = ""){ if(!b){ cerr<<s<<endl; exit(1);/*assert(0);*/ }}
//my_nulloptをあらゆる操作の単位元的な物として扱う
//vectorの参照外時に返したり、右辺値として渡されたときに何もしないなど
struct my_nullopt_t {} my_nullopt;
#define nullopt_t my_nullopt_t
#define nullopt my_nullopt
/*@formatter:off*/
//値が無いときは、setを使わない限り代入できない
//=を使っても無視される
template<class T> struct my_optional {
private:
bool is_null;
T v;
public:
typedef T value_type ;
my_optional() : is_null(true) {}
my_optional(const nullopt_t&) : is_null(true) {}
my_optional(const T& v) : v(v), is_null(false) {}
bool has_value() const { return !is_null; }
T &value() { static string mes = "optional has no value";assert2(!is_null, mes);return v;}
const T &value() const { static string mes = "optional has no value";assert2(!is_null, mes);return v;}
void set(const T &nv) {is_null = false;v = nv;}
template<class U> void operator=(const U &v) {
set(v);//null状態でも代入出来るようにした
// if (has_value())value() = v; else return;
}
template<class U> void operator=(const my_optional<U> &v) {
if (/*has_value() && */v.has_value())(*this) = v; else return;
}
/*@formatter:off*/
void reset() { is_null = true; }
void operator=(const nullopt_t &) { reset(); }
template<require_t(!is_same2(T, bool))>
explicit operator bool(){return !is_null;}
//nullの時はエラー
operator T&(){return value();}
operator const T&()const {return value();}
my_optional<T> operator++() { if (this->has_value()) { this->value()++; return *this; } else { return *this; } }
my_optional<T> operator++(signed) { if (this->has_value()) { auto tem = *this; this->value()++; return tem; } else { return *this; } }
my_optional<T> operator--() { if (this->has_value()) { this->value()--; return *this; } else { return *this; } }
my_optional<T> operator--(signed) { if (this->has_value()) { auto tem = *this; this->value()--; return tem; } else { return *this; } }
};
template<class T>istream &operator>>(istream &iss, my_optional<T>& v) { T val; iss>>val; v.set(val); return iss;}
#define optional my_optional
template<class T>
using opt = my_optional<T>;
//template<class T, class A = std::allocator<T>> struct debtor : std::vector<T, A> {
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T> >>
struct o_map : std::map<Key, optional<T>, Compare, Allocator> {
optional<T> emp;
o_map() : std::map<Key, optional<T>, Compare, Allocator>() {}
auto operator()(const nullopt_t&) {return nullopt;}
optional<T> &operator()(const optional<Key> &k) {if (k.has_value()) {return std::map<Key, optional<T>, Compare, Allocator>::operator[](k.value());} else {emp.reset();return emp;}}
optional<T> &operator()(const Key &k) { auto &v = std::map<Key, optional<T>, Compare, Allocator>::operator[](k); if (v.has_value())return v; else { v.set(0); return v; } }
template<class U> void operator[](U){static string mes = "s_map cant []";assert2(0, mes);}
};
//以下、空のoptionalをnulloptと書く
//ov[-1(参照外)] でnulloptを返す
//ov[nullopt] で nulloptをかえす
template<class T> struct ov{
optional<T> emp;
vector<optional<T>> v;
ov(int i = 0, T val = 0):v(i, val){}
template<class U>ov(const U& rhs){v.resize(sz(rhs));for (int i = 0; i < sz(rhs); i ++)v[i].set(rhs[i]);}
optional<T> &operator()(int i) {if (i < 0 || sz(v) <= i) {emp.reset();return emp;} else { return v[i]; }}
optional<T> &operator()(const nullopt_t &) { return operator()(-1); }
optional<T> &operator()(const optional<T> &i) { if (i.has_value())return operator()(i.value()); else { return operator()(-1); } }
/*@formatter:off*/
};
template<class T>string deb_tos(const ov<T>& v){
return deb_tos(v.v);
}
//vectorに対しての処理は.vを呼ぶ
template<class T> class ovv{
optional<T> emp;
public:
vector<vector<optional<T>> > v ;
ovv(int i=0, int j=0, T val = 0) : v(i, vector<optional<T>>(j, val) ){}
ovv(const vector<vector<T> >& S){
v.resize(S.size());
for (int h = 0; h < sz(S); h++){
v[h].resize(sz(S[h]));
for (int w = 0; w < sz(S[h]); w++){
v[h][w].set(S[h][w]);
}
}
}
optional<T> &operator()(int i, int j) { if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) { emp.reset();return emp; } else { return v[i][j]; } }
//再帰ver 遅いと思う
// optional<T>& gets(optional<T>& v){return v;}
// template<class V, class H, class... U> optional<T>& gets(V& v, H i, U... tail){ if constexpr(is_same2(H, nullopt_t))return operator()(-1,-1); else if constexpr(is_same2(H, optional<int>)){ if(i.has_value())return gets(v[(int)i], tail...); else return operator()(-1,-1); }else if constexpr(is_integral<H>::value){ return gets(v[(int)i], tail...); }else{ assert(0); return emp; } }
#if __cplusplus >= 201703L
//if constexprバージョン 上が遅かったらこれで
template<class U, class V> optional<T> &operator()(const U &i, const V &j) { /*駄目な場合を除外*/ if constexpr(is_same2(U, nullopt_t) || is_same2(U, nullopt_t)) { return operator()(-1, -1); /* o, o*/ } else if constexpr(is_same2(U, optional<int>) && is_same2(V, optional<int>)) { return operator()(i.has_value() ? (int) i : -1, j.has_value() ? (int) j : -1); /* o, x*/ } else if constexpr(is_same2(U, optional<int>)) { return operator()(i.has_value() ? (int) i : -1, (int) j); /* x, o*/ } else if constexpr(is_same2(V, optional<int>)) { return operator()((int) i, j.has_value() ? (int) j : -1); /* x, x*/ } else { return operator()((int) i, (int) j); } }
#endif
operator const vector<vector<optional<T>> >&(){
return v;
}
};
template<class T>istream &operator>>(istream &iss, ovv<T> &a) { for (int h = 0; h < sz(a); h ++){ for (int w = 0; w < sz(a[h]); w ++){ iss>>a.v[h][w ]; } } return iss;}
template<class T>ostream &operator<<(ostream &os, ovv<T>& a) {
os << a.v;
return os;
}
template<class T>string deb_tos(const ovv<T>& v){
return deb_tos(v.v);
}
template<class T> struct ov3{
optional<T> emp;
vector<vector<vector<optional<T>>> > v ;
ov3(int i, int j, int k, T val = 0) : v(i, vector<vector<optional<T>>>(j, vector<optional<T>>(k, val) ) ){}
optional<T> &operator()(int i, int j, int k) { if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) { if(k < 0 || sz(v[i][j]) <= k){ emp.reset(); return emp; } } return v[i][j][k]; }
private:
#if __cplusplus >= 201703L
//再帰ver 遅いと思う
template<class V, class H> optional<T> &gets(V &nowv, H i) { if constexpr(is_same2(H, nullopt_t)) { emp.reset(); return emp; } else if constexpr(is_same2(H, optional<int>)) { if (i.has_value()) { return nowv[(int) i]; } else { emp.reset();return emp; } } else if constexpr(is_integral<H>::value) { return nowv[(int) i]; } else { static string mes = "ov3 error not index";assert2(0, mes); emp.reset();return emp; } }
//todo const &消した
template<class V, class H, class... U> optional<T> &gets(V &nowv, H i, U... tail) { if constexpr(is_same2(H, nullopt_t)) { emp.reset();return emp; } else if constexpr(is_same2(H, optional<int>)) { if (i.has_value()) { return gets(nowv[(int) i], tail...); } else { emp.reset();return emp; } } else if constexpr(is_integral<H>::value) { return gets(nowv[(int) i], tail...); } else { static string mes = "ov3 error not index";assert2(0, mes); emp.reset();return emp; } }
#endif
public:
template<class U, class V, class W> optional<T> &operator()(U i, V j, W k) { return gets(v, i, j, k); }
/*@formatter:off*/
};
template<class T>string deb_tos(const ov3<T>& v){
return deb_tos(v.v);
}
//nullopt_t
//優先順位
//null, [opt, tem]
// + と += は違う意味を持つ
//val+=null : val
//val+null : null
//
//+は途中計算
//+=は最終的に格納したい値にだけ持たせる
//+=がvoidを返すのは、途中計算で使うのを抑制するため
//nulloptを考慮する際、計算途中では+を使ってnulloptを作り
//格納する際は+=で無効にする必要がある
//演算子==
//optional<int>(10) == 10
//全ての型に対応させ、value_typeが等しいかを見るようにするのもありかも
//null同士を比較する状況はおかしいのではないか
bool operator==(const nullopt_t &, const nullopt_t&){assert2(0, "nul == null cant hikaku");return false;}
template<class T> bool operator==(const nullopt_t &, const T&){return false;}
template<class T> bool operator!=(const nullopt_t &, const T&){return true;}
template<class T> bool operator==(const T&, const nullopt_t &){return false;}
template<class T> bool operator!=(const T&, const nullopt_t &){return true;}
//nullを
nullopt_t& operator +(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator -(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator *(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator /(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator +=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator -=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator *=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator /=(const nullopt_t &, const nullopt_t&) {return nullopt;}
template<class ANY> nullopt_t operator+(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator-(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator*(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator/(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator+(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator-(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator*(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator/(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> void operator+=(nullopt_t &, const ANY &) {}
template<class ANY> void operator-=(nullopt_t &, const ANY &) {}
template<class ANY> void operator*=(nullopt_t &, const ANY &) {}
template<class ANY> void operator/=(nullopt_t &, const ANY &) {}
template<class ANY> void operator+=(ANY &, const nullopt_t &) {}
template<class ANY> void operator-=(ANY &, const nullopt_t &) {}
template<class ANY> void operator*=(ANY &, const nullopt_t &) {}
template<class ANY> void operator/=(ANY &, const nullopt_t &) {}
template<class T>struct is_optional:false_type{};
template<class T>struct is_optional<optional<T>>:true_type{};
template<class T, class U>
true_type both_optional(optional<T> t, optional<U> u);
false_type both_optional(...);
template<class T, class U> class opt_check : public decltype(both_optional(declval<T>(), declval<U>())) {};
//optionalは同じ型同士しか足せない
//(o, t), (t, o), (o, o)
#define opt_tem(op) \
template<class O, class O_ret = decltype(declval<O>() op declval<O>())>optional<O_ret> operator op(const optional<O> &opt1, const optional<O> &opt2) { if (!opt1.has_value() || !opt2.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt1.value() op opt2.value()); }}\
template<class O, class T, class O_ret = decltype(declval<O>() op declval<O>())> auto operator op(const optional<O> &opt, const T &tem) -> require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { if (!opt.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt.value() op tem); }}\
template<class O, class T, class O_ret = decltype(declval<O>() op declval<O>())> auto operator op(const T &tem, const optional<O> &opt) -> require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { if (!opt.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt.value() op tem); }}
/*@formatter:off*/
opt_tem(+)opt_tem(-)opt_tem(*)opt_tem(/)
//比較はoptional<bool>を返す
opt_tem(<)opt_tem(>)opt_tem(<=)opt_tem(>=)
/*@formatter:on*//*@formatter:off*/
template<class O, class T> bool operator==(const optional<O>& opt, const T& tem){if(opt.has_value()){return opt.value()==tem;}else return nullopt == tem;}
template<class O, class T> bool operator!=(const optional<O>& opt, const T& tem){if(opt.has_value()){return opt.value()!=tem;}else return nullopt != tem;}
template<class O, class T> bool operator==(const T& tem, const optional<O>& opt){if(opt.has_value()){return opt.value()==tem;}else return nullopt == tem;}
template<class O, class T> bool operator!=(const T& tem, const optional<O>& opt){if(opt.has_value()){return opt.value()!=tem;}else return nullopt != tem;}
template<class O> bool operator==(const optional<O>& opt1, const optional<O>& opt2){ if(opt1.has_value() != opt2.has_value()){ return false; }else if(opt1.has_value()){ return opt1.value() == opt2.value(); }else { return nullopt == nullopt; }}
template<class O> bool operator!=(const optional<O>& opt1, const optional<O>& opt2){return !(opt1 == opt2);}
//(a+=null) != (a=a+null)
// a null
template<class T, class O> void operator+=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem += opt.value(); }}
template<class T, class O> void operator-=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem -= opt.value(); }}
template<class T, class O> void operator*=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem *= opt.value(); }}
template<class T, class O> void operator/=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem /= opt.value(); }}
template<class T, class O> void operator+=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() += tem; }}
template<class T, class O> void operator-=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() -= tem; }}
template<class T, class O> void operator*=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() *= tem; }}
template<class T, class O> void operator/=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() /= tem; }}
//
template<class Ol, class Or> void operator+=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl += opr.value(); }}
template<class Ol, class Or> void operator-=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl -= opr.value(); }}
template<class Ol, class Or> void operator*=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl *= opr.value(); }}
template<class Ol, class Or> void operator/=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl /= opr.value(); }}
/*@formatter:off*/
template<class U> auto max(const nullopt_t &, const U &val) { return val; }
template<class U> auto max(const U &val, const nullopt_t &) { return val; }
template<class U> auto min(const nullopt_t &, const U &val) { return val; }
template<class U> auto min(const U &val, const nullopt_t &) { return val; }
template<class T, class U> auto max(const optional<T> &opt, const U &val) { if (opt.has_value())return max(opt.value(), val); else return val; }
template<class T, class U> auto max(const U &val, const optional<T> &opt) { if (opt.has_value())return max(opt.value(), val); else return val; }
template<class T, class U> auto min(const optional<T> &opt, const U &val) { if (opt.has_value())return min(opt.value(), val); else return val; }
template<class T, class U> auto min(const U &val, const optional<T> &opt) { if (opt.has_value())return min(opt.value(), val); else return val; }
//null , optional, T
bool chma(nullopt_t &, const nullopt_t &) { return false; }
template<class T> bool chma(T &opt, const nullopt_t &) { return false; }
template<class T> bool chma(nullopt_t &, const T &opt) { return false; }
template<class T> bool chma(optional<T> &olv, const optional<T> &orv) { if (orv.has_value()) { return chma(olv, orv.value()); } else return false; }
template<class T, class U> bool chma(optional<T> &opt, const U &rhs) { if (opt.has_value()) { return chma(opt.value(), rhs); } else return false; }
template<class T, class U> bool chma(T &lhs, const optional<U> &opt) { if (opt.has_value()) { return chma(lhs, opt.value()); } else return false; }
bool chmi(nullopt_t &, const nullopt_t &) { return false; }
template<class T> bool chmi(T &opt, const nullopt_t &) { return false; }
template<class T> bool chmi(nullopt_t &, const T &opt) { return false; }
template<class T> bool chmi(optional<T> &olv, const optional<T> &orv) { if (orv.has_value()) { return chmi(olv, orv.value()); } else return false; }
template<class T, class U> bool chmi(optional<T> &opt, const U &rhs) { if (opt.has_value()) { return chmi(opt.value(), rhs); } else return false; }
template<class T, class U> bool chmi(T &lhs, const optional<U> &opt) { if (opt.has_value()) { return chmi(lhs, opt.value()); } else return false; }
template<class T> ostream &operator<<(ostream &os, optional<T> p) { if (p.has_value())os << p.value(); else os << "e"; return os;}
template<class T>using opt = my_optional<T>;
struct xorshift {
/*@formatter:on*/
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
/*@formatter:off*/
size_t operator()(const 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()(const 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 T, class U> size_t operator()(const std::pair<T, U>& x) const{ static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); uint64_t hasx = splitmix64(x.first); uint64_t hasy = splitmix64(x.second + FIXED_RANDOM); return hasx ^ hasy; }
template<class T> size_t operator()(const vector<T> &x) const { uint64_t has = 0; static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); uint64_t rv = splitmix64(FIXED_RANDOM); for (int i = 0; i < sz(x); i ++){ uint64_t v = splitmix64(x[i] + rv); has ^= v; rv = splitmix64(rv); } return has; }
};
#ifdef _DEBUG
//#define use_debtor
//template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) { return a.find(k) != a.end(); }
#ifdef use_debtor
//https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template<class T, class A = std::allocator<T>> struct debtor : std::vector<T, A> {
using std::vector<T, A>::vector;
template<class U> int deb_v(U a, int v) { return v; }
template<class U> int deb_v(debtor<U> &a, int v = 0) { cerr << a.size() << " "; return deb_v(a.at(0), v + 1); }
template<class U> void deb_o(U a) { cerr << a << " "; }
template<class U> void deb_o(debtor<U> &a) { for (int i = 0; i < min((int) a.size(), 15ll); i++) { deb_o(a[i]); } if ((int) a.size() > 15) { cerr << "..."; } cerr << endl; }
typename std::vector<T>::reference my_at(typename std::vector<T>::size_type n, vector<int> &ind) { if (n < 0 || n >= (int) this->size()) { int siz = (int) this->size(); cerr << "vector size = "; int dim = deb_v((*this)); cerr << endl; ind.push_back(n); cerr << "out index at "; for (auto &&i: ind) { cerr << i << " "; } cerr << endl; cerr << endl; if (dim <= 2) { deb_o((*this)); } exit(0); } return this->at(n); }
typename std::vector<T>::reference operator[](typename std::vector<T>::size_type n) { if (n < 0 || n >= (int) this->size()) { int siz = (int) this->size(); cerr << "vector size = "; int dim = deb_v((*this)); cerr << endl; cerr << "out index at " << n << endl; cerr << endl; if (dim <= 2) { deb_o((*this)); } exit(0); } return this->at(n); }
};
#define vector debtor
#endif
#ifdef use_pbds
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>
#endif
//区間削除は出来ない
//gp_hash_tableでcountを使えないようにするため
template<class K, class V>using umap_f = unordered_map<K, V>;
#else
#define endl '\n'
//umapはunorderd_mapになる
//umapiは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>
template<class K, class V>
struct umap_f : public __gnu_pbds::gp_hash_table<K, V, xorshift>{
int count(const K& k){
return this->find(k) != this->end();
}
};
#endif
#define umapi unordered_map<ll,ll>
#define umapp unordered_map<P,ll>
#define umappp unordered_map<P,P>
#define umapu unordered_map<uint64_t,ll>
#define umapip unordered_map<ll,P>
template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) { return a.find(k) != a.end(); }
/*@formatter:off*/
#ifdef use_pbds
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); }
#endif
//衝突対策
#define ws ws_
typedef tuple<ll, ll, ll> T;
typedef tuple<ll, ll, ll, ll> F;
//T mt(ll a, ll b, ll c) { return T(a, b, c); }
//F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }
//関数内をまとめる
//初期値l=-1, r=-1
void set_lr12(int &l, int &r, int n) { /*r==-1*/ if (r == -1) { if (l == -1) { l = 0; r = n; } else { r = l; l = 0; } }}
//@マクロ省略系 型,構造
//using で元のdoubleを同時に使えるはず
#define double_big
#ifdef double_big
#define double long double
//#define pow powl
#endif
using dou = double;
/*@formatter:off*/
template<class T> T MAX() { return numeric_limits<T>::max(); }
template<class T> T MIN() { return numeric_limits<T>::min(); }
constexpr ll inf = (ll) 1e9 + 100;
constexpr ll linf = (ll) 1e18 + 100;
constexpr dou dinf = (dou) linf * linf;
constexpr char infc = '{';
const string infs = "{";
template<class T> T INF() { return MAX<T>() / 2; }
template<> signed INF() { return inf; }
template<> ll INF() { return linf; }
template<> double INF() { return dinf; }
template<> char INF() { return infc; }
template<> string INF() { return infs; }
const double eps = 1e-9;
//#define use_epsdou
#ifdef use_epsdou
//基本コメントアウト
struct epsdou { double v; epsdou(double v = 0) : v(v) {} template<class T> epsdou &operator+=(T b) { v += (double) b; return (*this); } template<class T> epsdou &operator-=(T b) { v -= (double) b; return (*this); } template<class T> epsdou &operator*=(T b) { v *= (double) b; return (*this); } template<class T> epsdou &operator/=(T b) { v /= (double) b; return (*this); } epsdou operator+(epsdou b) { return v + (double) b; } epsdou operator-(epsdou b) { return v - (double) b; } epsdou operator*(epsdou b) { return v * (double) b; } epsdou operator/(epsdou b) { return v / (double) b; } epsdou operator-() const { return epsdou(-v); } template<class T> bool operator<(T b) { return v < (double) b; } template<class T> bool operator>(T b) {auto r = (double)b; return v > (double) b; } template<class T> bool operator==(T b) { return fabs(v - (double) b) <= eps; } template<class T> bool operator<=(T b) { return v < (double) b || fabs(v - b) <= eps; } template<class T> bool operator>=(T b) { return v > (double) b || fabs(v - b) <= eps; } operator double() { return v; }};
template<>epsdou MAX(){return MAX<double>();}
template<>epsdou MIN(){return MIN<double>();}
//priqrity_queue等で使うのに必要
bool operator<(const epsdou &a, const epsdou &b) {return a.v < b.v;}
bool operator>(const epsdou &a, const epsdou &b) {return a.v > b.v;}
istream &operator>>(istream &iss, epsdou &a) {iss >> a.v;return iss;}
ostream &operator<<(ostream &os, epsdou &a) {os << a.v;return os;}
#define eps_conr_t(o) template<class T> epsdou operator o(T a, epsdou b) {return (dou) a o b.v;}
#define eps_conl_t(o) template<class T> epsdou operator o(epsdou a, T b) {return a.v o (dou) b;}
eps_conl_t(+)eps_conl_t(-)eps_conl_t(*)eps_conl_t(/)eps_conr_t(+)eps_conr_t(-)eps_conr_t(*)eps_conr_t(/)
//template<class U> epsdou max(epsdou a, U b){return a.v>b ? a.v: b;}
//template<class U> epsdou max(U a, epsdou b){return a>b.v ? a: b.v;}
//template<class U> epsdou min(epsdou a, U b){return a.v<b ? a.v: b;}
//template<class U> epsdou min(U a, epsdou b){return a<b.v ? a: b.v;}
#undef double
#define double epsdou
#undef dou
#define dou epsdou
#endif
template<class T = int, class A, class B = int> T my_pow(A a, B b = 2) {
if(b < 0)return (T)1 / my_pow<T>(a, -b);
#if __cplusplus >= 201703L
if constexpr(is_floating_point<T>::value) { return pow((T) a, (T) b); }
else if constexpr(is_floating_point<A>::value) { assert2(0, "pow <not dou>(dou, )");/*return 0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/}
else if constexpr(is_floating_point<B>::value) { assert2(0, "pow <not dou>(, dou)");/*return 0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/}
else {
#endif
T ret = 1; T bek = a; while (b) { if (b & 1)ret *= bek; bek *= bek; b >>= 1; } return ret;
#if __cplusplus >= 201703L
}
#endif
}
#define pow my_pow
#define ull unsigned long long
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 upd update
#define sstream stringstream
#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 lam1(ret) [&](auto&& v){return ret;}
#define lam2(v, ret) [&](auto&& v){return ret;}
#define lam(...) over2(__VA_ARGS__,lam2,lam1)(__VA_ARGS__)
#define lamr(right) [&](auto&& p){return p right;}
#define unique(v) v.erase( unique(v.begin(), v.end()), v.end() );
//マクロ省略系 コンテナ
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 V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>>a
#define vvt2(t, a, b) vector<vector<t>>a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b,vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b,vector<t>(c,d))
#define vv(type, ...) over4(__VA_ARGS__,vvt4,vvt3,vvt2 ,vvt1,vvt0)(type,__VA_ARGS__)
#define vvi(...) vv(ll,__VA_ARGS__)
#define vvb(...) vv(bool,__VA_ARGS__)
#define vvs(...) vv(string,__VA_ARGS__)
#define vvd(...) vv(double,__VA_ARGS__)
#define vvc(...) vv(char,__VA_ARGS__)
#define vvp(...) vv(P,__VA_ARGS__)
#define vvt(...) vv(T,__VA_ARGS__)
//optional
#define vvoi(...) vv(optional<ll>,__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 vn(type, name, ...) auto name = make_v<type>(__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 setp = set<P>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll,xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
//初期化子を与える
template<template<class...> class MAP, class K, class V, class ... A>
struct init_map : public MAP<K, V, A...> {
V init_value;
init_map(V init_value = 0) : MAP<K, V, A...>(), init_value(init_value) {}
V &operator[](const K &k) {
if (MAP<K, V, A...>::count(k)==0) {
return MAP<K, V, A...>::operator[](k) = init_value;
}
return MAP<K, V, A...>::operator[](k);
}
};
template<class... A> using map2 = init_map<map, A...>;
template<class... A> using umap2 = init_map<umap, A...>;
template<class... A> using umap_f2 = init_map<umap_f, A...>;
//任意のマクロサポート用 使う度に初期化する //todo これを消す
int index_, v1_, v2_, v3_;
/*@formatter:off*/
string to_string(char c) { string ret = ""; ret += c; return ret;}
template<class T> class pq_min_max { vector<T> d; void make_heap() { for (int i = d.size(); i--;) { if (i & 1 && d[i - 1] < d[i]) swap(d[i - 1], d[i]); int k = down(i); up(k, i); } } inline int parent(int k) const { return ((k >> 1) - 1) & ~1; } int down(int k) { int n = d.size(); if (k & 1) { /* min heap*/ while (2 * k + 1 < n) { int c = 2 * k + 3; if (n <= c || d[c - 2] < d[c]) c -= 2; if (c < n && d[c] < d[k]) { swap(d[k], d[c]); k = c; } else break; } } else { /* max heap*/ while (2 * k + 2 < n) { int c = 2 * k + 4; if (n <= c || d[c] < d[c - 2]) c -= 2; if (c < n && d[k] < d[c]) { swap(d[k], d[c]); k = c; } else break; } } return k; } int up(int k, int root = 1) { if ((k | 1) < (int) d.size() && d[k & ~1] < d[k | 1]) { swap(d[k & ~1], d[k | 1]); k ^= 1; } int p; while (root < k && d[p = parent(k)] < d[k]) { /*max heap*/ swap(d[p], d[k]); k = p; } while (root < k && d[k] < d[p = parent(k) | 1]) { /* min heap*/ swap(d[p], d[k]); k = p; } return k; }public: pq_min_max() {} pq_min_max(const vector<T> &d_) : d(d_) { make_heap(); } template<class Iter> pq_min_max(Iter first, Iter last) : d(first, last) { make_heap(); } void operator+=(const T &x) { int k = d.size(); d.push_back(x); up(k); } void pop_min() { if (d.size() < 3u) { d.pop_back(); } else { swap(d[1], d.back()); d.pop_back(); int k = down(1); up(k); } } void pop_max() { if (d.size() < 2u) { d.pop_back(); } else { swap(d[0], d.back()); d.pop_back(); int k = down(0); up(k); } } const T &get_min() const { return d.size() < 2u ? d[0] : d[1]; } const T &get_max() const { return d[0]; } int size() const { return d.size(); } bool empty() const { return d.empty(); }};
//小さいほうからM個取得するpq
template<class T> struct helper_pq_size { pq_min_max<T> q; T su = 0; int max_size = 0; helper_pq_size() {} helper_pq_size(int max_size) : max_size(max_size) {} void clear() { q = pq_min_max<T>(); su = 0; } void operator+=(T v) { su += v; q += (v); if (sz(q) > max_size) { su -= q.get_max(); q.pop_max(); } } T sum() { return su; } T top() { return q.get_min(); } void pop() { su -= q.get_min(); q.pop_min(); } T poll() { T ret = q.get_min(); su -= ret; q.pop_min(); return ret; } ll size() { return q.size(); }};
//大きいほうからM個取得するpq
template<class T> struct helper_pqg_size { pq_min_max<T> q; T su = 0; int max_size = 0; helper_pqg_size() {} helper_pqg_size(int max_size) : max_size(max_size) {} void clear() { q = pq_min_max<T>(); su = 0; } void operator+=(T v) { su += v; q += (v); if (sz(q) > max_size) { su -= q.get_min(); q.pop_min(); } } T sum() { return su; } T top() { return q.get_max(); } void pop() { su -= q.get_max(); q.pop_max(); } T poll() { T ret = q.get_max(); su -= ret; q.pop_min(); return ret; } ll size() { return q.size(); }};;
template<class T, class Container = vector<T>,class Compare = std::less<typename Container::value_type>>
struct helper_pqg { priority_queue<T, Container, Compare> q;/*小さい順*/ T su = 0; helper_pqg() {} 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>
using helper_pq = helper_pqg<T, vector<T>, greater<T>>;
#if __cplusplus >= 201703L
//小さいほうからsize個残る
//Tがoptionalなら空の時nullを返す
template<class T> struct pq {
helper_pq<T> a_q;/*大きい順*/ helper_pq_size<T> b_q;/*大きい順*/ bool aquery;
T su = 0;
pq(int size = inf) {aquery = size == inf;if (!aquery) { b_q = helper_pq_size<T>(size); }}
void clear() { if (aquery) a_q.clear(); else b_q.clear(); }
void operator+=(T v) { if (aquery) a_q += v; else b_q += v; }
//optionalなら空の時nullを返す
T top() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q) == 0)return T(); return a_q.top(); } else { if (sz(b_q) == 0)return T(); return b_q.top(); } } else { if (aquery)return a_q.top(); else return b_q.top(); } }
T sum() { if (aquery) return a_q.sum(); else return b_q.sum(); }
//optionalなら空の時何もしない
void pop() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q))a_q.pop(); } else { if (sz(b_q))b_q.pop(); }} else { if (aquery)a_q.pop(); else b_q.pop(); }} /*T*/
T poll() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q) == 0)return T(); return a_q.poll(); } else { if (sz(b_q) == 0)return T(); return b_q.poll(); } } else { if (aquery)return a_q.poll(); else return b_q.poll(); } }
ll size() { if (aquery) return a_q.size(); else return b_q.size(); }
/*@formatter:off*/
};
template<class T> struct pqg { helper_pqg<T> a_q;/*大きい順*/ helper_pqg_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pqg(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pqg_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
#else
//小さいほうからsize個残る
template<class T> struct pq { helper_pq<T> a_q;/*大きい順*/ helper_pq_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pq(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pq_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
//大きいほうからsize個残る
template<class T> struct pqg { helper_pqg<T> a_q;/*大きい順*/ helper_pqg_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pqg(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pqg_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
#endif
#define pqi pq<ll>
#define pqgi pqg<ll>
template<class T> string deb_tos(pq<T> &q) { vector<T> res; auto temq = q; while (sz(temq))res.push_back(temq.top()), temq.pop(); stringstream ss; ss<< res; return ss.str();}
template<class T> string deb_tos(pqg<T> &q) { vector<T> res; auto temq = q; while (sz(temq))res.push_back(temq.top()), temq.pop(); stringstream ss; ss<< res; return ss.str();}
/*@formatter:off*/
//マクロ 繰り返し
//↓@オーバーロード隔離
//todo 使わないもの非表示
#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 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)
#ifdef use_for
//ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J) i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K)i = (j + 1 == J && k + 1 == K) ? i + 1 : i, j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j, k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L) i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i, j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j, k = (l + 1 == L ?(k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M) i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i, j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, k = (l + 1 == L && m + 1 == M ?(k + 1 == K ? 0 : k + 1) : k), l = m + 1 == M ? l+1 == L ? 0 : l+1 : l, m = m + 1 == M ? 0 : m + 1
#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J) for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K) for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L) for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I; nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M)for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I; nex_ind5(i, j, k, l, m, J, K, L, M))
//i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)
template<class T> void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) { while (1) { j++; if (j >= J) { j = 0; i++; if (i < I) { J = (int) s[i].size(); } } if (i >= I || J) return; }}
template<class T> void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K, vector<vector<vector<T>>> &s) { while (1) { k++; if (k >= K) { k = 0; j++; if (j >= J) { j = 0; i++; if (i >= I)return; } } J = (int) s[i].size(); K = (int) s[i][j].size(); if (J && K) return; }}
#define repv_2(i, a) repss2(i, sz(a))
//正方形である必要はない
//直前を持つのとどっちが早いか
#define repv_3(i, j, a) for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), i = 0, j = 0; i < repvI; nex_repv2(i,j,repvI,repvJ,a))
//箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a) for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), repvK =(int)a[0][0].size(), i = 0, j = 0, k=0; i < repvI; nex_repv3(i,j,k,repvI,repvJ,repvK,a))
#define repv_5(i, j, k, l, a) repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a) repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]), sz(a[0][0][0][0]))
#endif
template<typename T> struct has_rbegin_rend { private:template<typename U> static auto check(U &&obj) -> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});static std::false_type check(...);public:static constexpr bool value = decltype(check(std::declval<T>()))::value; };
template<typename T> constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template<typename Iterator> class Range { public:Range(Iterator &&begin, Iterator &&end) noexcept: m_begin(std::forward<Iterator>(begin)), m_end(std::forward<Iterator>(end)) {}Iterator begin() const noexcept { return m_begin; }Iterator end() const noexcept { return m_end; }private:const Iterator m_begin;const Iterator m_end; };
template<typename Iterator> static inline Range<Iterator> makeRange(Iterator &&begin, Iterator &&end) noexcept { return Range<Iterator>{std::forward<Iterator>(begin), std::forward<Iterator>(end)}; }
template<typename T> static inline decltype(auto) makeReversedRange(const std::initializer_list<T> &iniList) noexcept { return makeRange(std::rbegin(iniList), std::rend(iniList)); }
template<typename T, typename std::enable_if_t<has_rbegin_rend_v<T>, std::nullptr_t> = nullptr> static inline decltype(auto) makeReversedRange(T &&c) noexcept { return makeRange(std::rbegin(c), std::rend(c)); }/* rbegin(), rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/template<typename T, typename std::enable_if<!has_rbegin_rend<T>::value, std::nullptr_t>::type = nullptr> static inline void makeReversedRange(T &&) noexcept { static_assert(has_rbegin_rend<T>::value, "Specified argument doesn't have reverse iterator."); }
//#define use_for
#define form3(k, v, st) for(auto&&[k, v] : st)
#define form4(k, v, st, r) for(auto&&[k, v] : range(st.begin(), st.lower_bound(r)))
#define form5(k, v, st, l, r) for(auto&&[k, v] : range(st.lower_bound(l), st.lower_bound(r)))
#define form(...) over5(__VA_ARGS__,form5,form4,form3)(__VA_ARGS__)
#define forrm1(st) for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
#define forrm3(k, v, st) for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
//向こう側で
// ++itか it = st.erase(it)とする
#define fors1(st) for (auto &&it = st.begin(); it != st.end(); )
#define fors2(v, st) for (auto &&it = st.begin(); it != st.end(); )
#define fors3(v, st, r) for (auto &&it = st.begin(); it != st.end() && (*it) < r; )
#define fors4(v, st, l, r) for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; )
#ifdef use_for
#define forslr3(st, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b) for (auto &&forslr_it = st.lower_bound(l); forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define fora_f_init_2(a, A) ;
#define fora_f_init_3(fora_f_i, a, A) auto &&a = A[fora_f_i];
#define fora_f_init_4(a, b, A, B) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i];
#define fora_f_init_5(fora_f_i, a, b, A, B) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i];
#define fora_f_init_6(a, b, c, A, B, C) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i];
#define fora_f_init_7(fora_f_i, a, b, c, A, B, C) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i];
#define fora_f_init_8(a, b, c, d, A, B, C, D) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i]; auto && d = D[fora_f_i];
#define fora_f_init_9(fora_f_i, a, b, c, d, A, B, C, D) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i]; auto && d = D[fora_f_i];
#define fora_f_init(...) over9(__VA_ARGS__,fora_f_init_9, fora_f_init_8, fora_f_init_7, fora_f_init_6, fora_f_init_5, fora_f_init_4, fora_f_init_3, fora_f_init_2)(__VA_ARGS__)
#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B) auto &&a = A[forr_i]; auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B) auto &&a = A[forr_i]; auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i]; auto && d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i]; auto && d = D[forr_i];
#define forr_init(...) over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6, forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)
#define forp_init3(k, v, S) auto &&k = S[forp_i].first;auto &&v = S[forp_i].second;
#define forp_init4(forp_i, k, v, S) auto &&k = S[forp_i].first;auto &&v = S[forp_i].second;
#define forp_init(...) over4(__VA_ARGS__,forp_init4,forp_init3,forp_init2,forp_init1)(__VA_ARGS__)
#define forrm_init(k, v, ...) auto &&k = (*forrm_it).fi;auto &&v = (*forrm_it).se;
#define fors_init(v, ...) auto &&v = (*it);
#define forlr_init(a, A, ngl, ngr) auto a = A[forlr_i]; auto prev = forlr_i ? A[forlr_i-1] : ngl;auto next = forlr_i+1< rep2lim? A[forlr_i+1] : ngr;
#define forslr_init4(a, A, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init(...) over6(__VA_ARGS__,forslr_init6,forslr_init5,forslr_init4)(__VA_ARGS__);
//こうしないとmapがおかしくなる
#define fora_f_2(a, A) for(auto&& a : A)
#define fora_f_3(fora_f_i, a, A) rep(fora_f_i, sz(A))
#define fora_f_4(a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_5(fora_f_i, a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_6(a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_7(fora_f_i, a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_8(a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define fora_f_9(fora_f_i, a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define forr_2(a, A) rer(forr_i, sz(A)-1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A)-1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A)-1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A)-1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A)-1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A)-1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A)-1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A)-1)
#endif
//↑@オーバーロード隔離
//rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__,rer4,rer3,rer2,)(__VA_ARGS__)
//自分込みで残りがREM以上の間ループを回す
#define rem(i, N, REM) for (int i = 0; i < N - REM + 1; i++)
//char用のrep
#define repc(i, m, n) for(char i = m,repc3lim=n; i < repc3lim ; ++i)
//i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__,reps5,reps4,reps3,reps2,)(__VA_ARGS__)
#define repss(...) over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a, repss2) (__VA_ARGS__)
//vectorのindexを走査する
//repv(i,j,vvi)
#define repv(...) over6(__VA_ARGS__,repv_6,repv_5,repv_4,repv_3,repv_2,)(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A)-1; i >= 0 ; i--)
//repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)
#ifdef use_for
#define fora_f(...) over9(__VA_ARGS__, fora_f_9, fora_f_8, fora_f_7, fora_f_6, fora_f_5, fora_f_4, fora_f_3, fora_f_2)(__VA_ARGS__)
#endif
#define forr(...) over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3, forr_2)(__VA_ARGS__)
//0~N-2まで見る
#define forar_init(v, rv, A) auto &&v = A[forar_i]; auto && rv = A[forar_i+1];
#define forar(v, rv, A) rep(forar_i, sz(A) - 1)
#if __cplusplus >= 201703L
template<size_t M_SZ, bool indexed, class Iterator, class T, class U=T, class V=T, class W=T>
class ite_vec_merge : public Iterator { std::size_t i = 0; vector<T> &A; vector<U> &B; vector<V> &C; vector<W> &D;public : ite_vec_merge(Iterator ita, vector<T> &A) : Iterator(ita), A(A), B(A), C(A), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B) : Iterator(ita), A(A), B(B), C(A), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C) : Iterator(ita), A(A), B(B), C(C), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C, vector<W> &D) : Iterator(ita), A(A), B(B), C(C), D(D) {} auto &operator++() { ++i; this->Iterator::operator++(); return *this; } auto operator*() const noexcept { if constexpr(!indexed && M_SZ == 1) { return tuple<T &>(A[i]); } else if constexpr(!indexed && M_SZ == 2) { return tuple<T &, U &>(A[i], B[i]); } else if constexpr(!indexed && M_SZ == 3) { return tuple<T &, U &, V &>(A[i], B[i], C[i]); } else if constexpr(!indexed && M_SZ == 4) { return tuple<T &, U &, V &, W &>(A[i], B[i], C[i], D[i]); } else if constexpr(indexed && M_SZ == 1) { return tuple<int, T &>(i, A[i]); } else if constexpr(indexed && M_SZ == 2) { return tuple<int, T &, U &>(i, A[i], B[i]); } else if constexpr(indexed && M_SZ == 3) { return tuple<int, T &, U &, V &>(i, A[i], B[i], C[i]); } else if constexpr(indexed && M_SZ == 4) { return tuple<int, T &, U &, V &, W &>(i, A[i], B[i], C[i], D[i]); } else { assert(0); return tuple<int>(i); } }};
template<size_t M_SZ, bool indexed, class T, class U=T, class V=T, class W=T>
class vec_merge { vector<T> &a; vector<U> &b; vector<V> &c; vector<W> &d;public : vec_merge(vector<T> &a) : a(a), b(a), c(a), d(a) {} vec_merge(vector<T> &a, vector<U> &b) : a(a), b(b), c(a), d(a) {} vec_merge(vector<T> &a, vector<U> &b, vector<V> &c) : a(a), b(b), c(c), d(a) {} vec_merge(vector<T> &a, vector<U> &b, vector<V> &c, vector<W> &d) : a(a), b(b), c(c), d(d) {} auto begin() const { if constexpr(M_SZ == 1) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a}; } else if constexpr(M_SZ == 2) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b}; } else if constexpr(M_SZ == 3) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b, c}; } else if constexpr(M_SZ == 4) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b, c, d}; } else { assert(0); return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a}; } } auto end() const { if constexpr(M_SZ == 1) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a}; } else if constexpr(M_SZ == 2) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b}; } else if constexpr(M_SZ == 3) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b, c}; } else if constexpr(M_SZ == 4) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b, c, d}; } else { assert(0); return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a}; } }};
#endif
#define fora_2(a, A) for(auto&& a : A)
#if __cplusplus >= 201703L
#define fora_3(i, a, A) for(auto[i, a] : vec_merge<1, true, decl_t<decltype(A)>>(A))
#define fora_4(a, b, A, B) for(auto[a, b] : vec_merge<2, false, decl_t<decltype(A)>, decl_t<decltype(B)>>(A, B))
#define fora_5(i, a, b, A, B) for(auto[i, a, b] : vec_merge<2, true, decl_t<decltype(A)>, decl_t<decltype(B)>>(A, B))
#define fora_6(a, b, c, A, B, C) for(auto[a, b, c] : vec_merge<3, false, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>>(A, B, C))
#define fora_7(i, a, b, c, A, B, C) for(auto[i, a, b, c] : vec_merge<3, true, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>>(A, B, C))
#define fora_8(a, b, c, d, A, B, C, D) for(auto[a, b, c, d] : vec_merge<4, false, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>, decl_t<decltype(D)>>(A, B, C, D))
#define fora_9(i, a, b, c, d, A, B, C, D) for(auto[i, a, b, c, d] : vec_merge<4, true, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>, decl_t<decltype(D)>>(A, B, C, D))
#endif
//構造化束縛ver
//1e5要素で40ms程度
//遅いときはfora_fを使う
#define fora(...) over9(__VA_ARGS__, fora_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3, fora_2)(__VA_ARGS__)
//#define forr(v, a) for(auto&& v : makeReversedRange(a))
//参照を取らない
/*@formatter:off*/
#ifdef use_for
template<class U> vector<U> to1d(vector<U> &a) { return a; }
template<class U> auto to1d(vector<vector<U>> &a) { vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)res.push_back(a2); return res;}
template<class U> vector<U> to1d(vector<vector<vector<U>>> &a) { vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) res.push_back(a3); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)res.push_back(a4); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)for (auto &&a5 : a4)res.push_back(a5); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)for (auto &&a5 : a4)for (auto &&a6 : a5)res.push_back(a6); return res;}
#define forv(a, b) for(auto a : to1d(b))
//インデックスを前後含めて走査
#define ring(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)
//値と前後を見る
#define ringv(v, d) index_=0;for (auto prev = d[sz(d)-1],next= (int)d.size()>1?d[1]:d[0],v = d[0]; index_ < sz(d); index_++, prev = v, v = next, next = (index_>=sz(d)-1?d[0]:d[index_+1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i,sz(d))
#endif
#define forrm(...) over5(__VA_ARGS__,forrm5,forrm4,forrm3,forrm2,forrm1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__,fors4,fors3,fors2,fors1)(__VA_ARGS__)
#define forslr(...) over6(__VA_ARGS__,forslr6,forslr5,forslr4,forslr3)(__VA_ARGS__)
#define forp3(k, v, st) rep(forp_i,sz(st))
#define forp4(forp_i, k, v, st) rep(forp_i,sz(st))
#define forp(...) over4(__VA_ARGS__,forp4,forp3)(__VA_ARGS__)
//to_vec(rep(i, N))のように使い
//iが走査した値を持つvectorを返す
#define to_vec2(type, my_for) \
[&](){ \
vector<type> ret; \
my_for{ \
ret.push_back(i); \
} \
return ret; \
}()
#define to_vec1(my_for) to_vec2(int, my_for)
#define to_vec(...) over2(__VA_ARGS__,to_vec2,to_vec1)(__VA_ARGS__)
//マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const double PI = 3.1415926535897932384626433832795029L;
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); }};
}
//stream まとめ
/*@formatter:off*/
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 << get<0>(p) << " " << get<1>(p) << " " << get<2>(p);return os;}
ostream &operator<<(ostream &os, F p) {os << get<0>(p) << " " << get<1>(p) << " " << get<2>(p)<<" "<< get<3>(p);return os;}
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec_) {for (ll i = 0; i < vec_.size(); ++i)os << vec_[i] << (i + 1 == vec_.size() ? "" : " ");return os;}
template<typename T> ostream &operator<<(ostream &os, const 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, const map<T, U> &m) {os<<endl;for (auto &&v:m) os << v << endl;return os;}
template<typename T, typename U> ostream &operator<<(ostream &os, const unordered_map<T, U> &m) {os<<endl;for (auto &&v:m) os << v << endl;return os;}
template<typename T, typename U> string deb_tos(const unordered_map<T, U> &m) { map<T, U> a; for (auto &&v:m) { a[v.first] = v.second; } stringstream ss; ss << a; return ss.str();}
template<class T> ostream &operator<<(ostream &os, const set<T>& s) { fora(v, s) { os << v << " "; } return os;}
template<class T> ostream &operator<<(ostream &os, const mset<T>& s) { fora(v, s) { os << v << " "; } return os;}
template<class T> ostream &operator<<(ostream &os, const deque<T>& a) { fora(v, a) { os << v << " "; } return os;}
ostream &operator<<(ostream &os, const vector<vector<char>> &vec_) { rep(h, sz(vec_)) { rep(w, sz(vec_[0])) { os << vec_[h][w]; } os << endl; } return os;}
ostream &operator<<(ostream &os, const vector<vector<my_optional<char>>> &vec_) {rep(h, sz(vec_)) { rep(w, sz(vec_[0])) { os << vec_[h][w]; } os << endl; } return os;}
//tuple "," 区切り
#if __cplusplus >= 201703L
template<class Tuple, size_t... Indicies>void helper_os_tuple(ostream &os, const Tuple &tup, index_sequence<Indicies...>) { stringstream ss; auto f=[&](auto a){ ss<<", "<<a; }; (...,f(get<Indicies>(tup))); os<<ss.str().substr(2);}
template<class... T>ostream &operator<<(ostream &os, const tuple<T...> &tup) {helper_os_tuple(os, tup, index_sequence_for<T...>{});return os;}
#endif
template<class T> struct range_now {
int l;
vector<T> A;
range_now(vector<T>&& A, int l) : A(A), l(l){}
};
/*@formatter:off*/
//template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>& a) {fora_f(v,a)os<<v<<endl;return os;}
template<typename W, typename H> void resize(W &vec_, const H head) { vec_.resize(head); }
template<typename W, typename H, typename ... T> void resize(W &vec_, const H &head, const T ... tail) {vec_.resize(head);for (auto &v: vec_)resize(v, tail...);}
//#define use_for_each //_each _all_of _any_of _none_of _find_if _rfind_if _contains _count_if _erase_if _entry_if
#ifdef use_for_each
//todo Atcoderの過去問がc++17に対応したら
#if __cplusplus >= 201703L
//for_each以外はconst & (呼び出し側のラムダも)
template<typename T, typename F> bool all_of2(const T &v, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : v) { if (!all_of2(v_, f))return false; } return true; } else { return f(v); }}
template<typename T, typename F> bool any_of2(const T &v, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : v) { if (any_of2(v_, f))return true; } return false; } else { return f(v); }}
template<typename T, typename F> bool none_of2(const T &v, F f) {return all_of2(v, [&](auto a){return !f(a);});}
/*@formatter:off*/
//存在しない場合
//1次元 Nを返す
//多次元-1を返す
template<typename T, typename F> ll find_if2(const vector<T> &v, F f) { rep(i, sz(v)) { if (f(v[i]))return i; } return sz(v);}
template<typename T, typename F> tuple<int, int> find_if2(const vector<vector<T> > &v, F f) { rep(i, sz(v)) { rep(j, sz(v[i])) { if (f(v[i][j])) { return tuple<int, int>(i, j); }}} return tuple<int, int>(-1, -1);}
template<typename T, typename F> auto find_if2(const vector<vector<vector<T> > > &v, F f) { rep(i, sz(v)) { if (auto ret = find_if2(v[i], f); get<0>(ret) != -1) { return tuple_cat(tuple<int>(i), ret); }} auto bad = tuple_cat(tuple<int>(-1), find_if2(v[0], f)); return bad;}
template<class T, class F> auto find_if2(const range_now<T> &v, F f) {return find_if2(v.A, f) + v.l;}
//存在しない場合
//1次元 -1を返す
//多次元-1を返す
template<typename T, typename F> ll rfind_if2(const vector<T> &v, F f) { rer(i, sz(v) - 1) { if (f(v[i]))return i; } return -1;}
template<typename T, typename F> tuple<int, int> rfind_if2(const vector<vector<T> > &v, F f) { rer(i, sz(v) - 1) { rer(j, sz(v[i]) - 1) { if (f(v[i][j])) { return tuple<int, int>(i, j); }}} return tuple<int, int>(-1, -1);}
template<typename T, typename F> auto rfind_if2(const vector<vector<vector<T> > > &v, F f) { rer(i, sz(v) - 1) { if (auto ret = rfind_if2(v[i], f); get<0>(ret) != -1) { return tuple_cat(tuple<int>(i), ret); }} auto bad = tuple_cat(tuple<int>(-1), rfind_if2(v[0], f)); return bad;}
//todo まとめられそう string,vector全般
template<class T> bool contains(const string &s, const T &v) { return s.find(v) != string::npos; }
template<typename T> bool contains(const vector<T> &v, const T &val) { return std::find(v.begin(), v.end(), val) != v.end(); }
template<typename T, typename F> bool contains_if2(const vector<T> &v, F f) { return find_if(v.begin(), v.end(), f) != v.end(); }
template<typename T, typename F> ll count_if2(const T &v, F f) { if constexpr(has_value_type<T>::value) { ll ret = 0; for (auto &&v_ : v) { ret += count_if2(v_, f); } return ret; } else { return f(v); }}
template<typename T, typename F> void for_each2(T &a, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : a)for_each2(v_, f); } else { f(a); }}
#else
template<typename T, typename F> bool all_of2(const T &v, F f) { return f(v); }
template<typename T, typename F> bool all_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> bool any_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> bool none_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> ll find_if2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> ll rfind_if2(const 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(const string &s, const T &v) { return s.find(v) != string::npos; }
template<typename T> bool contains(const vector<T> &v, const T &val) { return std::find(v.begin(), v.end(), val) != v.end(); }
template<typename T, typename F> bool contains_if2(const vector<T> &v, F f) { return find_if(v.begin(), v.end(), f) != v.end(); }
template<typename T, typename F> ll count_if2(const T &v, F f) { return f(v); }
template<typename T, typename F> ll count_if2(const 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 &a, F f) {
f(a);
}
template<typename T, typename F> void for_each2(vector<T> &a, F f) {
for (auto &&v_ : a)for_each2(v_, f);
}
#endif
template<typename W> ll count_od(const vector<W> &a) { return count_if2(a, [](ll v) { return v & 1; }); }
template<typename W> ll count_ev(const vector<W> &a) { return count_if2(a, [](ll v) { return !(v & 1); }); }
//削除した後のvectorを返す
template<typename T, typename F> vector<T> erase_if2(const vector<T> &v, F f) { vector<T> nv; rep(i, sz(v)) { if (!f(v[i])) { nv.push_back(v[i]); }} return nv;}
template<typename T, typename F> vector<vector<T>> erase_if2(const vector<vector<T>> &v, F f) { vector<vector<T>> res; rep(i, sz(v)) { res[i] = erase_if2(v[i], f); } return res;}
template<typename T, typename F> vector<T> entry_if2(const vector<T> &v, F f) {vector<T> nv;rep(i, sz(v)) { if (f(v[i])) { nv.push_back(v[i]); }}return nv;}
template<typename T, typename F> vector<vector<T>> entry_if2(const vector<vector<T>> &v, F f) {vector<vector<T>> res;rep(i, sz(v)) { res[i] = entry_if2(v[i], f); }return res;}
template<typename T, typename F> ll l_rfind_if(const vector<T> &v, F f) {rer(i, sz(v) - 1) { if (f(v[i]))return i; }return -1;}
template<typename T, typename F> bool l_contains_if(const vector<T> &v, F f) {rer(i, sz(v) - 1) { if (f(v[i]))return true; }return false;}
template<class A, class B, class C> auto t_all_of(A a, B b, C c) { return std::all_of(a, b, c); }
template<class A, class B, class C> auto t_any_of(A a, B b, C c) { return std::any_of(a, b, c); }
template<class A, class B, class C> auto t_none_of(A a, B b, C c) { return std::none_of(a, b, c); }
template<class A, class B, class C> auto t_find_if(A a, B b, C c) { return std::find_if(a, b, c); }
template<class A, class B, class C> auto t_count_if(A a, B b, C c) { return std::count_if(a, b, c); }
#define all_of_s__2(a, right) (t_all_of(ALL(a),lamr(right)))
#define all_of_s__3(a, v, siki) (t_all_of(ALL(a),[&](auto v){return siki;}))
#define all_of_s(...) over3(__VA_ARGS__,all_of_s__3,all_of_s__2)(__VA_ARGS__)
//all_of(A, %2);
//all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a,lamr(right))
#define all_of__3(a, v, siki) all_of2(a,[&](auto v){return siki;})
#define all_of(...) over3(__VA_ARGS__,all_of__3,all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a,f)
#define any_of_s__2(a, right) (t_any_of(ALL(a),lamr(right)))
#define any_of_s__3(a, v, siki) (t_any_of(ALL(a),[&](auto v){return siki;}))
#define any_of_s(...) over3(__VA_ARGS__,any_of_s__3,any_of_s__2)(__VA_ARGS__)
#define any_of__2(a, right) any_of2(a,lamr(right))
#define any_of__3(a, v, siki) any_of2(a,[&](auto v){return siki;})
#define any_of(...) over3(__VA_ARGS__,any_of__3,any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a,f)
#define none_of_s__2(a, right) (t_none_of(ALL(a),lamr(right)))
#define none_of_s__3(a, v, siki) (t_none_of(ALL(a),[&](auto v){return siki;}))
#define none_of_s(...) over3(__VA_ARGS__,none_of_s__3,none_of_s__2)(__VA_ARGS__)
#define none_of__2(a, right) none_of2(a,lamr(right))
#define none_of__3(a, v, siki) none_of2(a,[&](auto v){return siki;})
#define none_of(...) over3(__VA_ARGS__,none_of__3,none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a,f)
#define find_if_s__2(a, right) (t_find_if(ALL(a),lamr(right))-a.begin())
#define find_if_s__3(a, v, siki) (t_find_if(ALL(a),[&](auto v){return siki;})-a.begin())
#define find_if_s(...) over3(__VA_ARGS__,find_if_s__3,find_if_s__2)(__VA_ARGS__)
#define find_if__2(a, right) find_if2(a,lamr(right))
#define find_if__3(a, v, siki) find_if2(a,[&](auto v){return siki;})
#define find_if__4(a, l, v, siki) (find_if2(decltype(a)(a.begin()+l , a.end()),[&](auto v){return siki;}) + l)
#define find_if(...) over4(__VA_ARGS__,find_if__4, find_if__3,find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a,f)
#define rfind_if_s__2(a, right) l_rfind_if(a, lamr(right))
#define rfind_if_s__3(a, v, siki) l_rfind_if(a, [&](auto v){return siki;})
#define rfind_if_s(...) over3(__VA_ARGS__,rfind_if_s__3,rfind_if_s__2)(__VA_ARGS__)
#define rfind_if__2(a, right) rfind_if2(a,lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a,[&](auto v){return siki;})
#define rfind_if(...) over3(__VA_ARGS__,rfind_if__3,rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a,f)
#define contains_if_s__2(a, right) l_contains_if(a, lamr(right))
#define contains_if_s__3(a, v, siki) l_contains_if(a, [&](auto v){return siki;})
#define contains_if_s(...) over3(__VA_ARGS__,contains_if_s__3,contains_if_s__2)(__VA_ARGS__)
#define contains_if__2(a, right) contains_if2(a,lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a,[&](auto v){return siki;})
#define contains_if(...) over3(__VA_ARGS__,contains_if__3,contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a,f)
#define count_if_s__2(a, right) (t_count_if(ALL(a),lamr(right)))
#define count_if_s__3(a, v, siki) (t_count_if(ALL(a),[&](auto v){return siki;}))
#define count_if_s(...) over3(__VA_ARGS__,count_if_s__3,count_if_s__2)(__VA_ARGS__)
#define count_if__2(a, right) count_if2(a,lamr(right))
#define count_if__3(a, v, siki) count_if2(a,[&](auto v){return siki;})
#define count_if(...) over3(__VA_ARGS__,count_if__3,count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a,f)
//vector<vi>で、viに対して操作
#define for_each_s__2(a, right) do{fora(v,a){v right;}}while(0)
#define for_each_s__3(a, v, shori) do{fora(v,a){shori;}}while(0)
#define for_each_s(...) over3(__VA_ARGS__,for_each_s__3,for_each_s__2)(__VA_ARGS__)
//vector<vi>で、intに対して操作
#define for_each__2(a, right) for_each2(a,lamr(right))
#define for_each__3(a, v, shori) for_each2(a,[&](auto& v){shori;})
#define for_each(...) over3(__VA_ARGS__,for_each__3,for_each__2)(__VA_ARGS__)
#define for_each_f(a, f) for_each2(a, f);
template<class T, class F> vector<T> help_for_eached(const vector<T> &A, F f) { vector<T> ret = A; for_each(ret, v, f(v)); return ret;}
#define for_eached__2(a, right) help_for_eached(a, lamr(right))
#define for_eached__3(a, v, shori) help_for_eached(a, lam(v, shori))
#define for_eached(...) over3(__VA_ARGS__,for_eached__3,for_eached__2)(__VA_ARGS__)
#define for_eached_f(a, f) for_eached2(a, f);
#define each for_each
#define eached for_eached
//#define erase_if_s__2(a, right) l_erase_if2(a,lamr(right))
//#define erase_if_s__3(a, v, siki) l_erase_if2(a,[&](auto v){return siki;})
//#define erase_if_s(...) over3(__VA_ARGS__,erase_if_s__3,erase_if_s__2)(__VA_ARGS__)
#define erase_if__2(a, right) erase_if2(a,lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a,[&](auto v){return siki;})
#define erase_if(...) over3(__VA_ARGS__,erase_if__3,erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a,f)
//#define entry_if_s__2(a, right) l_entry_if2(a,lamr(right))
//#define entry_if_s__3(a, v, siki) l_entry_if2(a,[&](auto v){return siki;})
//#define entry_if_s(...) over3(__VA_ARGS__,entry_if_s__3,entry_if_s__2)(__VA_ARGS__)
#define entry_if__2(a, right) entry_if2(a,lamr(right))
#define entry_if__3(a, v, siki) entry_if2(a,[&](auto v){return siki;})
#define entry_if(...) over3(__VA_ARGS__,entry_if__3,entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) entry_if2(a,f)
#endif
//機能削除 todo
//string.replace()は長さを指定するため、間違えやすい
/*@formatter:off*/
void replace(str &a, char key, char v) { replace(ALL(a), key, v); }
template<class T, class U> void my_replace(T& s, int l, int r, const U& t){s.replace(l, r-l, t);}
#define replace my_replace
template<class T, class U, class W> void replace(vector<W> &a, T key, U v) { rep(i, sz(a))if (a[i] == key)a[i] = v; }
template<class T, class U, class W> void replace(vector<vector<W>> &A, T key, U v) { rep(i, sz(A))replace(A[i], key, v); }
void replace(str &a, char key, str v) { if (v == "")a.erase(remove(ALL(a), key), a.end()); }
//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; }
void replace(str &a) { int dec = 0; if ('a' <= a[0] && a[0] <= 'z')dec = 'a'; if ('A' <= a[0] && a[0] <= 'Z')dec = 'A'; fora(v, a) { v -= dec; }}
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 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)); }
vi iota(ll s, ll len) {vi ve(len);iota(ALL(ve), s);return ve;}
//[iterator, iterator)等と渡す
// vectorに変換もできる
#if __cplusplus >= 201703L
template<class I, class J>
struct body_range {
I itl;
J itr;
body_range(I it, J end) : itl(it), itr(end) {}
I begin() { return itl; }
I end() { return itr; }
//毎回コピーする
operator vector<typename I::value_type>() {
return vector<typename I::value_type>(itl, itr);
}
};
template<class I, class J, require_t(is_integral_v<I>)>
vector<int> range(I l, J r){
return iota(l, r-l);
}
template<class I, require_t(is_integral_v<I>)>
vector<int> range(I r){
return iota(0, r);
}
template<class I, require_t(!is_integral_v<I>)>
auto range(I itl, I itr){
return body_range(itl, itr);
}
#endif
/*@formatter:off*/
//tuple<vecs...> = take_vt(vt)
#if __cplusplus >= 201703L
template<class Tup_l, class Tup_r, size_t ... Indicies> auto helper_take_vector_tuple(Tup_l &res, const Tup_r &rhs, index_sequence<Indicies...>) { (..., get<Indicies>(res).emplace_back(get<Indicies>(rhs))); }
template<class... T> auto take_vector_tuple(const vector<tuple<T...>> &elems) {tuple<vector<T>...> res;for (auto &&elem : elems) { helper_take_vector_tuple(res, elem, index_sequence_for<T...>{}); }return res;}
//tie_vt(A,B,C) = vt;
template<class... T> struct tie_vector_tuple { tuple<vector<T> &...> v; tie_vector_tuple(vector<T> &...args) : v(args...) {} template<class Tup, size_t ...Indicies> void helper_emplace(int i, Tup &rhs, index_sequence<Indicies...>) { (..., (get<Indicies>(v).emplace_back(get<Indicies>(rhs)))); } template<size_t ... Indicies> void clear(index_sequence<Indicies...>) { (..., (get<Indicies>(v).clear())); } void operator=(vector<tuple<T...>> &rhs) {clear(index_sequence_for<T...>{});rep(i, sz(rhs)) { helper_emplace(i, rhs[i], index_sequence_for<T...>{}); }}};
/*@formatter:off*/
//vt = make_vt(A, B, C)
template<class H, class... T> auto make_vector_tuple(const vector<H> &head, const vector<T> &...tails) { vector<tuple<H, T...>> res; rep(i, sz(head)) { res.emplace_back(head[i], tails[i]...); } return res;}
#endif
/*@formatter:off*/
#define mvt make_vector_tuple
#define tie_vt tie_vector_tuple
#define make_vt make_vector_tuple
#define take_vt take_vector_tuple
/*@formatter:off*/
//基本ソート@0
template<class T> void sort(vector<T> &a, int l = -1, int r = -1) {set_lr12(l, r, sz(a));fast_sort(a.begin() + l, a.begin() + r);}
template<class T> void rsort(vector<T> &a, int l = -1, int r = -1) {set_lr12(l, r, sz(a));fast_sort(a.begin() + l, a.begin() + r, greater<T>());};
//f(tup)の大きさでソート
template<class U, class F> void sort(vector<U> &a, F f) { fast_sort(ALL(a), [&](U l, U r) { return f(l) < f(r); }); };
template<class U, class F> void rsort(vector<U> &a, F f) { fast_sort(ALL(a), [&](U l, U r) { return f(l) > f(r); }); };
enum tuple_comparator { /*tcom_less = 1728, tcom_greater = 1729, */ fisi = 0, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd, 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};
//todo 短くする
#define set_4(i0, i1, o0, o1) [&](U l, U r) { return get<i0>(l) != get<i0>(r) ? get<i0>(l) o0 get<i0>(r) : get<i1>(l) o1 get<i1>(r) ;}
#define set_6(i0, i1, i2, o0, o1, o2) [&](U l, U r) { return get<i0>(l) != get<i0>(r) ? get<i0>(l) o0 get<i0>(r) : get<i1>(l) != get<i1>(r) ? get<i1>(l) o1 get<i1>(r) : get<i2>(l) o2 get<i2>(r); }
//functionを返すため少し遅い todo
#if __cplusplus >= 201703L
template<class... T, class U=tuple<T...>> function<bool(U, U)> get_function2(const vector<tuple<T...>> &a, tuple_comparator Compare) { if constexpr(sizeof...(T) >= 2) { int type = Compare; if (type == 0) return set_4(0, 1, <, <); if (type == 1) return set_4(0, 1, <,>); if (type == 2) return set_4(0, 1, >, <); if (type == 3) return set_4(0, 1, >, >); if (type == 4) return set_4(1, 0, <, <); if (type == 5) return set_4(1, 0, <,>); if (type == 6) return set_4(1, 0, >, <); if (type == 7) return set_4(1, 0, >, >); } if constexpr(sizeof...(T) >= 3) { int type = Compare - 8; if (type == 0) return set_6(0, 1, 2, <, <, <); else if (type == 1) return set_6(0, 1, 2, <, <,>); else if (type == 2) return set_6(0, 1, 2, <,>, <); else if (type == 3) return set_6(0, 1, 2, <,>, >); else if (type == 4) return set_6(0, 1, 2, >, <, <); else if (type == 5) return set_6(0, 1, 2, >, <,>); else if (type == 6) return set_6(0, 1, 2, >, >, <); else if (type == 7) return set_6(0, 1, 2, >, >, >); else if (type == 8) return set_6(0, 2, 1, <, <, <); else if (type == 9) return set_6(0, 2, 1, <, <,>); else if (type == 10) return set_6(0, 2, 1, <,>, <); else if (type == 11) return set_6(0, 2, 1, <,>, >); else if (type == 12) return set_6(0, 2, 1, >, <, <); else if (type == 13) return set_6(0, 2, 1, >, <,>); else if (type == 14) return set_6(0, 2, 1, >, >, <); else if (type == 15) return set_6(0, 2, 1, >, >, >); else if (type == 16) return set_6(1, 0, 2, <, <, <); else if (type == 17) return set_6(1, 0, 2, <, <,>); else if (type == 18) return set_6(1, 0, 2, <,>, <); else if (type == 19) return set_6(1, 0, 2, <,>, >); else if (type == 20) return set_6(1, 0, 2, >, <, <); else if (type == 21) return set_6(1, 0, 2, >, <,>); else if (type == 22) return set_6(1, 0, 2, >, >, <); else if (type == 23) return set_6(1, 0, 2, >, >, >); else if (type == 24) return set_6(1, 2, 0, <, <, <); else if (type == 25) return set_6(1, 2, 0, <, <,>); else if (type == 26) return set_6(1, 2, 0, <,>, <); else if (type == 27) return set_6(1, 2, 0, <,>, >); else if (type == 28) return set_6(1, 2, 0, >, <, <); else if (type == 29) return set_6(1, 2, 0, >, <,>); else if (type == 30) return set_6(1, 2, 0, >, >, <); else if (type == 31) return set_6(1, 2, 0, >, >, >); else if (type == 32) return set_6(2, 0, 1, <, <, <); else if (type == 33) return set_6(2, 0, 1, <, <,>); else if (type == 34) return set_6(2, 0, 1, <,>, <); else if (type == 35) return set_6(2, 0, 1, <,>, >); else if (type == 36) return set_6(2, 0, 1, >, <, <); else if (type == 37) return set_6(2, 0, 1, >, <,>); else if (type == 38) return set_6(2, 0, 1, >, >, <); else if (type == 39) return set_6(2, 0, 1, >, >, >); else if (type == 40) return set_6(2, 1, 0, <, <, <); else if (type == 41) return set_6(2, 1, 0, <, <,>); else if (type == 42) return set_6(2, 1, 0, <,>, <); else if (type == 43) return set_6(2, 1, 0, <,>, >); else if (type == 44) return set_6(2, 1, 0, >, <, <); else if (type == 45) return set_6(2, 1, 0, >, <,>); else if (type == 46) return set_6(2, 1, 0, >, >, <); else if (type == 47) return set_6(2, 1, 0, >, >, >); } return [&](U l, U r) { return true; };}
template<class... T> void sort(vector<tuple<T...>> &a, tuple_comparator Compare) {auto f = get_function2(a, Compare);fast_sort(ALL(a), f);}
#endif
/*@formatter:off*/
#undef set_4
#undef set_6
#if __cplusplus >= 201703L
//sort_tuple
template<class H1, class H2, class... T> void sortt(vector<H1> &head1, vector<H2> &head2, vector<T> &...tails) { auto vec_t = make_vt(head1, head2, tails...); sort(vec_t); tie_vt(head1, head2, tails...) = vec_t;}
template<class H1, class H2, class... T> void rsortt(vector<H1> &head1, vector<H2> &head2, vector<T> &...tails) { auto vec_t = make_vt(head1, head2, tails...); rsort(vec_t); tie_vt(head1, head2, tails...) = vec_t;}template<class F, class... T> void helper_sortt_f(F f, vector<T> &...a) { auto z = make_vt(a...); sort(z, f); tie_vt(a...) = z;}template<class F, class... T> void helper_rsortt_f(F f, vector<T> &...a) { auto z = make_vt(a...); rsort(z, f); tie_vt(a...) = z;}
//sortt(a,b,c,d, f)まで対応->
template<class A, class B, class F, require_t(!is_vector<F>::value)>
void sortt(vector<A> &a, vector<B> &b, F f) { helper_sortt_f(f, a, b); }
template<class A, class B, class F, require_t(!is_vector<F>::value)>
void rsortt(vector<A> &a, vector<B> &b, F f) { helper_rsortt_f(f, a, b); }template<class A, class B, class C, class F, require_t(!is_vector<F>::value)> void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) { helper_sortt_f(f, a, b, c); }template<class A, class B, class C, class F, require_t(!is_vector<F>::value)> void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) { helper_rsortt_f(f, a, b, c); }template<class A, class B, class C, class D, class F, require_t(!is_vector<F>::value)> void sortt(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d, F f) { helper_sortt_f(f, a, b, c, d); }template<class A, class B, class C, class D, class F, require_t(!is_vector<F>::value)> void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d, F f) { helper_rsortt_f(f, a, b, c, d); }// sort_tuple f }
#endif
/*@formatter:off*/
//任意引数は取らない
template<class T> vi sorti(const vector<T> &a) { auto b = a; vi ind = iota(0, sz(b)); sortt(b, ind); return ind;}
template<class T> vi rsorti(const vector<T> &a) {auto b = a; vi ind = iota(0, sz(b)); rsortt(b, ind); return ind;}
#if __cplusplus >= 201703L
template<class T, class F> vi sorti(const vector<T> &a, F f) { vi ind = iota(0, sz(a)); if constexpr(is_same_v<F, tuple_comparator>) { auto f2 = get_function2(a, f); auto g = [&](int i, int j) { return f2(a[i], a[j]); }; fast_sort(ALL(ind), g); } else { auto g = [&](int i) { return f(a[i]); }; sort(ind, g); } return ind;}
template<class T, class F, require_t(is_function_v<F>)> vi rsorti(const vector<T> &a, F f) { vi ind = iota(0, sz(a)); auto g = [&](int i) { return f(a[i]); }; rsort(ind, g); return ind;}
//任意引数にfを渡したい場合は (make_vt(a, b, c), f)
template<class H, class... Ts> vi sortti(vector<H> head, vector<Ts>... tails) { vi ind = iota(0, sz(head)); auto vec = make_vt(head, tails..., ind); sort(vec); auto rets = take_vt(vec); return get<sizeof...(tails) + 1>(rets);}
template<class H, class... Ts> vi rsortti(vector<H> head, vector<Ts>... tails) { vi ind = iota(0, sz(head)); auto vec = make_vt(head, tails..., ind); rsort(vec); auto rets = take_vt(vec); return get<sizeof...(tails) + 1>(rets);}
#endif
/*@formatter:off*/
template<class... T, class U> auto sorted(U head, T... a) {sort(head, a...);return head;}
template<class... T, class U> auto rsorted(U head, T... a) {rsort(head, a...);return head;}
//@5
void sort(string &a) { sort(ALL(a)); }
void rsort(string &a) { sort(RALL(a)); }
void sort(int &a, int &b) { if (a > b)swap(a, b); }
void sort(int &a, int &b, int &c) { sort(a, b); sort(a, c); sort(b, c);}
void rsort(int &a, int &b) { if (a < b)swap(a, b); }
void rsort(int &a, int &b, int &c) { rsort(a, b); rsort(a, c); rsort(b, c);}
template<class T> bool includes(vector<T> &a, vector<T> &b) { vi c = a; vi d = b; sort(c); sort(d); return includes(ALL(c), ALL(d));}
template<class T> bool distinct(const vector<T> &A) { if ((int) (A).size() == 1)return true; if ((int) (A).size() == 2)return A[0] != A[1]; if ((int) (A).size() == 3)return (A[0] != A[1] && A[1] != A[2] && A[0] != A[2]); auto B = A; sort(B); int N = (B.size()); unique(B); return N == (int) (B.size());}
template<class H, class... T> bool distinct(const H &a, const T &...b) { return distinct(vector<H>{a, b...}); }
/*@formatter:off*/
template<class T, class U> void inc(pair<T, U> &a, U v = 1) { a.first += v, a.second += v; }
template<class T, class U> void inc(T &a, U v = 1) { a += v; }
template<class T, class U = int> 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 = int> 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, class U, class W> void dec(vector<T> &a, vector<U> &b, W v = 1) {for (auto &u :a)dec(u, v);for (auto &u :b)dec(u, v);}
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 san(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 san(0, i, sz(a)) && san(0, j, sz(a)); }
#define inside ins
ll u0(ll a) { return a < 0 ? 0 : a; }
template<class T> vector<T> u0(vector<T> &a) { vector<T> ret = a; fora(v, ret) { v = u(v); } return ret;}
//todo 名前
bool d_(int a, int b) {if (b == 0)return false;return (a % b) == 0;}
//エラー
void ole() {
#ifdef _DEBUG
cerr << "ole" << endl;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(string s = "") {cerr << s << endl;assert(0 == 1);exit(0);}
void tle() { while (inf)cout << inf << endl; }
//@汎用便利関数 入力
ll in() {ll ret;cin >> ret;return ret;}
template<class T> T in() { T 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...);}
//value_typeを持つ場合呼べる
//len回要素を追加する
template<class Iterable, class T = typename Iterable::value_type> Iterable tin(int len) { Iterable ret; T tem; while (len--) { cin >> tem; ret += tem; } return ret;}
template<class T> T tin() { T ret; cin >> ret; return ret;}
template<class T> T tind(int len = 0) { auto ret = tin<T>(len); dec(ret, 1); return ret;}
#define din_t2(type, a) type a;cin>>a
#define din_t3(type, a, b) type a,b;cin>>a>> b
#define din_t4(type, a, b, c) type a,b,c;cin>>a>>b>>c
#define din_t5(type, a, b, c, d) type a,b,c,d;cin>>a>>b>>c>>d
#define din_t6(type, a, b, c, d, e) type a,b,c,d,e;cin>>a>>b>>c>>d>>e
#define din_t7(type, a, b, c, d, e, f) type a,b,c,d,e,f;cin>>a>>b>>c>>d>>e>>f
#define din_t(...) over7(__VA_ARGS__,din_t7,din_t6,din_t5,din_t4,din_t3 ,din_t2)(__VA_ARGS__)
#define din(...) din_t(int,__VA_ARGS__)
#define d_in
#define dsig(...) din_t(signed,__VA_ARGS__)
#define dst(...) din_t(string,__VA_ARGS__)
#define dstr dst
#define d_str dst
#define dcha(...) din_t(char,__VA_ARGS__)
#define dchar dcha
#define ddou(...) din_t(double,__VA_ARGS__)
#define din1d(a) din_t2(int, a);a--
#define din2d(a, b) din_t3(int, a,b);a--,b--
#define din3d(a, b, c) din_t4(int, a,b,c);a--,b--,c--
#define din4d(a, b, c, d) din_t5(int, a,b,c,d);a--,b--,c--,d--
#define dind(...) over4(__VA_ARGS__,din4d,din3d,din2d ,din1d)(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
template<class T> void err2(T &&head) { cerr << head; }
template<class T, class... U> void err2(T &&head, U &&... tail) { cerr << head << " "; err2(tail...);}
template<class T, class... U> void err(T &&head, U &&... tail) { cerr << head << " "; err2(tail...); cerr << "" << endl;}
template<class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
//debで出力する最大長
constexpr int DEB_LEN = 20;
constexpr int DEB_LEN_H = 12;
string deb_tos(const int &v) { if (abs(v) == inf || abs(v) == linf)return "e"; else return to_string(v); }
template<class T> string deb_tos(const T &a) {stringstream ss;ss << a;return ss.str();}
string deb_tos(const P& p){ stringstream ss; ss<<"{"; ss<<p.fi; ss<<", "; ss<<p.se; ss<<"}"; return ss.str();}
#ifdef use_epsdou
string deb_tos(const epsdou &a) {return deb_tos(a.v);}
#endif
template<class T> string deb_tos(const optional<T> &a) { if (a.has_value()) { return deb_tos(a.value()); } else return "e"; }
template<class T> string deb_tos(const vector<T> &a, ll W = inf) { stringstream ss; if (W == inf)W = min(sz(a), DEB_LEN); if (sz(a) == 0)return ss.str(); rep(i, W) { ss << deb_tos(a[i]); if (typeid(a[i]) == typeid(P)) { ss << endl; } else { ss << " "; } } return ss.str();}
template<class T> string deb_tos(const vector<vector<T> > &a, vi H, vi W, int key = -1) { stringstream ss; ss << endl; vi lens(sz(W)); fora(h, H) { rep(wi, sz(W)) { if (sz(a[h]) <= W[wi])break; lens[wi] = max(lens[wi], sz(deb_tos(a[h][W[wi]])) + 1); lens[wi] = max(lens[wi], sz(deb_tos(W[wi])) + 1); } } if (key == -1)ss << " *|"; else ss << " " << key << "|"; int wi = 0; fora(w, W) { ss << std::right << std::setw(lens[wi]) << w; wi++; } ss << "" << endl; rep(i, sz(W))rep(lens[i])ss << "_"; rep(i, 3)ss << "_"; ss << "" << endl; fora(h, H) { ss << std::right << std::setw(2) << h << "|"; int wi = 0; fora(w, W) { if (sz(a[h]) <= w)break; ss << std::right << std::setw(lens[wi]) << deb_tos(a[h][w]); wi++; } ss << "" << endl; } return ss.str();}
template<class T> string deb_tos(const vector<vector<T> > &a, ll H = inf, ll W = inf, int key = -1) { H = (H != inf) ? H : min({H, sz(a), DEB_LEN_H}); W = min({W, sz(a[0]), DEB_LEN_H}); vi hs, ws; rep(h, H) { hs.push_back(h); } rep(w, W) { ws.push_back(w); } return deb_tos(a, hs, ws, key);}
template<class T> string deb_tos(const vector<vector<vector<T> > > &a, ll H = inf) { stringstream ss; if (H == inf)H = DEB_LEN_H; H = min(H, sz(a)); rep(i, H) { ss << endl; ss << deb_tos(a[i], inf, inf, i); } return ss.str();}
template<class T> string deb_tos(vector<set<T> > &a, ll H = inf, ll W = inf, int key = -1) { vector<vector<T> > b(sz(a)); rep(i, sz(a)) { fora(v, a[i]) { b[i].push_back(v); }} return deb_tos(b, H, W, key);}
template<class T, size_t A> string deb_tos(T (&a)[A]) { return deb_tos(vector<T>(begin(a), end(a))); }
template<class T, size_t A, size_t B> string deb_tos(T (&a)[A][B]) { return deb_tos(vector<vector<T> >(begin(a), end(a))); }
template<class T, size_t A, size_t B, size_t C> string deb_tos(T (&a)[A][B][C]) { return deb_tos(vector<vector<vector<T> > >(begin(a), end(a))); }
/*@formatter:off*/
template<class T> void out2(T head) { cout << head; res_mes += deb_tos(head);}
template<class T, class... U> void out2(T head, U ... tail) { cout << head << " "; res_mes += deb_tos(head) + " "; out2(tail...);}
template<class T, class... U> void out(T head, U ... tail) { cout << head << " "; res_mes += deb_tos(head) + " "; out2(tail...); cout << "" << endl; res_mes += "\n";}
template<class T> void out(T head) { cout << head << endl; res_mes += deb_tos(head) + "\n";}
void out() { cout << "" << endl; }
#else
#define err(...);
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;}
#endif
template<class H, class ... T>void outl(const vector<H> &h, const vector<T> &... t) {rep(i, sz(h)) out(h[i], t[i]...);}
//テーブルをスペースなしで出力
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; }
/*@formatter:off*/
template<class T> void na(vector<T> &a, ll n) { a.resize(n); rep(i, n)cin >> a[i];}
template<class T> void na(set<T> &a, ll n) { rep(i, n)a.insert(in()); }
#define dna(a, n) vi a; na(a, n);/*nを複数使うと n==in()の時バグる事に注意*/
#define dnad(a, n) vi a; nad(a, n);
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> void nad(set<T> &a, ll n) { rep(i, n)a.insert(in() - 1); }
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];}
template<class T, class U> void na2(set<T> &a, set<U> &b, ll n) { rep(i, n) { a.insert(in()); b.insert(in()); }}
#define dna2(a, b, n) vi a,b; na2(a,b,n);
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];}
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]--;}
#define dna2d(a, b, n) vi a,b; na2d(a,b,n);
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,b,c; na3(a,b,c,n);
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,b,c; na3d(a,b,c,n);
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,b,c,d; na4(a,b,c,d,n);
#define dna4d(a, b, c, d, n) vi a,b,c,d; na4d(a,b,c,d,n);
#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 dnt(S, h, w) vvi(S,h,w);nt(S,h,w);
#define dntc(S, h, w) vvc(S,h,w);nt(S,h,w);
#define dnts(S, h, w) vvs(S,h,w);nt(S,h,w);
//デバッグ
#define sp << " " <<
/*@formatter:off*/
#define deb1(x) debugName(x)<<" = "<<deb_tos(x)
#define deb_2(x, ...) deb1(x) <<", "<< deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) <<", "<< deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) <<", "<< deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) <<", "<< deb_4(__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__)
/*@formatter:off*/
#ifdef _DEBUG
#define deb(...) do{was_deb=true;cerr<< over10(__VA_ARGS__,deb10,deb9,deb8,deb7,deb6,deb5,deb_4,deb_3,deb_2,deb1)(__VA_ARGS__) <<endl;}while(0)
void print_n_base(int x, int base) {string S;while (x) {S += (char)('0'+x % base);x /= base;}cerr << S << endl;}
template<class T> void print_n_base(vector<T> X, int base) {cerr << endl; for (auto &&x:X) { print_n_base(x, base); } cerr << endl;}
//n進数
#define deb2(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 2);
#define deb3(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 3);
#define deb4(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 4);
#define deb_ex_deb(x, len) debugName(x)<<" = "<<deb_tos(x, len)
#define call_deb_ex_deb(x, len) deb_ex_deb(x, len)
//要素が存在する行だけ出力(vvt)
#define deb_ex(v) do {int N = sz(v);int s = N;int t = 0;rep(i, N) {if (sz(v[i])) {chmi(s, i);chma(t, i);}}auto ex_v = sub(v, s, N);str S = deb_tos(ex_v, sz(ex_v));debugName(v);cerr<<" = "<<endl;cerr << S << endl;} while (0);
#define debi(A) {int len=min(sz(A),20); was_deb=true;cerr<<debugName(A)<<" = "<<endl;rep(i, len)cerr<<std::right << std::setw((int)(sz(tos(A[i]))+(i ? 1 : 0)))<<(i%10);cerr<<endl;rep(i, len)cerr<<std::right << std::setw((int)(sz(tos(A[i]))+(i ? 1 : 0)))<<A[i];cerr<<endl;}
template<class T, class F> string deb_tos_f(vector<T> &A, F f) { vi I; rep(i, sz(A)) { if (f(A[i]))I.push_back(i); } was_deb = true; stringstream ss; fora(ii, i, I)ss << std::right << std::setw((int) (max(sz(tos(A[i])), sz(tos(i))) + (ii ? 1 : 0))) << i; ss << endl; fora(ii, i, I)ss << std::right << std::setw((int) (max(sz(tos(A[i])), sz(tos(i))) + (ii ? 1 : 0))) << A[i]; return ss.str();}
template<class T, class F> string deb_tos_f(vector<vector<T> > &a, F f, int key = -1) {vi hs, ws_; int H = sz(a), W = sz(a[0]); vi exh(H), exw(W); rep(h, H) { rep(w, W) { if (f(a[h][w])) { exh[h] = true; exw[w] = true; } } } rep(h, H) if (exh[h])hs.push_back(h); rep(w, W) if (exw[w])ws_.push_back(w); return deb_tos(a, hs, ws_, key);}
template<class T, class F> string deb_tos_f(vector<vector<vector<T>>> &a, F f) { stringstream ss; int H = sz(a); if (sz(a) == 0)return ss.str(); int cou = 0; rep(i, H) { if (any_of(a[i], v, f(v))) { ss << deb_tos_f(a[i], f, i); cou++; } if(cou>50)break; } ss << "" << endl; return ss.str();}
#define debf_normal(tab, f) do{cerr<<debugName(tab)<<" = "<<endl;cerr<< deb_tos_f(tab, f)<<endl;}while(0);
#define debf2(tab, siki_r) debf_normal(tab, lamr(siki_r))
#define debf3(tab, v, siki) debf_normal(tab, lam(siki))
//S, sikir
//S, v, siki
#define debf(...) over3(__VA_ARGS__,debf3,debf2,debf1)(__VA_ARGS__)
#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#define deb_ex(...) ;
#define debf(...) ;
#define debi(...) ;
#endif
#define debugline(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n'
/*@formatter:off*/
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
using bint =__int128;
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 to_bint(string &s) {__int128 ret = 0; for (ll i = 0; i < (ll) s.length(); ++i) if ('0' <= s[i] && s[i] <= '9') ret = 10 * ret + s[i] - '0'; return ret;}
void operator>>(istream &iss, bint &v) {string S; iss >> S; v = 0; rep(i, sz(S)) { v *= 10; v += S[i] - '0'; }}
//便利関数
/*@formatter:off*/
//テスト用
#define rand xor128_
unsigned long xor128_(void) {static unsigned long x = 123456789, y = 362436069, z = 521288629, w = 88675123; unsigned long t; t = (x ^ (x << 11)); x = y; y = z; z = w; return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));}
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); }}}
ll rand(ll max) { return rand(0, max); }
template<class T> T rand(vector<T> &A) { return A[rand(sz(A) - 1)]; }
//重複することがある
template<class T> vector<T> ranv(vector<T> &A, int N) {vector<T> ret(N); rep(i, N) { ret[i] = rand(A); } return ret;}
template<class T> vector<T> ranv_unique(vector<T> &A, int N) {vector<T> ret(N); umapi was; rep(j, N) { int i; while (1) { i = rand(sz(A) - 1); if (was.find(i) == was.end())break; } ret[j] = A[i]; was[i] = 1; } return ret;}
vi ranv(ll n, ll min, ll max) {vi v(n); rep(i, n)v[i] = rand(min, max); return v;}
/*@formatter:off*/
#ifdef _DEBUG
bool timeup(int time) {static bool never = true; if (never)message += "may timeup, because slow"; never = false; auto end_time = system_clock::now(); auto part = duration_cast<milliseconds>(end_time - start_time); auto lim = milliseconds(time); return part >= lim;}
#else
bool timeup(int time) {
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#endif
void set_time() { past_time = system_clock::now(); }
//MS型(millisecqnds)で返る
//set_timeをしてからの時間
auto calc_time_milli() {auto now = system_clock::now(); auto part = duration_cast<milliseconds>(now - past_time); return part;}
auto calc_time_micro() {auto now = system_clock::now(); auto part = duration_cast<microseconds>(now - past_time); return part;}
auto calc_time_nano() {auto now = system_clock::now(); auto part = duration_cast<nanoseconds>(now - past_time); return part;}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS=std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {if (b < nanoseconds(1)) { return a / nanoseconds(1); } int v = a / b; return v;}
//set_time();
//rep(i,lim)shori
//lim*=time_nanbai();
//rep(i,lim)shoriと使う
//全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {auto dec = duration_cast<nanoseconds>(past_time - start_time); auto part = calc_time_nano(); auto can_time = nanoseconds(milli * 1000 * 1000); can_time -= part; can_time -= dec; return div(can_time, part);}
/*@formatter:off*/
//#define use_rand
#ifdef use_rand
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;}
//便利 汎用
#endif
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]); }}
template<class Iterable, class T = typename Iterable::value_type> vector<pair<T, int>> run_length(const Iterable &a) {vector<pair<T, int>> 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;}
/*@formatter:off*/
//#define use_mgr //_goldd _goldt
#ifdef use_mgr
//->[i, f(i)]
template<class T, class U, class F> auto mgr(T ok, U ng, const F &f, require_arg(is_integral<T>::value &&is_integral<U>::value)) { auto mid = (ok + ng); if (ok < ng) while (ng - ok > 1) { mid = (ok + ng) >> 1; if (f(mid))ok = mid; else ng = mid; } else while (ok - ng > 1) { mid = (ok + ng) >> 1; if (f(mid))ok = mid; else ng = mid; } return ok;}
//[l, r)の中で,f(i)がtrueとなる範囲を返す okはそこに含まれる
template<class F> P mgr_range(int l, int r, F f, int ok) {if (f(ok) == 0) { out("f(ok) must true"); re(); } return mp(mgr(ok, l - 1, f), mgr(ok, r, f) + 1);}
template<class F> auto mgrd(dou ok, dou ng, F f, int kai = 100) {if (ok < ng) rep(i, kai) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid; else ng = mid; } else rep(i, kai) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid; else ng = mid; } return ok;}
template<class F> dou mgrd_time(dou ok, dou ng, F f, int time = 1980) {bool han = true; if (ok < ng) while (1) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid, han = true; else ng = mid, han = false; deb(mid, han); if (timeup(time)) { break; } } else while (1) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid, han = true; else ng = mid, han = false; deb(mid, han); if (timeup(time)) { break; } } return ok;}
//todo 減らす
template<class F> auto 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 make_tuple(resIndex, calc(resIndex));}
template<class F> auto 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 make_tuple(resIndex, calc(resIndex));}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template<class F> auto 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 make_tuple(left, calc(left));}
template<class F> auto 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 make_tuple(left, calc(left));}
//l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template<class F> auto 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 make_tuple(mini, calc(mini));}
template<class F> auto 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 make_tuple(maxi, calc(maxi));}
template<class F> auto 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 make_tuple(mini, calc(mini));}
template<class F> auto 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 make_tuple(maxi, calc(maxi));}
#endif
//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; }
//エラー-1
template<typename W, typename T> ll find(vector<W> &a, int l, const T key) {rep(i, l, sz(a))if (a[i] == key)return i;return -1;}
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);}
//getid(find())を返す 1次元にする
template<typename W, typename T> int findi(vector<vector<W >> &a, const T key) {rep(i, sz(a))rep(j, sz(a[0]))if (a[i][j] == key)return i * sz(a[0]) + j;return -1;}
template<typename W, typename U> tuple<int, int, int> 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 tuple<int, int, int>(i, j, k); return tuple<int, int, int>(-1, -1, -1);}
//無ければ-1
int find(string &s, const string key) { int klen = sz(key); rep(i, sz(s) - klen + 1) { if (s[i] != key[0])continue; if (s.substr(i, klen) == key) { return i; } }return -1;}
int find(string &s, int l, const string key) { int klen = sz(key); rep(i, l, sz(s) - klen + 1) { if (s[i] != key[0])continue; if (s.substr(i, klen) == key) { return i; } } return -1;}
int find(string &s, const char key) { rep(i, sz(s)) { if (s[i] == key)return i; } return -1;}
int find(string &s, int l, const char key) { rep(i, l, sz(s)) { if (s[i] == key)return i; } return -1;}
//N箇所について右のkeyの場所を返す
template<typename W, typename T> vi finds(const W &a, const T& key) { int n = sz(a); vi rpos(n, -1); rer(i, n-1){ if(i<n-1){ rpos[i] = rpos[i+1]; } if(a[i]==key)rpos[i] = i; } return rpos;}
template<typename W, typename T> vi rfinds(const W &a, const T& key) { int n = sz(a); vi lpos(n, -1); rep(i, n){ if(i> 0){ lpos[i] = lpos[i-1]; } if(a[i]==key)lpos[i] = i; } return lpos;}
//todoz
#if __cplusplus >= 201703L
template<typename W, typename T, class Iterable = typename W::value_type>
ll count(const W &a, const T &k) { return count_if(a, ==k); }
template<typename W, class Iterable = typename W::value_type> vi count(const W &a) {
vi res;
for_each(a, v, if (sz(res) <= (int) v)res.resize((int) v + 1);
res[v]++;);
return res;
}
#else
ll count(const string& S, const char& c){
int res=0;
fora(s, S){
res += s==c;
}
return res;
}
#endif
ll count(const str &a, const 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;}
/*@formatter:off*/
//'a' = 'A' = 0 として集計 既に-'a'されていても動く
vi count(str &a, int l, int r) { vi cou(26); char c = 'a'; if ('A' <= a[l] && a[l] <= 'Z')c = 'A'; if ('a' <= a[l] && a[l] <= 'z') c = 'a'; else c = 0; rep(i, l, r)++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> auto rev(const vector<T> &a) { auto b = a; reverse(ALL(b)); return b;}
/* ＼反転 */ template<class U>
auto 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]; return b;}
/* ｜反転 */ template<class U>
auto revw(vector<vector<U>> &a) { vector<vector<U> > b(sz(a), vector<U>(sz(a[0]))); int W = sz(a[0]); rep(h, sz(a)) rep(w, sz(a[0])) { b[h][W - 1 - w] = a[h][w]; } return b;}
/* ー反転 */ template<class U>
auto revh(vector<vector<U>> &a) { vector<vector<U> > b(sz(a), vector<U>(sz(a[0]))); int H = sz(a); rep(h, sz(a)) rep(w, sz(a[0])) { b[H - 1 - h][w] = a[h][w]; } return b;}
/* ／反転 */ template<class U>
auto revr(vector<vector<U>> &a) { vector<vector<U> > b(sz(a[0]), vector<U>(sz(a))); int H = sz(a); int W = sz(a[0]); rep(h, sz(a)) rep(w, sz(a[0]))b[w][h] = a[H - 1 - h][W - 1 - w]; return b;}
auto rev(const string &a) { string b = a; reverse(ALL(b)); return b;}
template<class T> auto rev(const T &v, int i) {return v[sz(v) - 1 - i];}
int rev(int N, int i) {return N-1-i;}
constexpr ll p10[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000ll, 100000000000ll, 1000000000000ll, 10000000000000ll, 100000000000000ll, 1000000000000000ll, 10000000000000000ll, 100000000000000000ll, 1000000000000000000ll};
//0は0桁
ll keta(ll v, int if_zero_res) { if(!v)return if_zero_res;if (v < p10[9]) { if (v < p10[4]) { if (v < p10[2]) { if (v < p10[1]) { if (v < p10[0])return 0; else 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 return 15; } else { if (v < p10[17]) { if (v < p10[16]) return 16; else return 17; } else { if (v < p10[18])return 18; else return 19; }}}}}
#if __cplusplus >= 201703L
ll getr(ll a, ll keta) { return (a / pow<ll>(10, keta)) % 10; }
#else
ll getr(ll a, ll keta) { return (a / (int)pow(10, keta)) % 10; }
#endif
//上から何桁目か
ll getl(ll a, ll ket) {int sketa = keta(a, 1);return getr(a, sketa - 1 - ket);}
ll dsum(ll v, ll sin = 10) {ll ret = 0;for (; v; v /= sin)ret += v % sin;return ret;}
ll mask10(ll v) { return p10[v] - 1; }
//変換系
template<class T, class U> auto to_v1(vector<reference_wrapper<U>>& ret, vector<T> &A) { rep(i, sz(A))ret.push_back(A[i]); return ret;}
template<class T, class U> auto to_v1(vector<reference_wrapper<U>>& ret, vector<vector<T> > &A) {rep(i, sz(A))to_v1(ret, A[i]);return ret;}
//参照付きで1次元に起こす
template<class T> auto to_v1(vector<vector<T> > &A) { vector<reference_wrapper<decl2_t<decltype(A)>>> ret; rep(i, sz(A))to_v1(ret, A[i]); return ret;}
//[v] := iとなるようなvectorを返す
//存在しない物は-1
//空でも動く(なぜか)
template<class T> auto keys(const T &a) {vector<decltype((a.begin())->fi)> res;for (auto &&k :a)res.push_back(k.fi);return res;}
template<class T> auto values(const T &a) {vector<decltype((a.begin())->se)> res;for (auto &&k :a)res.push_back(k.se);return res;}
//todo 可変長で
template<class T> constexpr T min(T a, T b, T c) { return a >= b ? b >= c ? c : b : a >= c ? c : a; }
template<class T> constexpr T max(T a, T b, T c) { return a <= b ? b <= c ? c : b : a <= c ? c : a; }
//1次元のコンテナ
template<class T> int mini(const vector<T> &a) { return min_element(ALL(a)) - a.begin(); }
template<class T> int maxi(const vector<T> &a) { return max_element(ALL(a)) - a.begin(); }
template<class T> T sum(const T &A) {return A;}
template<class T> T sum(const vector<T> &A, int l = -1, int r = -1) {T s = 0;set_lr12(l, r, sz(A));rep(i, l, r)s += sum(A[i]);return s;}
//1次元のIterableに使える
template<class T, require_t(!has_value_type<T>::value)>T min(T &a) { return a; }
template<class V, require_t(has_value_type<V>::value)>auto min(V &a, ll s = -1, ll n = -1) { using Ret_t = decl2_t<V>; auto ret = MAX<Ret_t>(); set_lr12(s, n, sz(a)); if (s == n) { return INF<Ret_t>(); } else { rep(i, s, n) { ret = min(ret, min(a[i])); } return ret; }}
template<class T, require_t(!has_value_type<T>::value)> T max(T &a) { return a; }
template<class V, require_t(has_value_type<V>::value)> auto max(V &a, ll s = -1, ll n = -1) { using Ret_t = decl2_t<V>; auto ret = MIN<Ret_t>(); set_lr12(s, n, sz(a)); if (s == n) { return -INF<Ret_t>(); } else { rep(i, s, n) { ret = max(ret, max(a[i])); } return ret; }}
template<class T> T mul(vector<T> &v, ll t = inf) {T ret = v[0];rep(i, 1, min(t, sz(v)))ret *= v[i];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;}
//indexを持つvectorを返す
/*@formatter:off*/
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<W> &xx, const T v, int s, ll t) { rep(i, s, t)xx[i] = v; }
template<typename W, typename T> void fill(vector<vector<W>> &xx, T v, int sh, int th, int sw, int tw) { rep(h, sh, th)rep(w, sw, tw)xx[h][w] = v; }
//#define use_fill //_sum _array _max _min
#ifdef use_fill
template<typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) { rep(i, N){fill(a[i], v);}}
template<class T, class U> void fill(vector<T> &a, const vi &ind, U val) { fora(v, ind) { a[v] = val; }}
template<typename A, size_t N> auto sum(A (&a)[N], int l = -1, int r = -1) {set_lr12(l, r, N);auto res = sum(a[l]);if (l == r) {return res - res;}rep(i, l + 1, r)res += sum(a[i]);return res;}
template<typename A, size_t N> auto max(A (&a)[N], int l = -1, int r = -1) { set_lr12(l, r, N); auto res = max(a[l]); if (l == r) { return -INF<decltype(res)>(); } rep(i, l + 1, r)res = max(res, max(a[i])); return res;}
template<typename A, size_t N> auto min(A (&a)[N], int l = -1, int r = -1) { set_lr12(l, r, N); auto res = min(a[l]); if (l == r) { return INF<decltype(res)>(); } rep(i, l + 1, r)res = min(res, min(a[i])); return res;}
#endif
vi inds_(vi &a) { int n = max(a) + 1; vi ret(n, -1); rep(i, sz(a)) { assert(ret[a[i]] ==-1);ret[a[i]] = i; } return ret;}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
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;}
template<class T> struct ruiC {
vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
/*先頭0*/
ruiC() : rui(1, 0) {}
T operator()(ll l, ll r) { if (l > r) { cerr << "ruic "; deb(l, r); assert(0); } return rui[r] - rui[l]; }
T operator()(int r = inf) { return operator()(0, min(r, sz(rui) - 1)); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
T operator[](ll i) { return rui[i]; }
/*0から順に追加される必要がある*/
void operator+=(T v) { rui.push_back(rui.back() + v); }
void add(int i, T v) {if (sz(rui) - 1 != i)ole();operator+=(v);}
T back() { return rui.back(); }
ll size() { return rui.size(); }
auto begin() { return rui.begin(); }
auto end() { return rui.end(); }
};
template<class T> string deb_tos(const ruiC<T> &a) {return deb_tos(a.rui);}
template<class T> ostream &operator<<(ostream &os, ruiC<T> a) { fora(v, a.rui){os << v << " "; } return os;}
template<class T> vector<T> ruiv(const 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(const vector<T> &a) { vector<T> ret = ruiv(a); return ruiC<T>(ret);}
template<class T> ruiC<T> ruic() { return ruiC<T>(); }
//imoは0-indexed
//ruiは1-indexed
template<class T> vector<T> imo(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)ret[i + 1] += ret[i]; return ret;}
//#define use_rui //_imo _ruic _ruiv
#ifdef use_rui
//kと同じものの数
template<class T, class U> vi imo(const vector<T> &a, U k) { vi equ(sz(a)); rep(i, sz(a)){ equ[i] = a[i]==k; } return imo(equ);}
template<class T> vector<T> imox(const 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(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)chmi(ret[i + 1], ret[i]); return ret;}
template<class T> vector<T> ima(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)chma(ret[i + 1], ret[i]); return ret;}
template<class T> vector<T> rimi(const vector<T> &v) { vector<T> ret = v; rer(i, sz(ret) - 1, 1)chmi(ret[i - 1], ret[i]); return ret;}
template<class T> vector<T> rima(const vector<T> &v) { vector<T> ret = v; rer(i, sz(ret) - 1, 1)chma(ret[i - 1], ret[i]); return ret;}
template<class T> struct ruimax {
template<typename Monoid> struct SegmentTree { /*pairで処理*/ int sz; vector<Monoid> seg; const Monoid M1 = mp(MIN<T>(), -1); Monoid f(Monoid a, Monoid b) { return max(a, b); } void build(vector<T> &a) { int n = sz(a); sz = 1; while (sz < n) sz <<= 1; seg.assign(2 * sz, M1); rep(i, n) { seg[i + sz] = mp(a[i], i); } for (int k = sz - 1; k > 0; k--) { seg[k] = f(seg[k << 1], seg[(k << 1) | 1]); } } Monoid query(int a, int b) { Monoid L = M1, R = M1; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) L = f(L, seg[a++]); if (b & 1) R = f(seg[--b], R); } return f(L, R); } Monoid operator[](const int &k) const { return seg[k + sz]; } };
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
public:
int n;
ruimax(vector<T> &a) : ve(a), n(sz(a)) { int index = -1; T ma = MIN<T>(); rv.resize(n + 1); ri.resize(n + 1); rv[0] = -INF<T>(); ri[0] = -1; rep(i, n) { if (chma(ma, a[i])) { index = i; } rv[i + 1] = ma; ri[i + 1] = index; } }
T operator()(int l, int r) { if (!(l <= r && 0 <= l && r <= n)) { deb(l, r, n); assert(0); } if (l == 0) { return rv[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).first; } }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } }
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template<class T> struct ruimin {
template<typename Monoid> struct SegmentTree { /*pairで処理*/ int sz;vector<Monoid> seg; const Monoid M1 = mp(MAX<T>(), -1); Monoid f(Monoid a, Monoid b) { return min(a, b); } void build(vector<T> &a) { int n = sz(a); sz = 1; while (sz < n) sz <<= 1; seg.assign(2 * sz, M1); rep(i, n) { seg[i + sz] = mp(a[i], i); } for (int k = sz - 1; k > 0; k--) { seg[k] = f(seg[k << 1], seg[(k << 1) | 1]); } } Monoid query(int a, int b) { Monoid L = M1, R = M1; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) L = f(L, seg[a++]); if (b & 1) R = f(seg[--b], R); } return f(L, R); } Monoid operator[](const int &k) const { return seg[k + sz]; } };
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
int n;
public:
ruimin(vector<T> &a) : ve(a), n(sz(a)) { int index = -1; T mi = MAX<T>(); rv.resize(n + 1); ri.resize(n + 1); rv[0] = INF<T>(); ri[0] = -1; rep(i, n) { if (chmi(mi, a[i])) { index = i; } rv[i + 1] = mi; ri[i + 1] = index; } }
T operator()(int l, int r) { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return rv[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).first; } }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) { { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } } assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } }
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};/*@formatter:off*/
vvi() ruib(vi &a) { vvi(res, 61, sz(a) + 1); rep(k, 61) { rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }} return res;}
vector<ruiC<int>> ruibc(vi &a) {vector<ruiC<int>> ret(61); vvi(res, 61, sz(a)); rep(k, 61) { rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; } ret[k] = ruic(res[k]); } return 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);}
template<class T> struct ruiC2 {
int H;
vector<ruiC<T>> rui;
ruiC<T> dummy;//変なのをよばれたときはこれを返す//todo
ruiC2(const vector<vector<T>> &ru) : rui(sz(ru)), H(sz(ru)) { for (int h = 0; h < H; h++) { if (sz(ru[h]) == 0)continue; if (sz(dummy) == 1) dummy = ruic(vector<T>(sz(ru[h]))); rui[h] = ruic(ru[h]); } }
//WについてHを返す
vector<T> operator()(ll l, ll r) { if (l > r) { cerr << "ruic "; deb(l, r); assert(0); } vector<T> res(H); for (int h = 0; h < H; h++)res[h] = rui[h](l, r); return res; }
//HについてWを返す
ruiC<T> &operator[](ll h) {
#ifdef _DEBUG
if (h >= H) {message += "warning ruiC h >= H";}
#endif
if (h >= H || sz(rui[h]) == 1)return dummy;else return rui[h];
}
/*@formatter:off*/
// vector<T> operator()(int r) { return operator()(0, r); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
/*0から順に追加される必要がある*/
// T back() { return rui.back(); }
// ll size() { return rui.size(); }
// auto begin(){return rui.begin();}
// auto end(){return rui.end();}
};
template<class T, class U> ruiC<ll> ruicou(vector<T> &a, U b) { vi cou(sz(a)); rep(i, sz(a)) { cou[i] = a[i] == b; } return ruic(cou);}
//メモリは形式によらず(26*N)
// rui(l,r)でvector(26文字について, l~rのcの個数)
// rui[h] ruic()を返す
// 添え字は'a', 'A'のまま扱う (予め-='a','A'されているものが渡されたらそれに従う)
template<typename Iterable, class is_Iterable = typename Iterable::value_type>
ruiC2<ll> ruicou(const Iterable &a) { int H = max(a) + 1; vvi(cou, H); rep(i, sz(a)) { if (sz(cou[a[i]]) == 0)cou[a[i]].resize(sz(a)); cou[a[i]][i] = 1; } return ruiC2<ll>(cou); }
/*@formatter:off*/
//h query
template<class T> vector<T> imoh(vector<vector<T>> &v, int w) { vector<T> ret(sz(v)); rep(h, sz(ret)) { ret[h] = v[h][w]; } rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; } return ret;}
template<class T> vector<T> ruih(vector<vector<T>> &v, int w) { vector<T> ret(sz(v) + 1); rep(h, sz(v)) { ret[h + 1] = v[h][w]; } rep(i, sz(v)) { ret[i + 1] += ret[i]; } return ret;}
template<class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) { vector<T> ret = ruih(a, w); return ruiC<T>(ret);}
//xor
template<class T> struct ruixC {
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);}
//差分を返す(累積を取ると元に戻る)
//101なら
//1111を返す
//元の配列で[l, r)へのxorは
//[l]と[r]へのxorになる https://atcoder.jp/contests/abc155/tasks/abc155_f
vi ruix_diff(vi &A) { int N = sz(A); assert(N); vi res(N + 1); res[0] = A[0]; rep(i, 1, N) { res[i] = A[i - 1] ^ A[i]; } res[N] = A[N - 1]; return res;}
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> struct rruiC {
vector<T> rui;
int n;
rruiC(vector<T> &a) : n(sz(a)) { rui.resize(n + 1); rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; } }
/*[r l)*/
T operator()(int r, int l) { r++; l++; assert(l <= r && l >= 0 && r <= n); return rui[l] - rui[r]; }
T operator()(int l) { return operator()(n - 1, l); }
T operator[](int i) { return operator()(i); }
};
template<class T> ostream &operator<<(ostream &os, rruiC<T> a) { fora(v, a.rui){os << v << " "; } return os;}
template<class T> string deb_tos(rruiC<T> &a) {return deb_tos(a.rui);}
#define rrui rruic
template<class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }
//掛け算
template<class T> struct ruimulC {
vector<T> rv;
int n;
ruimulC(vector<T> &a) : rv(a), n(sz(a)) { rv.resize(n + 1); rv[0] = 1; rep(i, n) { rv[i + 1] = a[i] * rv[i]; } }
ruimulC() : n(0) { rv.resize(n + 1); rv[0] = 1; }
void operator+=(T v) { rv.push_back(rv.back() * v); n++; }
T operator()(int l, int r) { assert(l <= r && 0 <= l && r <= n); return rv[r] / rv[l]; }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template<class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template<class T> ruimulC<T> ruimul() { vector<T> a; return ruimulC<T>(a);}
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, class W> T lowerBound(ruiC <T> &a, U v, W banpei) { return lowerBound(a.rui, v, banpei); }
template<class T, class U, class W> T upperBound(ruiC <T> &a, U v, W banpei) { return upperBound(a.rui, v, banpei); }
template<class T, class U, class W> T rlowerBound(ruiC <T> &a, U v, W banpei) { return rlowerBound(a.rui, v, banpei); }
template<class T, class U, class W> T rupperBound(ruiC <T> &a, U v, W banpei) { return rupperBound(a.rui, v, banpei); }
#endif
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62);//オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
//bget(n)次元
// NならN-1まで
vector<vi> bget2(vi &a, int keta_size) { vvi(res, keta_size, sz(a)); rep(k, keta_size) { rep(i, sz(a)) { res[k][i] = bget(a[i], k); }} return res;}
vi bget1(vi &a, int keta) { vi res(sz(a)); rep(i, sz(a)) { res[i] = bget(a[i], keta); } return res;}
#if __cplusplus >= 201703L
ll bget(ll m, ll keta, ll sinsuu) { m /= pow<ll>(sinsuu, keta); return m % sinsuu;}
#else
ll bget(ll m, ll keta, ll sinsuu) { m /= (ll)pow(sinsuu, keta); return m % sinsuu;}
#endif
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62);//オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
#if __cplusplus >= 201703L
ll bit(ll n, ll sinsuu) { return pow<ll>(sinsuu, n); }
#else
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
#endif
ll mask(ll n) { return (1ll << n) - 1; }
//aをbitに置きなおす
//{0, 2} -> 101
ll bit(const vi &a) { int m = 0; for (auto &&v:a) m |= bit(v); return m;}
//{1, 1, 0} -> 011
//bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bit_bool(vi &a) { int m = 0; rep(i, sz(a)) if (a[i])m |= bit(i); return m;}
#define bcou __builtin_popcountll
//最下位ビット
ll lbit(ll n) { assert(n);return n & -n; }
ll lbiti(ll n) { assert(n);return log2(n & -n); }
//最上位ビット
ll hbit(ll n) { assert(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) { assert(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;}
/*over*/#define forbit1_2(i, mas) for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, i = !mas ? 0 :log2(forbitj); forbitm; forbitm = forbitm ^ forbitj, forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
/*over*/#define forbit1_3(i, N, mas) for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, i = !mas ? 0 :log2(forbitj); forbitm && i < N; forbitm = forbitm ^ forbitj, forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
//masの立ってるindexを見る
// i, [N], mas
#define forbit1(...) over3(__VA_ARGS__, forbit1_3, forbit1_2)(__VA_ARGS__)
//masが立っていないindexを見る
// i, N, mas
#define forbit0(i, N, mas) forbit1(i, (mask(N) & (~(mas))))
//forsubをスニペットして使う
//Mの部分集合(0,M含む)を見る 3^sz(S)個ある
#define forsub_all(m, M) for (int m = M; m != -1; m = m == 0 ? -1 : (m - 1) & M)
//BASE進数
template<size_t BASE> class base_num {
int v;
public:
base_num(int v = 0) : v(v) {};
int operator[](int i) { return bget(v, i, BASE); }
void operator++() { v++; }
void operator++(signed) { v++; }
operator int() { return v; }
};
#define base3(mas, lim, BASE) for (base_num<BASE> mas; mas < lim; mas++)
#define base2(mas, lim) base3(mas, lim, 2)
#define base(...) over3(__VA_ARGS__,base3,base2,base1)(__VA_ARGS__)
//aにある物をtrueとする
vb bool_(vi a, int n) { vb ret(max(max(a) + 1, n)); rep(i, sz(a))ret[a[i]] = true; return ret;}
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; } res = 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 use_compress
//[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;}
#ifdef use_compress
//ind[i] := i番目に小さい数
//map[v] := vは何番目に小さいか
vi compress(vi &a, umapi &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(); }}
#endif
//要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(ALL(a),v))
#define lowerIndex(a, v) (lower_bound(ALL(a),v)-a.begin())
#define upperIndex(a, v) (upper_bound(ALL(a),v)-a.begin())
#define rlowerIndex(a, v) (upper_bound(ALL(a),v)-a.begin()-1)
#define rupperIndex(a, v) (lower_bound(ALL(a),v)-a.begin()-1)
template<class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) { auto it = lower_bound(a.begin(), a.end(), v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) { auto it = upper_bound(a.begin(), a.end(), v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(vector<T> &a, U v, W banpei) { auto it = upper_bound(a.begin(), a.end(), v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(vector<T> &a, U v, W banpei) { auto it = lower_bound(a.begin(), a.end(), v); if (it == a.begin())return banpei; else { return *(--it); }}
//todo 消せないか
template<class T, class U, class W> T lowerBound(set<T> &a, U v, W banpei) { auto it = a.lower_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(set<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(set<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(set<T> &a, U v, W banpei) {auto it = a.lower_bound(v);if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T lowerBound(mset<T> &a, U v, W banpei) { auto it = a.lower_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(mset<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(mset<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(mset<T> &a, U v, W banpei) {auto it = a.lower_bound(v);if (it == a.begin())return banpei; else { return *(--it); }}
#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) {out(s...); exit(0); }
//便利 数学 math
//sub ⊂ top
bool subset(int sub, int top) {return (sub & top) == sub;}
//-180 ~ 180 degree
double atand(double h, double w) {return atan2(h, w) / PI * 180;}
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {if (m < 0) m *= -1;return (a % m + m) % m;}
//ll pow(ll a) { return a * a; };
template<class T> T fact(int v) { static vector<T> fact(2, 1); if (sz(fact) <= v) { rep(i, sz(fact), v + 1) { fact.emplace_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];}
//二項係数の偶奇を返す
int com_mod2(int n,int r){return n == ( r | (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];}
#define gcd my_gcd
template<class T, class U, class V = typename max_type<T, U>::type>
V gcd(T a_, U b_) { V a = a_; V b = b_; while (b) a %= b, swap(a, b); return abs(a);}
template<class T>T gcd(const vector<T>& b) { T res = b[0]; rep(i, 1, sz(b))res = gcd(b[i], res); return res;}
#define lcm my_lcm
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; }}
#define hypot my_hypot
double hypot(double dx, double dy){return std::sqrt(dx*dx+ dy*dy);}
ll sig0(int t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
bint sig0(bint t) {return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
//ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {if (s > t)swap(s, t);return sig0(t - s) + s * (t - s + 1);}
#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) { assert(((v - st) % ad) == 0); return (v - st) / ad;}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad;}
// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) { if (st >= v) return st; return (v - st + ad - 1) / ad * ad + st;}
//第何項か
ll lower_tosa_i(ll st, ll ad, ll v) { if (st >= v) return 0; return (v - st + ad - 1) / ad;}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }
//b * res <= aを満たす [l, r)を返す div
P drange_ika(int a, int b) { P null_p = mp(linf, linf); if (b == 0) { if (a >= 0) { return mp(-linf, linf + 1)/*全て*/; } else { return null_p/*無い*/; } } else { if (a >= 0) { if (b > 0) { return mp(-linf, a / b + 1); } else { return mp(-(a / -b), linf + 1); } } else { if (b > 0) { return mp(-linf, -ceil(-a, b) + 1); } else { return mp(ceil(-a, -b), linf + 1); } } }}
//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); }
/*@formatter:off*/
//機能拡張
#define dtie(a, b) int a, b; tie(a, b)
template<class T, class U> string to_string(T a, U b) { string res = ""; res += a; res += b; return res;}
template<class T, class U, class V> string to_string(T a, U b, V c) { string res = ""; res += a; res += b; res += c; return res;}
template<class T, class U, class V, class W> string to_string(T a, U b, V c, W d) { string res = ""; res += a; res += b; res += c; res += d; return res;}
template<class T, class U, class V, class W, class X> string to_string(T a, U b, V c, W d, X e) { string res = ""; res += a; res += b; res += c; res += d; res += e; return res;}
//todo stringもセットで
//find_ifはsubrを使う
string sub(string &A, int l, int r) { assert(0 <= l && l <= r && r <= sz(A)); return A.substr(l, r - l);}
template<class T> vector<T> sub(const vector<T> &A, int l, int r) { assert(0 <= l && l <= r && r <= sz(A)); vector<T> ret(r - l); std::copy(A.begin() + l, A.begin() + r, ret.begin()); return ret;}
template<class T> vector<T> sub(const vector<T> &A, int r) { return sub(A, 0, r); }
#if __cplusplus >= 201703L
template<class I, require_t(has_value_type<I>::value)> I subn(const I &A, int l, int len) { return sub(A, l, l + len); }
#endif
template<class T, class F>
//sub2で呼ぶ
vector<T> sub(const vector<vector<T> >& A, int h, int w, int ah,int aw, F f){ vector<T> res; while(0<= h && h < sz(A) && 0 <= w && w < sz(A[h]) && f(A[h][w])){ res.emplace_back(A[h][w]); h += ah; w += aw; } return res;}
template<class T> vector<T>sub(const vector<vector<T> >& A, int h, int w, int ah,int aw){return sub(A, h, w, ah, aw, [&](T v){return true;});}
//range_nowを返す(find_ifでしか使われない)
#if __cplusplus >= 201703L
template<class T> auto subr(const vector<T> &A, int l) {return range_now(vector<T>(A.begin()+l, A.end()), l);}
#endif
#define sub25(A, h, w, ah, aw) sub(A, h, w, ah, aw)
#define sub26(A, h, w, ah, aw, siki_r) sub(A, h, w, ah, aw, [&](auto v){return v siki_r;})
#define sub27(A, h, w, ah, aw, v, siki) sub(A, h, w, ah, aw, [&](auto v){return siki;})
#define sub2(...) over7(__VA_ARGS__,sub27,sub26,sub25)(__VA_ARGS__)
constexpr int bsetlen = 50001;
//constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] < b[i])return true;if (a[i] > b[i])return false;}return false;}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] > b[i])return true;if (a[i] < b[i])return false;}return false;}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] < b[i])return true;if (a[i] > b[i])return false;}return true;}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] > b[i])return true;if (a[i] < b[i])return false;}return true;}
string operator~(string &a) {string res = a;for (auto &&c:res) {if (c == '0')c = '1';else if (c == '1')c = '0';else {cerr << "cant ~" << a << "must bit" << endl;exit(0);}}return res;}
ostream &operator<<(ostream &os, bset& a) { bitset<10> b; vi list; rep(i,bsetlen){ if(a[i])list.push_back(i),b[i]=1; } os<<b<<", "<<list; return os;}
int hbiti(bset&a){rer(i,bsetlen){if(a[i])return i;}return -1;}
#define hk(a, b, c) (a <= b && b < c)
//O(N/64)
bset nap(bset &a, int v) {bset r = a | a << v;return r;}
bset nap(bset &a, bset &v) {bset r = a;rep(i, bsetlen) {if (v[i])r |= a << i;}return r;}
template<class T> int count(set<T> &S, T l, T r) { assert(l < r); auto it = S.lower_bound(l); return it != S.end() && (*it) < r;}
//template<class T> void seth(vector<vector<T>> &S, int w, vector<T> &v) {assert(sz(S) == sz(v));assert(w < sz(S[0]));rep(h, sz(S)) { S[h][w] = v[h]; }}
template<class T> vector<T> geth(vector<vector<T>> &S, int w) { assert(w < sz(S[0])); vector<T> ret(sz(S)); rep(h, sz(S)) { ret[h] = S[h][w]; } return ret;}
//vector<bool>[i]は参照を返さないため、こうしないとvb[i] |= trueがコンパイルエラー
vb::reference operator|=(vb::reference a, bool b){return a = a | b;}
vb::reference operator&=(vb::reference a, bool b){return a = a & b;}
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+(const pair<T, U> &a, const pair<T, U> &b) { return pair<T, U>(a.fi + b.fi, a.se + b.se); }
template<class T, class U> pair<T,U> operator-(const pair<T,U> &a, const pair<T,U> & b) {return pair<T,U>(a.fi-b.fi,a.se-b.se);}
template<class T, class U> pair<T,U> operator-(const pair<T, U>& a){return pair<T, U>(-a.first, -a.second);}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rhs) {
#ifdef _DEBUG
static bool was = false;if (!was)message += "str += 65 is 'A' not \"65\" ";was = true;
#endif
return lhs + (char) rhs;
}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const int lhs, const basic_string<CharT, Traits, Alloc> &rhs) {
#ifdef _DEBUG
static bool was = false;if (!was)message += "str += 65 is 'A' not \"65\" ";was = true;
#endif
return (char)lhs + rhs;
}
template<typename CharT, typename Traits, typename Alloc> void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) { lhs = lhs + rv;}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) { const int rv2 = rv; return lhs + rv2;}
template<typename CharT, typename Traits, typename Alloc> void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {const int v = rv; lhs += v; }
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+(U v,const vector<T> &a) { vector<T> ret = a; ret.insert(ret.begin(), v); return ret;}template<class T> vector<T> operator+(const vector<T>& a, const vector<T>& b) { vector<T> ret; ret = a; fora(v, b){ret += v; } return ret;}template<class T> vector<T> &operator+=(vector<T> &a,const vector<T> &b) { rep(i, sz(b)) {/*こうしないとa+=aで両辺が増え続けてバグる*/ a.push_back(b[i]); } return a;}template<class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) { for(auto&& bv : b) { a[bv.first] += bv.second; } return a;}template<class T, class U> vector<T> operator+(const vector<T> &a, const U& v) { vector<T> ret = a; ret += v; return ret;}template<class T, class U> auto operator+=(uset<T> &a, U v) { return a.insert(v); }
template<class T> vector<T> operator%(vector<T>& a, int v){ vi ret(sz(a)); rep(i,sz(a)){ ret[i] = a[i] % v; } return ret;}
template<class T> vector<T> operator%=(vector<T>& a, int v){ rep(i,sz(a)){ a[i] %= v; } return a;}
vi operator&(vi& a, vi& b){ assert(sz(a)==sz(b)); vi ret(sz(a)); rep(i,sz(a)){ ret[i] = min(a[i],b[i]); } return ret;}
template<class T> void operator+=(mset<T> &a, vector<T>& v) { for(auto&& u : v)a.insert(u); }
template<class T> void operator+=(set<T> &a, vector<T>& v) { for(auto&& u : v)a.insert(u); }
template<class T> void operator+=(vector<T> &a, set<T>& v) { for(auto&& u : v)a.emplace_back(u); }
template<class T> void operator+=(vector<T> &a, mset<T>& v) { for(auto&& u : v)a.emplace_back(u); }
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(T &v, unsigned ll i) { v.erase(v.begin() + i); }
template<typename T> void erase(T &v, unsigned ll s, unsigned ll e) { v.erase(v.begin() + s, v.begin() + e); }
template<class T, class... I> auto erased(T& v, I... arg){ auto ret = v; erase(ret, arg...); return ret;}
template<typename T> void pop_front(vector<T> &v) { erase(v, 0); }
template<typename T> void entry(vector<T> &v, unsigned ll s, unsigned ll e) { erase(v, e, sz(v));erase(v,0,s);}
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); }
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;}
ll stoi(string& s){return stol(s);}
#define assert_yn(yn_v, v); assert(yn_v == 0 || yn_v == v);yn_v = v;
//不完全な対策、現状はautohotkeyで対応
int yn_v = 0;
void yn(bool a) { assert_yn(yn_v, 1);if (a)cout << "yes" << endl; else cout << "no" << endl; }
void fyn(bool a) { assert_yn(yn_v, 1);yn(a); exit(0);}
void Yn(bool a) { assert_yn(yn_v, 2);if (a)cout << "Yes" << endl; else cout << "No" << endl; }
void fYn(bool a) { assert_yn(yn_v, 2);Yn(a); exit(0);}
void YN(bool a) { assert_yn(yn_v, 3);if (a)cout << "YES" << endl; else cout << "NO" << endl; }
void fYN(bool a) { assert_yn(yn_v, 3);YN(a); exit(0);}
int ab_v = 0;
void fAb(bool a) { assert_yn(ab_v, 1);if(a)cout<<"Alice"<<endl;else cout<<"Bob";}
void fAB(bool a) { assert_yn(yn_v, 2);if(a)cout<<"ALICE"<<endl;else cout<<"BOB";}
int pos_v = 0;
void Possible(bool a) { assert_yn(pos_v, 1);if (a)cout << "Possible" << endl; else cout << "Impossible" << endl; exit(0);}
void POSSIBLE(bool a) { assert_yn(pos_v, 2);if (a)cout << "POSSIBLE" << endl; else cout << "IMPOSSIBLE" << endl; exit(0);}
void fPossible(bool a) { assert_yn(pos_v, 1)Possible(a);exit(0);}
void fPOSSIBLE(bool a) { assert_yn(pos_v, 2)POSSIBLE(a);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)}; }
//未分類
//0,2,1 1番目と2番目の次元を入れ替える
template<class T> auto irekae(vector<vector<vector<T> > > &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c) resize(res,a,b,c);rep(i,a)rep(j,b)rep(k,c)
vector<vector<vector<T> > > res; if (x == 0 && y == 1 && z == 2) { res = A; } else if (x == 0 && y == 2 && z == 1) { irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) { res[i][j][k] = A[i][k][j]; } } else if (x == 1 && y == 0 && z == 2) { irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) { res[i][j][k] = A[j][i][k]; } } else if (x == 1 && y == 2 && z == 0) { irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) { res[i][j][k] = A[k][i][j]; } } else if (x == 2 && y == 0 && z == 1) { irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) { res[i][j][k] = A[j][k][i]; } } else if (x == 2 && y == 1 && z == 0) { irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) { res[i][j][k] = A[k][j][i]; } } return res;
#undef irekae_resize_loop
}
template<class T> auto irekae(vector<vector<T>>&A,int i=1,int j=0){ vvt(res,sz(A[0]),sz(A)); rep(i,sz(A)){ rep(j,sz(A[0])){ res[j][i]=A[i][j]; } } return res;}
//tou分割する
template<typename Iterable> vector<Iterable> table(const Iterable &a, int tou = 2) {int N = sz(a); vector<Iterable> res(tou); int hab = N / tou; vi lens(tou, hab); rep(i, N % tou) { lens[tou - 1 - i]++; } int l = 0; rep(i, tou) { int len = lens[i]; int r = l + len; res[i].resize(len); std::copy(a.begin() + l, a.begin() + r, res[i].begin()); l = r; } return res;}
//長さn毎に分割する
template<typename Iterable> vector<Iterable> table_n(const Iterable &a, int len) { int N = sz(a); vector<Iterable> res(ceil(N, len)); vi lens(N / len, len); if (N % len)lens.push_back(N % len); int l = 0; rep(i, sz(lens)) { int len = lens[i]; int r = l + len; res[i].resize(len); std::copy(a.begin() + l, a.begin() + r, res[i].begin()); l = r; } return res;}
//縦を返す
vi& geth(vvi()& a, int w){ static vi ret; ret.resize(sz(a)); rep(i,sz(a)){ ret[i] = a[i][w]; } return ret;}
//@起動時
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;
//#define pre prev
//#define nex next
//gra mll pr
//上下左右
const string udlr = "udlr";
string UDLR = "UDLR";//x4と連動 UDLR.find('U') := x4[0]
vc atoz = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x','y', 'z'};
vc AtoZ = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X','Y', 'Z'};
//右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {while (++i < 4) { if (inside(h + h4[i], w + w4[i], H, W))return i; }return i;}
#define mei(nh, nw, h, w) for (int i = mei_inc(h, w, H, W, -1), nh = i<4? h + h4[i] : 0, nw = i<4? w + w4[i] : 0; i < 4; i=mei_inc(h,w,H,W,i), nh = h+h4[i], nw = w+w4[i])
int mei_inc8(int h, int w, int H, int W, int i) { while (++i < 8) { if (inside(h + h8[i], w + w8[i], H, W))return i; } return i;}
#define mei8(nh, nw, h, w) for (int i = mei_inc8(h, w, H, W, -1), nh = i<8? h + h8[i] : 0, nw = i<8? w + w8[i] : 0; i < 8; i=mei_inc8(h,w,H,W,i), nh = h+h8[i], nw = w+w8[i])
int mei_incv(int h, int w, int H, int W, int i, vp &p) { while (++i < sz(p)) { if (inside(h + p[i].fi, w + p[i].se, H, W))return i; } return i;}
#define meiv(nh, nw, h, w, p) for (int i = mei_incv(h, w, H, W, -1, p), nh = i<sz(p)? h + p[i].fi : 0, nw = i<sz(p)? w + p[i].se : 0; i < sz(p); i=mei_incv(h,w,H,W,i,p), nh = h+p[i].fi, nw = w+p[i].se)
//H*Wのグリッドを斜めに分割する
//右上
vector<vp> naname_list_ne(int H, int W) { vector<vp> res(H + W - 1); rep(sh, H) { int sw = 0; res[sh] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh--; nw++; if (0 <= nh && nw < W) { res[sh] += mp(nh, nw); }else{ break; } } } rep(sw, 1, W) { int sh = H - 1; res[H + sw - 1] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh--; nw++; if (0 <= nh && nw < W) { res[H + sw-1] += mp(nh, nw); }else{ break; } } } return res;}
//右下
vector<vp> naname_list_se(int H, int W) { vector<vp> res(H + W - 1); rep(sh, H) { int sw = 0; res[sh] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh++; nw++; if (0 <= nh && nh< H && nw < W) { res[sh] += mp(nh, nw); } else { break; } } } rep(sw, 1, W) { int sh = 0; res[H + sw - 1] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh++; nw++; if (0 <= nh && nh < H && nw < W) { res[H + sw - 1] += mp(nh, nw); } else { break; } } } return res;}
//グラフ内で #undef getid
//#define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1) (__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
#define set_shuffle() std::random_device seed_gen;std::mt19937 engine(seed_gen())
#define shuffle(a) std::shuffle((a).begin(), (a).end(), engine);
//1980 開始からtime ms経っていたらtrue
vb bit_bool(int v, int len) { assert(bit(len) > v); vb ret(len); rep(i, len) { ret[i] = bget(v, i); } return ret;}
vi tov(vb& a){ vi ret; rep(i,sz(a)){ if(a[i])ret.push_back(i); } return ret;}
bool kaibun(const str& S){return S==rev(S);}
template<class T> vector<T> repeat(const vector<T> &A, int kaisu) { vector<T> ret; while (kaisu--) { ret += A; } return ret;}
#define rge range
#define upd update
//S[{s, t, d}]
#define strs slice_str
struct slice_str {
string S;
slice_str() {}
slice_str(const string &S) : S(S) {}
slice_str(int len, char c) : S(len, c) {}
auto size(){return S.size();}
char& operator[](int p) { return S[p]; }
string operator[](initializer_list<int> p) { if (sz(p) == 1) { return S.substr(0, *(p.begin())); } else if (sz(p) == 2) { int l = *(p.begin()); int r = *(next(p.begin())); return S.substr(l, r - l); } else { auto it = p.begin(); int s = *(it++); int t = *(it++); int d = *(it); if (d == -1) { int s_ = sz(S) - s - 1; int t_ = sz(S) - t - 1; return rev(S).substr(s_, t_ - s_); } else if (d < 0) { t = max(-1ll, t); string ret; while (s > t) { ret += S[s]; s += d; } return ret; } else { t = min(sz(S), t); string ret; while (s < t) { ret += S[s]; s += d; } return ret; } } }
operator string &() { return S; }
template<class T> void operator+=(const T &a) { S += a; }
bool operator==(const slice_str& rhs){return S==rhs.S;}
auto pop_back(){return S.pop_back();}
};
ostream &operator<<(ostream &os, const slice_str &a) { os << a.S; return os;}
istream &operator>>(istream &iss, slice_str &a) {iss >> a.S;return iss;}
template<class T> bool can(const T &v, int i) { return 0 <= i && i < sz(v); }
#if __cplusplus >= 201703L
//template<class T> auto sum(int a, T v...) {return (v + ... + 0);}
#endif
#define VEC vector
//string.substr()は長さを指定するため、間違えやすい
#define substr my_substr
#endif /*UNTITLED15_TEMPLATE_H*/
#endif
//† ←template終了
/*@formatter:on*/
//vectorで取れる要素数
//bool=> 1e9 * 8.32
//int => 1e8 * 2.6
//ll => 1e8 * 1.3
//3次元以上取るとメモリがヤバい
//static配列を使う
vvc (ba);
ll N, M, H, W;
vi A, B, C;
namespace {/*@formatter:off*/
#undef getid
#undef getid_1
#undef getid_2
//#define type_id_graph
#ifdef type_id_graph
//#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c,ty,id; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c,ty=ve[gi].ty, id = ve[gi].id, true); ++gi)
#define forg_f_init(ve) int f = ve[gi].f, t = ve[gi].t, ty = ve[gi].ty, id = ve[gi].id; auto& c = ve[gi].c
#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim; ++gi)
#define fort_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim ; ++gi)
#define fort_f_init(gi, ve) int f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, id = ve[gi].id;if(t == p)continue;
//#define fort_f(gi, ve) for (ll gi = 0, f, t, c, ty, id,wasp = (p != -1 && ve[gi].t == p) ? 1 : 0; (wasp = wasp ? 1 : (p != -1 && ve[gi].t == p) ? 1 : 0,gi + wasp < ve.size()) &&(tie(f, t, c, ty, id) = wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c, ve[gi + 1].ty, ve[gi + 1].id) : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c, ve[gi].ty, ve[gi].id), true); ++gi)
#define fore(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c, ty, id; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, id = ve[gi].id, true); ++gi)
template<class T> struct edge_ { typedef T value_type;int f, t, ty, id; T c; edge_(int f, int t, T c = 1, int ty = -1, int id= -1) : f(f), t(t), c(c), ty(ty), id(id) {} 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<<" "<< e.ty<<" "<<e.id;return os;}
template<typename T> class graph {
public :
typedef T value_type;
vector<vector<edge_<T>>> g;
vector<edge_<T>> edges;
int n;
explicit graph(int n) : n(n) { g.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {this->n = n;g.resize(n);}
int size() { return n; }
vector<edge_<T> > &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int ty, 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;
explicit digraph(int n) : graph<T>(n) {}
explicit digraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
void add(int f, int t, T c = 1, int ty = -1, int eid = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {debugline("digraph add");deb(f, t, c);ole();}
int id = sz(edges);
if(eid != -1)id = eid;
g[f].emplace_back(f, t, c, ty, id);
edges.emplace_back(f, t, c, ty, id);//edgesを使わないなら消せる
}
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 set_edges() override{ 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;
explicit undigraph(int n) : graph<T>(n) {}
explicit undigraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
int next_id = 0;
// f < t
void add(int f, int t, T c = 1, int ty = -1, int eid = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("undigraph add"); deb(f, t, c); ole(); }
int id = eid;
if(id == -1){
id = next_id++;
}
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を使わないなら消せる
edges.emplace_back(t, f, c, ty, id);
}
void add(edge_<T> &e) { int f = e.f, t = e.t,ty = e.ty,id=e.id; T c = e.c; add(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 set_edges () override{ if (sz(edges))return; rep(i, n)fora(e, g[i])edges.push_back(e); }
};
#else //#ifdef type_id_graph
#define forg_f_init(ve) int f = ve[gi].f, t = ve[gi].t; auto& c = ve[gi].c
#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim; ++gi)
// /*temp2*/#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
//#define fort_f(gi, ve) for (ll gi = 0, f, t, c,wasp = (p != -1 && ve[gi].t == p) ? 1 : 0; (wasp = wasp ? 1 : (p != -1 && ve[gi].t == p) ? 1 : 0,gi + wasp < ve.size()) &&(tie(f, t, c) = wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c) : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c), true); ++gi)
#define fort_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim ; ++gi)
#define fort_f_init(gi, ve) int f = ve[gi].f, t = ve[gi].t, c = ve[gi].c;if(t == p)continue;
#define fore(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
template<class T> struct edge_ {typedef T value_type;int f, t; T c; edge_(int f, int t, T c = 1) : f(f), t(t), c(c) {} 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 {
public :
typedef T value_type;
vector<vector<edge_<T>>> g;
vector<edge_<T>> edges;
int n;
explicit graph(int n) : n(n) { g.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {this->n = n;g.resize(n);}
int size() { return n; }
vector<edge_<T> > &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c) = 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;
explicit digraph(int n) : graph<T>(n) {}
explicit digraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {debugline("digraph add");deb(f, t, c);ole();}
g[f].emplace_back(f, t, c);
edges.emplace_back(f, t, c);//edgesを使わないなら消せる
}
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 set_edges() override{ 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;
explicit undigraph(int n) : graph<T>(n) {}
explicit undigraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
// f < t
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("undigraph add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
edges.emplace_back(f, t, c);//edgesを使わないなら消せる
edges.emplace_back(t, f, c);
}
void add(edge_<T> &e) { int f = e.f, t = e.t; T c = e.c; add(f, t, c); }
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 set_edges () override{ if (sz(edges))return; rep(i, n)fora(e, g[i])edges.push_back(e); }
};
#endif
#define dijkstra_path dis_path
template<class T,class I> vi dis_path(digraph<T> &g, vector<T> &dis, int s, int t, I init_value) { assert(dis[t] != init_value); auto rg = rev(g); int now = t; vi path; path.push_back(now); T cost = 0; while (now != s) { rep(gi, sz(rg[now])) { int m = rg[now][gi].t; if (dis[m] == init_value)continue; if (dis[m] + rg[now][gi].c + cost == dis[t]) { cost += rg[now][gi].c; now = m; break; } } path.push_back(now); } rev(path); return path;}
template<class T,class I> vi dis_path(undigraph<T> &g, vector<T> &dis, int s, int t, I init_value) { assert(dis[t] != init_value); int now = t; vi path; path.push_back(now); T cost = 0; while (now != s) { rep(gi, sz(g[now])) { int m = g[now][gi].t; if (dis[m] == init_value)continue; if (dis[m] + g[now][gi].c + cost == dis[t]) { cost += g[now][gi].c; now = m; break; } } path.push_back(now); } rev(path); return path;}
template<class T,class I> vi dis_path(digraph<T> &g, vector<vector<T>> &dis, int s, int t, I init_value) { return dis_path(g, dis[s], s, t, init_value); }
template<class T,class I> vi dis_path(undigraph<T> &g, vector<vector<T>> &dis, int s, int t, I init_value) { return dis_path(g, dis[s], s, t, init_value); }
vi to_vi(const int& i){return vi{i};}
vi to_vi(const vi& v){return v;}
#define dijk dijkstra
//O(N^2)
template<class T, class U, class I> vector<T> dijkstra_mitu(graph<T> &g, const U &S_, I init_value) { vi S = to_vi(S_); int n = g.n; T initValue = MAX<T>(); vector<T> dis(n, initValue); fora(s, S) { if (!(0 <= s && s < g.n)) { debugline("dijkstra_mitu"); deb(s, g.n); ole(); } dis[s] = 0; } vb used(n); while (true) { int v = -1; rep(u, n) { if (!used[u] && (v == -1 || dis[u] < dis[v]))v = u; } if (v == -1)break; if (dis[v] == initValue)break; used[v] = true; rep(u, sz(g[v])) { auto e = g[v][u]; dis[e.t] = min(dis[e.t], dis[v] + e.c); } } /*基本、たどり着かないなら-1*/ for (auto &&d :dis) { if (d == initValue) { d = init_value; }} return dis;}
template<class T, class U, class I> vector<T> dijkstra_01(graph<T> &g, const U &S_, I init_value) {int N = g.n; vi S = to_vi(S_); T tinf = INF<T>(); vector<T> dis(N, tinf); deque<int> q; fora(s, S) { dis[s] = 0; q.push_back(s); } vb was(N); while (!q.empty()) { int f = q.front(); q.pop_front(); if (was[f])continue; was[f] = true; fora(e, g[f]) { if (dis[e.t] > dis[f] + e.c) { if (e.c) { dis[e.t] = dis[f] + 1; q.push_back(e.t); } else { dis[e.t] = dis[f]; q.push_front(e.t); } } } } rep(i, N)if (dis[i] == tinf)dis[i] = init_value; return dis;}
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 emplace(u64 key, const T &value) { ++size_; v[getbit(key ^ last)].emplace_back(key, value); } void push(u64 key, const T &value) { emplace(key, value); } pair<u64, T> top() { 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; } void pop() { ; } int size() { return size_; }};
//01, 密グラフ, normalを自動で判断する
template<class Q, class T, class U,class I> vector<T> private_dijkstra(graph<T> &g, U &S_, I init_value) { vi S = to_vi(S_); fora(s, S) { if (!(0 <= s && s < g.n)) { debugline("dijkstra"); deb(s, g.n); ole(); } } bool cost01 = true; rep(i, g.n) { forg_f(gi, g[i]) {forg_f_init(g[i]); cost01 &= (c == 0 || c == 1); }} if (cost01)return dijkstra_01(g, S_, init_value); else if ((g.n + sz(g.edges)) * log2(g.n) > g.n * g.n) { return dijkstra_mitu(g, S, init_value); } T initValue = MAX<T>(); vector<T> dis(g.n, initValue); Q q; fora(s, S) { dis[s] = 0; q.emplace(0, s); } while (q.size()) { T nowc; int i; tie(nowc, i) = q.top(); 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, class U,class I> vector<T> dijkstra(graph<T> &g, U S_, I init_value) { if (typeid(T) == typeid(int)) { return private_dijkstra<radixheap<int>>(g, S_, init_value); } else { return private_dijkstra<priority_queue<pair<T, int>, vector<pair<T, int >>, greater<pair<T, int >> >>(g, S_, init_value); }}
//dijkstra_cou<mint> : 数える型で書く return vp(dis,cou)
template<class COU,class T=int,class I> auto dijkstra_cou(const graph<T> &g, int s, I init_value) { if (!(0 <= s && s < g.n)) { debugline("dijkstra"); deb(s, g.n); ole(); } err("count by type COU "); err("int or mint"); T initValue = MAX<T>(); vector<T> dis(g.n, initValue); vector<COU> cou(g.n); cou[s] = 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_f(gi, g[i]){ forg_f_init(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_f(gi, g[i]){ forg_f_init(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, class I> vector<vector<T>> warshall(graph<T> &g, I init_value) { int n = g.n; assert(n < 1e4); vector<vector<T> > dis(n, vector<T>(n, INF<T>())); rep(i, n)fora(e, g.g[i]) { if (dis[e.f][e.t] > e.c) { dis[e.f][e.t] = e.c; }} rep(i, n)dis[i][i] = 0; rep(k, n) rep(i, n) rep(j, n) { if (dis[i][j] > dis[i][k] + dis[k][j]) { dis[i][j] = dis[i][k] + dis[k][j]; }} rep(i, n)rep(j, n) if (dis[i][j] == linf)dis[i][j] = init_value; return dis;}
//密グラフの時、warshallに投げる
//01等の判定もここで出来る
template<class T, class I> vector<vector<T>> dijkstra_all(graph<T> &g, I init_value) { int n = g.n; assert(n < 1e4); if (n * n < (n + sz(g.edges)) * 14) { /*O(N^3) vs O(N (N+M)log N)*/ return warshall(g, init_value); } vector<vector<T>> dis(n); rep(i, n) { dis[i] = dijkstra(g, i, 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( 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( 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; }};
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; rmq_dep.push_back(d); disv[x] = dis; in[x] = cnt++; forg_f(gi, g[x]) { forg_f_init(g[x]); if (t == p) { continue; } dfs(t, x, d + 1, dis + c); id_[cnt] = x; rmq_dep.push_back(d); cnt++; } } void precalc() { never = false; cnt = 0; rmq_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(rmq_dep);
#ifdef _DEBUG
if (n >= 100)return; cerr << "---tree---" << endl; rep(i, n) { if (!(i == root || sz(g[i]) > 1))continue; cerr << i << " -> "; vi ts; forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != par_[i])ts.push_back(t); } rep(i, sz(ts) - 1)cerr << ts[i] << ", "; if (sz(ts))cerr << ts.back() << endl; } cerr << endl;
#endif
} int pos; void hld_build() { never_hld = false; if (never)precalc(); g.resize(n); vid.resize(n, -1); head.resize(n); heavy.resize(n, -1); depth.resize(n); inv.resize(n); subl.resize(n); subr.resize(n); dfs(root, -1); t = 0; dfs_hld(root);
#ifdef _DEBUG
if (n >= 100)return; 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; cerr << "!!query!! edge or not edge carefull!!" << endl;
#endif
} int dfs(int curr, int prev) { int sub = 1, max_sub = 0; heavy[curr] = -1;
forg_f(gi, g[curr]) { forg_f_init(g[curr]); int next = t; if (next != prev) { depth[next] = depth[curr] + 1; int sub_next = dfs(next, curr); sub += sub_next; if (max_sub < sub_next) max_sub = sub_next, heavy[curr] = next; } } return sub; } int t = 0;
#ifndef __CLION_IDE__
void dfs_hld(int v = 0) { vid[v] = subl[v] = t; t++; inv[subl[v]] = v; if (0 <= heavy[v]) { head[heavy[v]] = head[v]; dfs_hld(heavy[v]); }
forg_f(gi, g[v]){forg_f_init(g[v]); if (depth[v] < depth[t]) if (t != heavy[v]) { head[t] = t; dfs_hld(t); } subr[v] = t; }}
#endif//__CLION_IDE__
vector<signed> rmq_dep;
vi par_, depth, disv;
vi childs;
vi par_id_;//親への辺のidを持つ
vvi(ids_);//隣接で辺のidを持つ
public:
using undigraph<T>::g; using undigraph<T>::n; using undigraph<T>::edges;
int root;
//(f,t)と(t,f)は同じidを持ち、[0,n-1]でadd順に割り振られる
//部分木の [左端、右端) index
//部分木の辺に加算する場合
//add(subl[i],subr[i],x)
//add(sub[i],sub[i+1],-x)
vector<int> vid, head, heavy, inv, subl, subr;
tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
tree(int n_, int root, const vector<edge_<T>> &E) : undigraph<T>(n_), root(root) {n = n_;fora(e, E) { add(e.f, e.t, e.c); }}
// f < t
void add(int f, int t, T c = 1) {
#ifdef _DEBUG
if ((n % k5) == 0) {re("tree must resize");}
#endif
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("tree add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
edges.emplace_back(f, t, c);/*edgesを使わないなら消せる*/
edges.emplace_back(t, f, c);
}
void add_di(int f, int t, T c = 1) {
#ifdef _DEBUG
if ((n % k5) == 0) { re("tree must resize"); }
#endif
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("tree add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); edges.emplace_back(f, t, c);/*edgesを使わないなら消せる*/ }
void root_change(int roo) { root = roo; precalc(); }
//葉になりえない頂点を根にする
void root_change_mid() {
#ifdef _DEBUG
message += "N>2 (mid)\n";
#endif
assert(n > 2); rep(i, n) { if (sz(g[i]) > 1) { root_change(i); return; } } }
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; }
int dep(int a) { if (never)precalc(); return disv[a]; }
int par(int a) { if (never)precalc(); return par_[a]; }
bool isleaf(int i) {if (never)precalc();return (sz(g[i]) == 1 && i != root);}
bool leaf(int i) { return isleaf(i); }
vi child(int r) { vi res; res.push_back(r); queue<int> q; q.push(r); while (!q.empty()) { int i = q.front(); res.push_back(i); q.pop(); forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != par(i))q.push(t); } } return res; }
vb child_ex(int r) { vb res(n); res[r] = true; queue<int> q; q.push(r); while (!q.empty()) { int i = q.front(); res[i] = true; q.pop(); forg_f(gi, g[i]) {forg_f_init(g[i]); if (t != par(i))q.push(t); } } return res; }
int dfs_count_subtree(int p, int i) { childs[i] = 1; fort_f(gi, g[i]) { fort_f_init(gi, g[i]); childs[i] += dfs_count_subtree(i, t); } return childs[i]; }
#define count_child count_subtree
int count_subtree(int f) { if (sz(childs) == 0) { if (never)precalc(); childs.resize(n); dfs_count_subtree(-1, root); } return childs[f]; }
//fからtの辺を切った時のtの大きさ
int count_subtree(int f, int t) { if (par(f) == t) { return n - count_subtree(f); } else { return count_subtree(t); } }
int size(int f, int t){return count_subtree(f, t);}
int size(){return n;}
vi path(int a, int b) { vi res; for_each_l(a, b, [&](int i) { res.push_back(i); }); return res; }
//idはedgesに使えない ↓edge(id)とする
//pathに含まれる辺のid達を返す
vi pathe(int a,int b){
#ifdef _DEBUG
static bool was = 0;if(!was)message+="can't edges[id]. must edge(id)\n";was=1;
#endif
if(sz(par_id_)==0){ ids_.resize(n); par_id_.resize(n); rep(i,0,sz(edges),2){ ids_[edges[i].f].emplace_back(i>>1); ids_[edges[i].t].emplace_back(i>>1); } if(never)precalc();/*par_を呼ぶため*/ rep(i, n){ int pa = par_[i]; forg_f(gi, g[i]){ forg_f_init(g[i]); if(t==pa){ par_id_[i] = ids_[i][gi]; } } } } int u = lca(a,b); vi res; if (a != u) { do { res.emplace_back(par_id_[a]); a = par_[a]; } while (a != u); } vi rev; if (b != u) { do { rev.emplace_back(par_id_[b]); b = par_[b]; } while (b != u); } rer(i,sz(rev)-1){ res.emplace_back(rev[i]); } return res;
}
//親の辺のidを返す
int par_id(int i){if(sz(par_id_)==0){pathe(0,0);}return par_id_[i];}
//fのi番目の辺のidを返す
int ids(int f,int i) {if(sz(ids_)==0){pathe(0,0);}return ids_[f][i];}
//idから辺を返す
edge_<T> edge(int id){return edges[id<<1];}
/*O(N) hldを使わず木を普通にたどる liteの意*/
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]; } fnode(r); vi a; while (v != r) { a.push_back(v); v = par_[v]; } while(sz(a)){ fnode(a.back()); a.pop_back(); } }
void for_each_edge_l(int u, int v, function<void(edge_<int> &)> fedge) { int r = lca(u, v); while (u != r) { forg_f(gi, g[u]) {forg_f_init(g[u]); if (t == par_[u]) { fedge(g[u][gi]); u = par_[u]; break; } } } vector<edge_<int>> qs; while (v != r) { forg_f(gi, g[v]) { forg_f_init(g[v]); if (t == par_[v]) { qs.push_back(g[v][gi]); v = par_[v]; break; } } } while(sz(qs)){ fedge(qs.back()); qs.pop_back(); } }
//Fは半開 (u,v)は木の頂点
//中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう
void for_each_/*[l,r)*/(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 depth[f] > depth[t] ? vid[f] : vid[t];}
int bel(edge_<T> &e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/ if (never_hld)hld_build();return depth[e.f] > depth[e.t] ? vid[e.f] : vid[e.t];}
template<class ... U> int operator()(U ... args) { return bel(args...); }
//path l -> r += v
template<class S> void seg_add(S &seg, int lhei, int rhei, int v) {for_each_(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });}
template<class S> void seg_update(S &seg, int lhei, int rhei, int v) {for_each_(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });}
template<class S> T seg_get(S &seg, int lhei, int rhei) { T res = seg.e; for_each_(lhei, rhei, [&](int l, int r) { res = seg.f(res, seg.get(l, r)); }); return res; }
template<class S> void seg_add_edge(S &seg, int lhei, int rhei, int v) { for_each_edge(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); }); }
template<class S> void seg_update_edge(S &seg, int lhei, int rhei, int v) { for_each_edge(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); }); }
template<class S> T seg_get_edge(S &seg, int lhei, int rhei) { T res = seg.e; for_each_edge(lhei, rhei, [&](int l, int r) { res = seg.f(res, seg.get(l, r)); }); return res; }
//単体 edgeは上で処理できる
template<class S> void seg_add(S &seg, int i, int v) { seg.add(bel(i), v); }
template<class S> void seg_update(S &seg, int i, int v) { seg.update(bel(i), v); }
template<class S> T seg_get(S &seg, int i) { return seg[i]; }
template<class S> void seg_del(S &seg, int i) { seg.del(bel(i)); }
//部分木iに対するクエリ
template<class S> void seg_add_sub(S &seg, int i, int v) {if (never_hld)hld_build();seg.add(subl[i], subr[i], v);}
template<class S> void seg_update_sub(S &seg, int i, int v) {if (never_hld)hld_build();seg.update(subl[i], subr[i], v);}
template<class S> T seg_get_sub(S &seg, int i, int v) {if (never_hld)hld_build();return seg.get(subl[i], subr[i], v);}
template<class S> void seg_add_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/seg.add(subl[i] + 1, subr[i], v);}
template<class S> void seg_update_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/seg.update(subl[i] + 1, subr[i], v);}
template<class S> T seg_get_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/return seg.get(subl[i] + 1, subr[i], v);}
};
//辺が多いのでedgesを持たない
//cost oo, ox, xo, xx 渡す
template<class T=int> class ungrid_k6 : public undigraph<T> {
vi costs;
public:
using undigraph<T>::g; using undigraph<T>::n; using undigraph<T>::edges;
int H, W;
vector<vector<char>> ba;
char wall;
void add(int f, int t, T c = 1){
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("grid_k6 add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
//undigraphと違い、edgesを持たない
}
int getid(int h, int w) { assert(ins(h, w, H, W)); return W * h + w; }
int getid(P p) { return getid(p.first, p.second); }
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); }
int operator()(P p) { return getid(p); }
//辺は無い
ungrid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {}
//fh,fw,th,twでコストを返す linfならスルー
template<class F>void build(F func) { rep(h, H) { rep(w, W) { int fid = getid(h, w); auto add = [&](int fh, int fw, int th, int tw) { if (ins(th, tw, H, W)) { auto cost = func(fh, fw, th, tw); if (abs(cost) >= linf)return; g[fid].emplace_back(fid, getid(th, tw), cost); } }; add(h, w, h + 1, w); add(h, w, h - 1, w); add(h, w, h, w + 1); add(h, w, h, w - 1); } } }
ungrid_k6(vector<vector<char>> ba, char wall = '#') : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) { build([&](int fh, int fw, int th, int tw) { if (ba[fh][fw] == wall || ba[th][tw] == wall)return linf; else return 1ll; }); }
/*o -> o, o -> x, x -> o, x-> x*/
ungrid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx, char wall = '#') : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), costs({oo, ox, xo, xx}), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { int cm = 0; if (ba[fh][fw] == wall) { cm += 2; } if (ba[th][tw] == wall) { cm++; } return costs[cm]; }); }
//lambda
ungrid_k6(vector<vector<char>> ba, char wall, function<T(char, char)> f) : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { return f(ba[fh][fw], ba[th][tw]); }); }
ungrid_k6(vector<vector<char>> ba, char wall, function<T(int, int, int, int)> f) : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build(f); }
void set_edges() { rep(i, n)fora(e, g[i])if (e.f < e.t)edges.push_back(e); }
};
//辺によりメモリを大量消費ためedgesを消している
//頂点10^6でメモリを190MB(制限の8割)使う
//左上から右下に移動できる
template<class T=int> class digrid_k6 : public digraph<T> {
vi costs;
public:
vector<vector<char>> ba;
char wall;
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
int H, W;
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("digrid_k6 add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
/*digraphと違いedgesを持たない*/
}
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){}
//fh,fw,th,twでコストを返す linfならスルー
template<class F>void build(F func) { rep(h, H) { rep(w, W) { int fid = getid(h, w); auto add = [&](int fh, int fw, int th, int tw) { if (ins(th, tw, H, W)) { auto cost = func(fh, fw, th, tw); if (abs(cost) >= linf)return; g[fid].emplace_back(fid, getid(th, tw), cost); } }; add(h, w, h + 1, w); add(h, w, h, w + 1); } } }
digrid_k6(vector<vector<char>> ba, char wall = '#') : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) { build([&](int fh, int fw, int th, int tw) { if (ba[fh][fw] == wall || ba[th][tw] == wall)return linf; else return 1ll; }); }
/*o -> o, o -> x, x -> o, x-> x*/
digrid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx, char wall = '#') : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), costs({oo, ox, xo, xx}), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { int cm = 0; if (ba[fh][fw] == wall) { cm += 2; } if (ba[th][tw] == wall) { cm++; } return costs[cm]; }); }
//lambda
digrid_k6(vector<vector<char>> ba, char wall, function<T(char, char)> f) : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { return f(ba[fh][fw], ba[th][tw]); }); }
digrid_k6(vector<vector<char>> ba, char wall, function<T(int, int, int, int)> f) : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build(f); }
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); }
};
//grid用のdijkstra
//vector<vector<t>>を返す
template<class G, class I> auto dijkstra(G &g, int fh, int fw, I init_value) { auto dis = dijkstra(g, g(fh, fw), init_value); vvi(res, g.H, g.W); rep(i, sz(dis)) { int h, w; tie(h, w) = g.get2(i); res[h][w] = dis[i]; } return res;}
//edgesを持たない
//dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template<class T=int>class segdi : public digraph<T>{int getid(int k){ if(k >= len*2-1){ return k; } else if(k < len - 1){ return k + len; }else{ return k - len + 1; } }void add(int f, int t, T c = 1) { f = getid(f); t = getid(t); if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("segdi add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/ }int mid;int len;
public:
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
//頂点が足りなくなったらresize
segdi(int n_) : digraph<T>(1) { int nn = 1; while (nn < n_)nn *= 2; n_ = nn; len = n_; this->resize(n_ + (n_ - 1) * 2 + n_); mid = n_ + (n_ - 1) * 2; int ad = len * 2 - 1; rep(i, len - 1) { add(i, i * 2 + 1, 0); add(i, i * 2 + 2, 0); if (i * 2 + 1 >= len - 1) { add(i * 2 + 1, i + ad, 0); add(i * 2 + 2, i + ad, 0); } else { add(i * 2 + 1 + ad, i + ad, 0); add(i * 2 + 2 + ad, i + ad, 0); } } }
void dfs(vi &list, int nl, int nr, int k, int l, int r) { if (r <= nl || nr <= l)return; if (l <= nl && nr <= r) { list += k; } else { dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r); dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r); } }
void rekkyo(vi &list, int l, int r) { l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { list.push_back(l); } if (!(r & 1)) { list.push_back(r - 1); } l >>= 1; r = (r - 1) >> 1; } }
//半開
void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/ int ad = 2 * len - 1; if (mid >= n) { this->resize(n + 100); } { int l = fl, r = fr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { if (l - len + 1 < 0)add(l + ad, mid, cost); else add(l, mid, cost); } if (!(r & 1)) { if (r - 1 - len + 1 < 0)add(r - 1 + ad, mid, cost); else add(r - 1, mid, cost); } l >>= 1; r = (r - 1) >> 1; } } { int l = tl, r = tr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { add(mid, l, 0); } if (!(r & 1)) { add(mid, r - 1, 0); } l >>= 1; r = (r - 1) >> 1; } } mid++; }
};
//edgesを持たない
//dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template<class T=int>class segun : public undigraph<T>{int getid(int k){ if(k >= len*2-1){ return k; } else if(k < len - 1){ return k + len; }else{ return k - len + 1; } }void add(int f, int t, T c = 1) { f = getid(f); t = getid(t); if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("segun add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/ g[t].emplace_back(t, f, c); /*digraphと違いedgesを持たない*/ } int mid; int len;
public:
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
//頂点が足りなくなったらresize
segun(int n_) : digraph<T>(1) { int nn = 1; while (nn < n_)nn *= 2; n_ = nn; len = n_; this->resize(n_ + (n_ - 1) * 2 + n_); mid = n_ + (n_ - 1) * 2; int ad = len * 2 - 1; rep(i, len - 1) { add(i, i * 2 + 1, 0); add(i, i * 2 + 2, 0); if (i * 2 + 1 >= len - 1) { add(i * 2 + 1, i + ad, 0); add(i * 2 + 2, i + ad, 0); } else { add(i * 2 + 1 + ad, i + ad, 0); add(i * 2 + 2 + ad, i + ad, 0); } } }
void dfs(vi &list, int nl, int nr, int k, int l, int r) { if (r <= nl || nr <= l)return; if (l <= nl && nr <= r) { list += k; } else { dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r); dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r); } }
void rekkyo(vi &list, int l, int r) { l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { list.push_back(l); } if (!(r & 1)) { list.push_back(r - 1); } l >>= 1; r = (r - 1) >> 1; } }
//半開
void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/ int ad = 2 * len - 1; if (mid >= n) { this->resize(n + 100); } { int l = fl, r = fr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { if (l - len + 1 < 0)add(l + ad, mid, cost); else add(l, mid, cost); } if (!(r & 1)) { if (r - 1 - len + 1 < 0)add(r - 1 + ad, mid, cost); else add(r - 1, mid, cost); } l >>= 1; r = (r - 1) >> 1; } } { int l = tl, r = tr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { add(mid, l, 0); } if (!(r & 1)) { add(mid, r - 1, 0); } l >>= 1; r = (r - 1) >> 1; } } mid++; }
};
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define o_getid(a,b,name,...) name
#define getid(...) o_getid(__VA_ARGS__, getid_2, getid_1) (__VA_ARGS__)
#define unionfind unionfind_graph
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; } }
template<class T>unionfind(graph<T>& g) : n(g.n), trees(g.n) { par.resize(n); siz.resize(n); es.resize(n); for (ll i = 0; i < n; i++) { par[i] = i; siz[i] = 1; } add(g); }
ll root(ll x) { if (par[x] == x) { return x; } else { return par[x] = root(par[x]); }}
ll operator()(ll x){return root(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;
}
template<class T>void add(graph<T>&g){fora(e,g.edges){unite(e.f,e.t);}}
template<class T>void unite(graph<T>&g){add(g);}
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); }
vector<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
//forg基本
template<class T> struct forg_edge_body {
vector<edge_<T>> &edges;
int i;
explicit forg_edge_body(int i, vector<edge_<T>> &edges): i(i), edges(edges) {}
auto operator++() {i++;}
auto operator*() {
#ifdef type_id_graph
return tuple<int, int, int, T, int, int>(i, edges[i].f, edges[i].t, edges[i].c, edges[i].ty, edges[i].id);
#else
return tuple<int, int, int, T>(i, edges[i].f, edges[i].t, edges[i].c);
#endif
}
template<class U>auto operator!=(const U& rhs){return i != rhs.i;}
};
/*@formatter:on*/
template<class T> struct fort_edge_body {
vector<edge_<T>> &edges;
int gi, ci;
int par;
void can_gi() {
while (gi < sz(edges) && edges[gi].t == par) {
gi++;
}
}
explicit fort_edge_body(int i, int par, vector<edge_<T>> &edges) : gi(i), ci(i), par(par), edges(edges) {
can_gi();
}
auto operator++() {
ci++;
gi++;
can_gi();
}
auto operator*() {
#ifdef type_id_graph
return tuple<int, int, int, T, int, int>(gi, edges[gi].f, edges[gi].t, edges[gi].c, edges[gi].ty, edges[gi].id);
#else
return tuple<int, int, int, T>(ci, edges[gi].f, edges[gi].t, edges[gi].c);
#endif
}
template<class U> auto operator!=(const U &rhs) { return gi != rhs.gi; }
};
template<class T> struct forg_edge {
vector<edge_<T>> &edges;
forg_edge_body<T> endp;
forg_edge(vector<edge_<T>> &edges) : edges(edges), endp(sz(edges), edges) {}
auto begin() { return forg_edge_body<T>(0, edges); }
auto end() { return endp; }
};
template<class T> struct fort_edge {
vector<edge_<T>> &edges;
fort_edge_body<T> endp;
int p;
fort_edge(int p, vector<edge_<T>> &edges) : p(p), edges(edges), endp(sz(edges), p, edges) {}
auto begin() { return fort_edge_body<T>(0, p, edges); }
auto end() { return endp; }
};
/*@formatter:off*/
/*@formatter:off*/
#ifdef type_id_graph
#define forg(gi, edges) for(auto[gi, f, t, c, ty, id] : forg_edge(edges))
#define fort(ci, edges) for(auto[ci, f, t, c, ty, id] : fort_edge(p, edges))
#else
#define forg(gi, edges) for(auto[gi, f, t, c] : forg_edge(edges))
#define fort(ci, edges) for(auto[ci, f, t, c] : fort_edge(p, edges))
#endif
//@出力
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) / 2 << endl; fore(gi, g.edges){ if (f < t)os << f << " " << t << " " << c << endl; } return os;}
//@判定
template<class T> bool nibu( 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 true;}
//頂点ではなく辺の数に依存した計算量 O(E)
template<class T> bool nibu_sub( graph<T> &g) { umapi col;/*0なら無色 */ queue<int> q; /*色は01か11 */ fora(e, g.edegs) { /*fとtの色を持つか否かは同じ*/ if (col[e.f] == 0)q.push(e.f); while (!q.empty()) { int f = q.front(); q.pop(); int fc = col[f]; forg_f(gi, g[f]) { forg_f_init(g[f]); int &tc = col[t]; /*fcには色がある*/ if (fc == tc)return false; /*違う色*/ if (tc)continue; /*無色*/ tc = fc ^ 2; q.push(tc); } } } return true;}
//二部グラフを色分けした際の頂点数を返す
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_f(gi, g[now]) { forg_f_init(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> bool close(undigraph<T> &g) { int n = 0; int e = 0; rep(i, g.n) { if (sz(g[i]))n++; forg_f(gi, g[i]) {forg_f_init(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_f(gi, g[i]) {forg_f_init(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);}
//@変形
//条件(f!=0等 f,t,cが使える)を満たすsubgraphをg2に代入
#define sub_di(g, g2, zhouken) {g2.resize(g.n);fore(gi, g.edges){if(zhouken){g2.add(f,t,c);}}}
#define sub_un(g, g2, zhouken) {g2.resize(g.n);fore(gi, g.edges){bool ok = zhouken; /*片方がアウトなら駄目という扱い*/swap(f,t); ok &= zhouken;if(ok && f < t){g2.add(f,t,c);}}}
//誘導部分グラフ(両辺がVに含まれる辺を含む最大のグラフを返す) yuudou
#define sub_di_guided(g, g2, V) {vi ex(max(V)); fora(v,V){ex[v]=1;}sub_di(g, g2, ex[f] && ex[t]);}
#define sub_un_guided(g, g2, V) {vi ex(max(V)); fora(v,V){ex[v]=1;}sub_un(g, g2, ex[f] && ex[t]);}
#define sub_tree sub_un
//閉路がなければ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;}
template<class T> digraph<T> rev(digraph<T> &g) { digraph<T> r(g.n); rep(i, g.n) { forg_f(gi, g[i]) {forg_f_init(g[i]); r.add(t, f, c); }} return r;}
//lc,rcは子を持つ中で一番左、右
//(g,ind,l,r)
template<class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r) {if (sz(ind)) {cerr << "ind must be empty" << endl;exit(0);}int N = sz(g);ind.resize(N);l.resize(N, inf);r.resize(N, -1);tree<T> h(N);queue<P> q;q.emplace(-1, 0);int c = 0;while (sz(q)) {int p = q.front().first;int i = q.front().second;q.pop();ind[i] = c;if (~p)chmi(l[ind[p]], c);if (~p)chma(r[ind[p]], c);c++;forg_f(gi, g[i]) {forg_f_init(g[i]);if (t != p)q.emplace(i, t);}}fora(e, g.edges) {if (e.f < e.t) {h.add(ind[e.f], ind[e.t], e.c);}}rep(i, N) {if (l[i] == inf)l[i] = -1;}return h;}
//lc,rcは子を持つ中で一番左、右
// たとえばl[lc[x]は2段下の最左
//(g,ind,l,r,lc,rc)
template<class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r, vi &lc, vi &rc) { if (sz(ind)) { cerr << "ind must be empty" << endl; exit(0); } int N = sz(g); ind.resize(N); l.resize(N, inf); lc.resize(N, inf); r.resize(N, -1); rc.resize(N, -1); tree<T> h(N); queue<P> q; q.emplace(-1, 0); int c = 0; while (sz(q)) { int p = q.front().first; int i = q.front().second; q.pop(); ind[i] = c; if (~p) { chmi(l[ind[p]], c); chma(r[ind[p]], c); if (sz(g[i]) > 1) { chmi(lc[ind[p]], c); chma(rc[ind[p]], c); } } c++; forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != p)q.emplace(i, t); } } fora(e, g.edges) { if (e.f < e.t) { h.add(ind[e.f], ind[e.t], e.c); } } rep(i, N) { if (l[i] == inf)l[i] = -1; if (lc[i] == inf)lc[i] = -1; } return h;}
//@集計
template<class T> vi indegree(graph<T> &g) {vi ret(g.size());rep(i, g.size()) { forg_f(gi, g[i]) {forg_f_init(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;}
#define kansetu articulation
//private
/*private*/ P farthest____(tree<> &E, int cur, int pre, int d, vi &D) { D[cur] = d; P r = {d, cur};
forg_f(gi, E[cur]) {
forg_f_init(E[cur]);
if (t != pre) {
P v = farthest____(E, t, cur, d + c, 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); fora(v, per) { forg_f(gi, g[v]) { forg_f_init(g[v]);chma(dp[t], dp[f] + c); }} return max(dp);}
//iから最も離れた距離
vi diameters(tree<> &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に対応するjと距離
vp diameters_p(tree<> &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(v1.second, D[0][i]); else res[i] = mp(v2.second, D[1][i]); } return res;}
int diameter(tree<> &E) { vi d = diameters(E); return max(d);}
//最も離れた二点を返す
P diameter_p(tree<> &E) { auto d = diameters_p(E); int dis = -1; int l = -1, r = -1; rep(i, sz(d)) { if (chma(dis, d[i].se)) { l = i; r = d[i].fi; } } return mp(l, r);}
//@列挙 取得
//閉路がある時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_f(gi, g[i]) { forg_f_init(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_f(gi, g[i]) { forg_f_init(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> 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, G.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, G.n) { if (!vis[i]) dfs(i, -1, k); } sort(arti.begin(), arti.end()); return arti;}
//閉路パスを一つ返す
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_f(gi, g[v]) { forg_f_init(g[i]);if (dfs(t))return true; } state[v] = -1; path.pop_back(); return false; })(i)) { return path; } } return vi();}
#ifdef type_id_graph
vi close_path_id(digraph<> &g) { auto D = close_path(g); if(sz(D)==0)return vi(); D += D[0]; vi ret; int cur = D[0]; rep(i,sz(D)-1){ forg_f(gi, g[D[i]]){forg_f_init(g[D[i]]); if(t == D[i+1]){ ret += id; break; } } } return ret;}
#endif
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;}
//iを含む最短閉路 https://atcoder.jp/contests/abc022/tasks/abc022_c
/*閉路が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_f(gi, rg[now]) { forg_f_init(rg[now]); if (--d[t] == 0) { q += t; res[t] = 0; } } } return res;}
//@アルゴリズム
//下にkrus_idがある
#define mst krus
template<class T> vi krus_i(vector<edge_<T>> &g, int group = 1, int n = -1) { if (n == -1)fora(e, g) { chma(n, max(e.f, e.t) + 1); }; vi res; unionfind uf(n); auto eis = sorti(g); int gcou = n; fora(ei, eis) { if (gcou == group)break; if (uf.unite(g[ei].f, g[ei].t)) { res += ei; gcou--; } } return res;}
template<class T> vector<edge_<T>> krus_ed(vector<edge_<T>> &g, int group=1, int n = -1) { auto inds = krus_i(g, group, n); vector<edge_<T>> ret; fora(i, inds) ret += g[i]; return ret;}
template<class T> vector<edge_<T>> krus_ed(undigraph<T> &g, int group = 1) { if (sz(g.edges) == 0)g.set_edges(); return krus_ed(g.edges, group, g.n);}
template<class T> T krus(undigraph<T> &g, int group = 1) { auto edges = krus_ed(g, group); T res=0; fora(e,edges)res += e.c; return res;}
//森を返す
template<class T> undigraph<T> krus_un(undigraph<T> &g, int group/*森になるので*/) { return undigraph<T>(g.n, krus_ed(g, group));}
template<class T> tree<T> krus_tr(undigraph<T> &g) { return tree<T>(g.n, 0,krus_ed(g));}
template<class T> int krus(vector<edge_<T>> &g, int group = 1) { auto edges = krus_ed(g, group); T res=0; fora(e, edges)res += e.c; return res;}
/*@formatter:off*/
//@実験
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;}
/*頂点数が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;}
template<class T,class I> vector<vector<int>> table(graph<T> &g,I init_value) { vvi(res, g.n, g.n,init_value); rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(g[i]);res[i][t] = c; }} return res;}
#ifdef type_id_graph
template<class T> vector<vector<edge_<T>>> type_list(digraph<T> &g) { vector<vector<edge_<T>>> res; rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(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) { forg_f(gi, g[i]) { forg_f_init(g[i]);chma(tn, ty); }} vector<vector<edge_<T>>> res(tn + 1); vi was(g.n); rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(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;}
//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;}
//graの方が早い
#endif
//type,idが使いたい場合は
//type_id_graph
// を付ける
#define edge edge_
/*@formatter:on*/}
void solve() {
in(N);
vi X, Y;
na2(X, Y, N);
undigraph<> g(N);
auto add = [&](vi &ind, vi &Z) {
rep(li, sz(ind) - 1) {
int l = ind[li];
int r = ind[li + 1];
g.add(l, r, abs(Z[r] - Z[l]));
}
};
vp Z;
rep(i, N) {
Z += mp(X[i], Y[i]);
}
vp Z2;
rep(i, N) {
Z2 += mp(Y[i], X[i]);
}
vi ind = iota(0, N);
sort(ALL(ind), [&](int a, int b) {
return Z[a] < Z[b];
});
add(ind, X);
sort(ALL(ind), [&](int a, int b) {
return Z2[a] < Z2[b];
});
add(ind, Y);
out(mst(g));
}
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) {
//solveを書き直す
//solveを呼び出す
}
exit(0);
#endif
return 0;
};
| a.cc:17:10: fatal error: boost/sort/pdqsort/pdqsort.hpp: No such file or directory
17 | #include <boost/sort/pdqsort/pdqsort.hpp>
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compilation terminated.
|
s296704754 | p03682 | C++ | /*temp*/
//
//
//
//
//#undef _DEBUG
//#pragma GCC optimize("Ofast")
//不動小数点の計算高速化
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#include <boost/multiprecision/cpp_int.hpp>
#ifdef _DEBUG
#include "template.h"
#else
#if __cplusplus >= 201703L
/*Atcoderでしか使えない(c++17 && このテンプレートが使えるならAtcoder)*/
#include <boost/sort/pdqsort/pdqsort.hpp>
#define fast_sort boost::sort::pdqsort
#endif
#endif
#ifndef _DEBUG
#ifndef UNTITLED15_TEMPLATE_H
#define UNTITLED15_TEMPLATE_H
#ifdef _DEBUG
#include "bits_stdc++.h"
#else
#include <bits/stdc++.h>
#endif
#ifndef fast_sort
#define fast_sort sort
#endif
//#define use_pq
#define use_for
#define use_for_each
#define use_sort
#define use_fill
#define use_rand
#define use_mgr
#define use_rui
#define use_compress
//
//
//
//
//
//
#define use_pbds
#ifdef use_pbds
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template<class T, class U, class W, class X> auto count(__gnu_pbds::gp_hash_table<T, U, W> &a, X k) { return a.find(k) != a.end(); }
#endif
using namespace std;
using namespace std::chrono;
/*@formatter:off*/
#define ll long long
using sig_dou = double;
//マクロ省略形 関数等
#define arsz(a) (sizeof(a)/sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define mt make_tuple
#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()
template<class T,class U> auto max(T a, U b){return a>b ? a: b;}
template<class T,class U> auto min(T a, U b){return a<b ? a: b;}
//optional<T>について下でオーバーロード(nullopt_tを左辺右辺について単位元として扱う)
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;}
//メタ系 meta
template<typename T, typename U = typename T::value_type>std::true_type value_type_tester(signed);
template<typename T>std::false_type value_type_tester(long);
template<typename T>struct has_value_type: decltype(value_type_tester<T>(0)){};
//A<T>でTを返す
template<class T>using decl_t = typename T::value_type;
//A<B<.....T>>でTを返す
template<class T, bool end = !has_value_type<T>::value> struct decl2_ {typedef T type;};
template<class T> struct decl2_<T, false> {typedef typename decl2_<decl_t<T>>::type type;};
template<class T> using decl2_t = typename decl2_<T>::type;
//#define decl_max(a, b) decltype(max(MAX<decltype(a)>(), MAX<decltype(b)>()))
#define is_same2(T, U) is_same<T, U>::value
template<class T>struct is_vector : std::false_type{};
template<class T>struct is_vector<std::vector<T>> : std::true_type{};
//大きい型を返す max_type<int, char>::type
//todo mintがlong long より小さいと判定されるためバグる
template<class T1, class T2, bool t1_bigger = (sizeof(T1) > sizeof(T2))>struct max_type{typedef T1 type;};
template<class T1, class T2> struct max_type<T1, T2, false>{typedef T2 type;};
template<class T> struct vec_rank : integral_constant<int, 0> {};
template<class T> struct vec_rank<vector<T>> : integral_constant<int, vec_rank<T>{} + 1> {};
//N個のTを並べたtupleを返す
//tuple_n<3, int>::type tuple<int, int, int>
template<size_t N, class T, class... Arg> struct tuple_n{typedef typename tuple_n<N-1, T, T, Arg...>::type type;};
template<class T, class...Arg> struct tuple_n<0, T, Arg...>{typedef tuple<Arg...> type;};
struct dummy_t1{};struct dummy_t2{};
struct dummy_t3{};struct dummy_t4{};
struct dummy_t5{};struct dummy_t6{};
//template<class T, require(is_integral<T>::value)>など
#define require_t(bo) enable_if_t<bo>* = nullptr
//複数でオーバーロードする場合、引数が同じだとうまくいかないため
//require_arg(bool, dummy_t1)
//require_arg(bool, dummy_t2)等とする
#define require_arg1(bo) enable_if_t<bo> * = nullptr
#define require_arg2(bo, dummy_type) enable_if_t<bo, dummy_type> * = nullptr
#define require_arg(...) over2(__VA_ARGS__,require_arg2,require_arg1)(__VA_ARGS__)
//->//enable_if_tのtを書き忘れそうだから
#define require_ret(bo, ret_type) enable_if_t<bo, ret_type>
#define int long long //todo 消したら動かない intの代わりにsignedを使う
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) # VariableName
//最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#ifdef _DEBUG
string message;
string res_mes;
bool was_deb = false;
[[ noreturn ]]
void my_exit(signed e = 0) {
if (was_deb && sz(res_mes)) {
cerr << "result = " << endl << res_mes << endl;
}
if (sz(message)) {
cerr << "****************************" << endl;
cerr << "Note." << endl;
cerr << message << endl;
cerr << "****************************" << endl;
}
exit(e);
}
#define exit my_exit
#endif
void assert2(bool b,const string& s = ""){ if(!b){ cerr<<s<<endl; exit(1);/*assert(0);*/ }}
//my_nulloptをあらゆる操作の単位元的な物として扱う
//vectorの参照外時に返したり、右辺値として渡されたときに何もしないなど
struct my_nullopt_t {} my_nullopt;
#define nullopt_t my_nullopt_t
#define nullopt my_nullopt
/*@formatter:off*/
//値が無いときは、setを使わない限り代入できない
//=を使っても無視される
template<class T> struct my_optional {
private:
bool is_null;
T v;
public:
typedef T value_type ;
my_optional() : is_null(true) {}
my_optional(const nullopt_t&) : is_null(true) {}
my_optional(const T& v) : v(v), is_null(false) {}
bool has_value() const { return !is_null; }
T &value() { static string mes = "optional has no value";assert2(!is_null, mes);return v;}
const T &value() const { static string mes = "optional has no value";assert2(!is_null, mes);return v;}
void set(const T &nv) {is_null = false;v = nv;}
template<class U> void operator=(const U &v) {
set(v);//null状態でも代入出来るようにした
// if (has_value())value() = v; else return;
}
template<class U> void operator=(const my_optional<U> &v) {
if (/*has_value() && */v.has_value())(*this) = v; else return;
}
/*@formatter:off*/
void reset() { is_null = true; }
void operator=(const nullopt_t &) { reset(); }
template<require_t(!is_same2(T, bool))>
explicit operator bool(){return !is_null;}
//nullの時はエラー
operator T&(){return value();}
operator const T&()const {return value();}
my_optional<T> operator++() { if (this->has_value()) { this->value()++; return *this; } else { return *this; } }
my_optional<T> operator++(signed) { if (this->has_value()) { auto tem = *this; this->value()++; return tem; } else { return *this; } }
my_optional<T> operator--() { if (this->has_value()) { this->value()--; return *this; } else { return *this; } }
my_optional<T> operator--(signed) { if (this->has_value()) { auto tem = *this; this->value()--; return tem; } else { return *this; } }
};
template<class T>istream &operator>>(istream &iss, my_optional<T>& v) { T val; iss>>val; v.set(val); return iss;}
#define optional my_optional
template<class T>
using opt = my_optional<T>;
//template<class T, class A = std::allocator<T>> struct debtor : std::vector<T, A> {
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<pair<const Key, T> >>
struct o_map : std::map<Key, optional<T>, Compare, Allocator> {
optional<T> emp;
o_map() : std::map<Key, optional<T>, Compare, Allocator>() {}
auto operator()(const nullopt_t&) {return nullopt;}
optional<T> &operator()(const optional<Key> &k) {if (k.has_value()) {return std::map<Key, optional<T>, Compare, Allocator>::operator[](k.value());} else {emp.reset();return emp;}}
optional<T> &operator()(const Key &k) { auto &v = std::map<Key, optional<T>, Compare, Allocator>::operator[](k); if (v.has_value())return v; else { v.set(0); return v; } }
template<class U> void operator[](U){static string mes = "s_map cant []";assert2(0, mes);}
};
//以下、空のoptionalをnulloptと書く
//ov[-1(参照外)] でnulloptを返す
//ov[nullopt] で nulloptをかえす
template<class T> struct ov{
optional<T> emp;
vector<optional<T>> v;
ov(int i = 0, T val = 0):v(i, val){}
template<class U>ov(const U& rhs){v.resize(sz(rhs));for (int i = 0; i < sz(rhs); i ++)v[i].set(rhs[i]);}
optional<T> &operator()(int i) {if (i < 0 || sz(v) <= i) {emp.reset();return emp;} else { return v[i]; }}
optional<T> &operator()(const nullopt_t &) { return operator()(-1); }
optional<T> &operator()(const optional<T> &i) { if (i.has_value())return operator()(i.value()); else { return operator()(-1); } }
/*@formatter:off*/
};
template<class T>string deb_tos(const ov<T>& v){
return deb_tos(v.v);
}
//vectorに対しての処理は.vを呼ぶ
template<class T> class ovv{
optional<T> emp;
public:
vector<vector<optional<T>> > v ;
ovv(int i=0, int j=0, T val = 0) : v(i, vector<optional<T>>(j, val) ){}
ovv(const vector<vector<T> >& S){
v.resize(S.size());
for (int h = 0; h < sz(S); h++){
v[h].resize(sz(S[h]));
for (int w = 0; w < sz(S[h]); w++){
v[h][w].set(S[h][w]);
}
}
}
optional<T> &operator()(int i, int j) { if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) { emp.reset();return emp; } else { return v[i][j]; } }
//再帰ver 遅いと思う
// optional<T>& gets(optional<T>& v){return v;}
// template<class V, class H, class... U> optional<T>& gets(V& v, H i, U... tail){ if constexpr(is_same2(H, nullopt_t))return operator()(-1,-1); else if constexpr(is_same2(H, optional<int>)){ if(i.has_value())return gets(v[(int)i], tail...); else return operator()(-1,-1); }else if constexpr(is_integral<H>::value){ return gets(v[(int)i], tail...); }else{ assert(0); return emp; } }
#if __cplusplus >= 201703L
//if constexprバージョン 上が遅かったらこれで
template<class U, class V> optional<T> &operator()(const U &i, const V &j) { /*駄目な場合を除外*/ if constexpr(is_same2(U, nullopt_t) || is_same2(U, nullopt_t)) { return operator()(-1, -1); /* o, o*/ } else if constexpr(is_same2(U, optional<int>) && is_same2(V, optional<int>)) { return operator()(i.has_value() ? (int) i : -1, j.has_value() ? (int) j : -1); /* o, x*/ } else if constexpr(is_same2(U, optional<int>)) { return operator()(i.has_value() ? (int) i : -1, (int) j); /* x, o*/ } else if constexpr(is_same2(V, optional<int>)) { return operator()((int) i, j.has_value() ? (int) j : -1); /* x, x*/ } else { return operator()((int) i, (int) j); } }
#endif
operator const vector<vector<optional<T>> >&(){
return v;
}
};
template<class T>istream &operator>>(istream &iss, ovv<T> &a) { for (int h = 0; h < sz(a); h ++){ for (int w = 0; w < sz(a[h]); w ++){ iss>>a.v[h][w ]; } } return iss;}
template<class T>ostream &operator<<(ostream &os, ovv<T>& a) {
os << a.v;
return os;
}
template<class T>string deb_tos(const ovv<T>& v){
return deb_tos(v.v);
}
template<class T> struct ov3{
optional<T> emp;
vector<vector<vector<optional<T>>> > v ;
ov3(int i, int j, int k, T val = 0) : v(i, vector<vector<optional<T>>>(j, vector<optional<T>>(k, val) ) ){}
optional<T> &operator()(int i, int j, int k) { if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) { if(k < 0 || sz(v[i][j]) <= k){ emp.reset(); return emp; } } return v[i][j][k]; }
private:
#if __cplusplus >= 201703L
//再帰ver 遅いと思う
template<class V, class H> optional<T> &gets(V &nowv, H i) { if constexpr(is_same2(H, nullopt_t)) { emp.reset(); return emp; } else if constexpr(is_same2(H, optional<int>)) { if (i.has_value()) { return nowv[(int) i]; } else { emp.reset();return emp; } } else if constexpr(is_integral<H>::value) { return nowv[(int) i]; } else { static string mes = "ov3 error not index";assert2(0, mes); emp.reset();return emp; } }
//todo const &消した
template<class V, class H, class... U> optional<T> &gets(V &nowv, H i, U... tail) { if constexpr(is_same2(H, nullopt_t)) { emp.reset();return emp; } else if constexpr(is_same2(H, optional<int>)) { if (i.has_value()) { return gets(nowv[(int) i], tail...); } else { emp.reset();return emp; } } else if constexpr(is_integral<H>::value) { return gets(nowv[(int) i], tail...); } else { static string mes = "ov3 error not index";assert2(0, mes); emp.reset();return emp; } }
#endif
public:
template<class U, class V, class W> optional<T> &operator()(U i, V j, W k) { return gets(v, i, j, k); }
/*@formatter:off*/
};
template<class T>string deb_tos(const ov3<T>& v){
return deb_tos(v.v);
}
//nullopt_t
//優先順位
//null, [opt, tem]
// + と += は違う意味を持つ
//val+=null : val
//val+null : null
//
//+は途中計算
//+=は最終的に格納したい値にだけ持たせる
//+=がvoidを返すのは、途中計算で使うのを抑制するため
//nulloptを考慮する際、計算途中では+を使ってnulloptを作り
//格納する際は+=で無効にする必要がある
//演算子==
//optional<int>(10) == 10
//全ての型に対応させ、value_typeが等しいかを見るようにするのもありかも
//null同士を比較する状況はおかしいのではないか
bool operator==(const nullopt_t &, const nullopt_t&){assert2(0, "nul == null cant hikaku");return false;}
template<class T> bool operator==(const nullopt_t &, const T&){return false;}
template<class T> bool operator!=(const nullopt_t &, const T&){return true;}
template<class T> bool operator==(const T&, const nullopt_t &){return false;}
template<class T> bool operator!=(const T&, const nullopt_t &){return true;}
//nullを
nullopt_t& operator +(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator -(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator *(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator /(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator +=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator -=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator *=(const nullopt_t &, const nullopt_t&) {return nullopt;}
nullopt_t& operator /=(const nullopt_t &, const nullopt_t&) {return nullopt;}
template<class ANY> nullopt_t operator+(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator-(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator*(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator/(const nullopt_t&, const ANY &) {return nullopt;}
template<class ANY> nullopt_t operator+(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator-(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator*(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> nullopt_t operator/(const ANY &, const nullopt_t &) {return nullopt;}
template<class ANY> void operator+=(nullopt_t &, const ANY &) {}
template<class ANY> void operator-=(nullopt_t &, const ANY &) {}
template<class ANY> void operator*=(nullopt_t &, const ANY &) {}
template<class ANY> void operator/=(nullopt_t &, const ANY &) {}
template<class ANY> void operator+=(ANY &, const nullopt_t &) {}
template<class ANY> void operator-=(ANY &, const nullopt_t &) {}
template<class ANY> void operator*=(ANY &, const nullopt_t &) {}
template<class ANY> void operator/=(ANY &, const nullopt_t &) {}
template<class T>struct is_optional:false_type{};
template<class T>struct is_optional<optional<T>>:true_type{};
template<class T, class U>
true_type both_optional(optional<T> t, optional<U> u);
false_type both_optional(...);
template<class T, class U> class opt_check : public decltype(both_optional(declval<T>(), declval<U>())) {};
//optionalは同じ型同士しか足せない
//(o, t), (t, o), (o, o)
#define opt_tem(op) \
template<class O, class O_ret = decltype(declval<O>() op declval<O>())>optional<O_ret> operator op(const optional<O> &opt1, const optional<O> &opt2) { if (!opt1.has_value() || !opt2.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt1.value() op opt2.value()); }}\
template<class O, class T, class O_ret = decltype(declval<O>() op declval<O>())> auto operator op(const optional<O> &opt, const T &tem) -> require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { if (!opt.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt.value() op tem); }}\
template<class O, class T, class O_ret = decltype(declval<O>() op declval<O>())> auto operator op(const T &tem, const optional<O> &opt) -> require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { if (!opt.has_value()) { return optional<O_ret>(); } else { return optional<O_ret>(opt.value() op tem); }}
/*@formatter:off*/
opt_tem(+)opt_tem(-)opt_tem(*)opt_tem(/)
//比較はoptional<bool>を返す
opt_tem(<)opt_tem(>)opt_tem(<=)opt_tem(>=)
/*@formatter:on*//*@formatter:off*/
template<class O, class T> bool operator==(const optional<O>& opt, const T& tem){if(opt.has_value()){return opt.value()==tem;}else return nullopt == tem;}
template<class O, class T> bool operator!=(const optional<O>& opt, const T& tem){if(opt.has_value()){return opt.value()!=tem;}else return nullopt != tem;}
template<class O, class T> bool operator==(const T& tem, const optional<O>& opt){if(opt.has_value()){return opt.value()==tem;}else return nullopt == tem;}
template<class O, class T> bool operator!=(const T& tem, const optional<O>& opt){if(opt.has_value()){return opt.value()!=tem;}else return nullopt != tem;}
template<class O> bool operator==(const optional<O>& opt1, const optional<O>& opt2){ if(opt1.has_value() != opt2.has_value()){ return false; }else if(opt1.has_value()){ return opt1.value() == opt2.value(); }else { return nullopt == nullopt; }}
template<class O> bool operator!=(const optional<O>& opt1, const optional<O>& opt2){return !(opt1 == opt2);}
//(a+=null) != (a=a+null)
// a null
template<class T, class O> void operator+=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem += opt.value(); }}
template<class T, class O> void operator-=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem -= opt.value(); }}
template<class T, class O> void operator*=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem *= opt.value(); }}
template<class T, class O> void operator/=(T &tem, const optional<O> &opt) { if (opt.has_value()) { tem /= opt.value(); }}
template<class T, class O> void operator+=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() += tem; }}
template<class T, class O> void operator-=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() -= tem; }}
template<class T, class O> void operator*=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() *= tem; }}
template<class T, class O> void operator/=(optional<O> &opt, const T &tem) { if (opt.has_value()) { opt.value() /= tem; }}
//
template<class Ol, class Or> void operator+=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl += opr.value(); }}
template<class Ol, class Or> void operator-=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl -= opr.value(); }}
template<class Ol, class Or> void operator*=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl *= opr.value(); }}
template<class Ol, class Or> void operator/=(optional<Ol> &opl, const optional<Or> &opr) { if (opr.has_value()) { return opl /= opr.value(); }}
/*@formatter:off*/
template<class U> auto max(const nullopt_t &, const U &val) { return val; }
template<class U> auto max(const U &val, const nullopt_t &) { return val; }
template<class U> auto min(const nullopt_t &, const U &val) { return val; }
template<class U> auto min(const U &val, const nullopt_t &) { return val; }
template<class T, class U> auto max(const optional<T> &opt, const U &val) { if (opt.has_value())return max(opt.value(), val); else return val; }
template<class T, class U> auto max(const U &val, const optional<T> &opt) { if (opt.has_value())return max(opt.value(), val); else return val; }
template<class T, class U> auto min(const optional<T> &opt, const U &val) { if (opt.has_value())return min(opt.value(), val); else return val; }
template<class T, class U> auto min(const U &val, const optional<T> &opt) { if (opt.has_value())return min(opt.value(), val); else return val; }
//null , optional, T
bool chma(nullopt_t &, const nullopt_t &) { return false; }
template<class T> bool chma(T &opt, const nullopt_t &) { return false; }
template<class T> bool chma(nullopt_t &, const T &opt) { return false; }
template<class T> bool chma(optional<T> &olv, const optional<T> &orv) { if (orv.has_value()) { return chma(olv, orv.value()); } else return false; }
template<class T, class U> bool chma(optional<T> &opt, const U &rhs) { if (opt.has_value()) { return chma(opt.value(), rhs); } else return false; }
template<class T, class U> bool chma(T &lhs, const optional<U> &opt) { if (opt.has_value()) { return chma(lhs, opt.value()); } else return false; }
bool chmi(nullopt_t &, const nullopt_t &) { return false; }
template<class T> bool chmi(T &opt, const nullopt_t &) { return false; }
template<class T> bool chmi(nullopt_t &, const T &opt) { return false; }
template<class T> bool chmi(optional<T> &olv, const optional<T> &orv) { if (orv.has_value()) { return chmi(olv, orv.value()); } else return false; }
template<class T, class U> bool chmi(optional<T> &opt, const U &rhs) { if (opt.has_value()) { return chmi(opt.value(), rhs); } else return false; }
template<class T, class U> bool chmi(T &lhs, const optional<U> &opt) { if (opt.has_value()) { return chmi(lhs, opt.value()); } else return false; }
template<class T> ostream &operator<<(ostream &os, optional<T> p) { if (p.has_value())os << p.value(); else os << "e"; return os;}
template<class T>using opt = my_optional<T>;
struct xorshift {
/*@formatter:on*/
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
/*@formatter:off*/
size_t operator()(const 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()(const 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 T, class U> size_t operator()(const std::pair<T, U>& x) const{ static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); uint64_t hasx = splitmix64(x.first); uint64_t hasy = splitmix64(x.second + FIXED_RANDOM); return hasx ^ hasy; }
template<class T> size_t operator()(const vector<T> &x) const { uint64_t has = 0; static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); uint64_t rv = splitmix64(FIXED_RANDOM); for (int i = 0; i < sz(x); i ++){ uint64_t v = splitmix64(x[i] + rv); has ^= v; rv = splitmix64(rv); } return has; }
};
#ifdef _DEBUG
//#define use_debtor
//template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) { return a.find(k) != a.end(); }
#ifdef use_debtor
//https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template<class T, class A = std::allocator<T>> struct debtor : std::vector<T, A> {
using std::vector<T, A>::vector;
template<class U> int deb_v(U a, int v) { return v; }
template<class U> int deb_v(debtor<U> &a, int v = 0) { cerr << a.size() << " "; return deb_v(a.at(0), v + 1); }
template<class U> void deb_o(U a) { cerr << a << " "; }
template<class U> void deb_o(debtor<U> &a) { for (int i = 0; i < min((int) a.size(), 15ll); i++) { deb_o(a[i]); } if ((int) a.size() > 15) { cerr << "..."; } cerr << endl; }
typename std::vector<T>::reference my_at(typename std::vector<T>::size_type n, vector<int> &ind) { if (n < 0 || n >= (int) this->size()) { int siz = (int) this->size(); cerr << "vector size = "; int dim = deb_v((*this)); cerr << endl; ind.push_back(n); cerr << "out index at "; for (auto &&i: ind) { cerr << i << " "; } cerr << endl; cerr << endl; if (dim <= 2) { deb_o((*this)); } exit(0); } return this->at(n); }
typename std::vector<T>::reference operator[](typename std::vector<T>::size_type n) { if (n < 0 || n >= (int) this->size()) { int siz = (int) this->size(); cerr << "vector size = "; int dim = deb_v((*this)); cerr << endl; cerr << "out index at " << n << endl; cerr << endl; if (dim <= 2) { deb_o((*this)); } exit(0); } return this->at(n); }
};
#define vector debtor
#endif
#ifdef use_pbds
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>
#endif
//区間削除は出来ない
//gp_hash_tableでcountを使えないようにするため
template<class K, class V>using umap_f = unordered_map<K, V>;
#else
#define endl '\n'
//umapはunorderd_mapになる
//umapiは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>
template<class K, class V>
struct umap_f : public __gnu_pbds::gp_hash_table<K, V, xorshift>{
int count(const K& k){
return this->find(k) != this->end();
}
};
#endif
#define umapi unordered_map<ll,ll>
#define umapp unordered_map<P,ll>
#define umappp unordered_map<P,P>
#define umapu unordered_map<uint64_t,ll>
#define umapip unordered_map<ll,P>
template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) { return a.find(k) != a.end(); }
/*@formatter:off*/
#ifdef use_pbds
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); }
#endif
//衝突対策
#define ws ws_
typedef tuple<ll, ll, ll> T;
typedef tuple<ll, ll, ll, ll> F;
//T mt(ll a, ll b, ll c) { return T(a, b, c); }
//F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }
//関数内をまとめる
//初期値l=-1, r=-1
void set_lr12(int &l, int &r, int n) { /*r==-1*/ if (r == -1) { if (l == -1) { l = 0; r = n; } else { r = l; l = 0; } }}
//@マクロ省略系 型,構造
//using で元のdoubleを同時に使えるはず
#define double_big
#ifdef double_big
#define double long double
//#define pow powl
#endif
using dou = double;
/*@formatter:off*/
template<class T> T MAX() { return numeric_limits<T>::max(); }
template<class T> T MIN() { return numeric_limits<T>::min(); }
constexpr ll inf = (ll) 1e9 + 100;
constexpr ll linf = (ll) 1e18 + 100;
constexpr dou dinf = (dou) linf * linf;
constexpr char infc = '{';
const string infs = "{";
template<class T> T INF() { return MAX<T>() / 2; }
template<> signed INF() { return inf; }
template<> ll INF() { return linf; }
template<> double INF() { return dinf; }
template<> char INF() { return infc; }
template<> string INF() { return infs; }
const double eps = 1e-9;
//#define use_epsdou
#ifdef use_epsdou
//基本コメントアウト
struct epsdou { double v; epsdou(double v = 0) : v(v) {} template<class T> epsdou &operator+=(T b) { v += (double) b; return (*this); } template<class T> epsdou &operator-=(T b) { v -= (double) b; return (*this); } template<class T> epsdou &operator*=(T b) { v *= (double) b; return (*this); } template<class T> epsdou &operator/=(T b) { v /= (double) b; return (*this); } epsdou operator+(epsdou b) { return v + (double) b; } epsdou operator-(epsdou b) { return v - (double) b; } epsdou operator*(epsdou b) { return v * (double) b; } epsdou operator/(epsdou b) { return v / (double) b; } epsdou operator-() const { return epsdou(-v); } template<class T> bool operator<(T b) { return v < (double) b; } template<class T> bool operator>(T b) {auto r = (double)b; return v > (double) b; } template<class T> bool operator==(T b) { return fabs(v - (double) b) <= eps; } template<class T> bool operator<=(T b) { return v < (double) b || fabs(v - b) <= eps; } template<class T> bool operator>=(T b) { return v > (double) b || fabs(v - b) <= eps; } operator double() { return v; }};
template<>epsdou MAX(){return MAX<double>();}
template<>epsdou MIN(){return MIN<double>();}
//priqrity_queue等で使うのに必要
bool operator<(const epsdou &a, const epsdou &b) {return a.v < b.v;}
bool operator>(const epsdou &a, const epsdou &b) {return a.v > b.v;}
istream &operator>>(istream &iss, epsdou &a) {iss >> a.v;return iss;}
ostream &operator<<(ostream &os, epsdou &a) {os << a.v;return os;}
#define eps_conr_t(o) template<class T> epsdou operator o(T a, epsdou b) {return (dou) a o b.v;}
#define eps_conl_t(o) template<class T> epsdou operator o(epsdou a, T b) {return a.v o (dou) b;}
eps_conl_t(+)eps_conl_t(-)eps_conl_t(*)eps_conl_t(/)eps_conr_t(+)eps_conr_t(-)eps_conr_t(*)eps_conr_t(/)
//template<class U> epsdou max(epsdou a, U b){return a.v>b ? a.v: b;}
//template<class U> epsdou max(U a, epsdou b){return a>b.v ? a: b.v;}
//template<class U> epsdou min(epsdou a, U b){return a.v<b ? a.v: b;}
//template<class U> epsdou min(U a, epsdou b){return a<b.v ? a: b.v;}
#undef double
#define double epsdou
#undef dou
#define dou epsdou
#endif
template<class T = int, class A, class B = int> T my_pow(A a, B b = 2) {
if(b < 0)return (T)1 / my_pow<T>(a, -b);
#if __cplusplus >= 201703L
if constexpr(is_floating_point<T>::value) { return pow((T) a, (T) b); }
else if constexpr(is_floating_point<A>::value) { assert2(0, "pow <not dou>(dou, )");/*return 0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/}
else if constexpr(is_floating_point<B>::value) { assert2(0, "pow <not dou>(, dou)");/*return 0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/}
else {
#endif
T ret = 1; T bek = a; while (b) { if (b & 1)ret *= bek; bek *= bek; b >>= 1; } return ret;
#if __cplusplus >= 201703L
}
#endif
}
#define pow my_pow
#define ull unsigned long long
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 upd update
#define sstream stringstream
#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 lam1(ret) [&](auto&& v){return ret;}
#define lam2(v, ret) [&](auto&& v){return ret;}
#define lam(...) over2(__VA_ARGS__,lam2,lam1)(__VA_ARGS__)
#define lamr(right) [&](auto&& p){return p right;}
#define unique(v) v.erase( unique(v.begin(), v.end()), v.end() );
//マクロ省略系 コンテナ
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 V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>>a
#define vvt2(t, a, b) vector<vector<t>>a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b,vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b,vector<t>(c,d))
#define vv(type, ...) over4(__VA_ARGS__,vvt4,vvt3,vvt2 ,vvt1,vvt0)(type,__VA_ARGS__)
#define vvi(...) vv(ll,__VA_ARGS__)
#define vvb(...) vv(bool,__VA_ARGS__)
#define vvs(...) vv(string,__VA_ARGS__)
#define vvd(...) vv(double,__VA_ARGS__)
#define vvc(...) vv(char,__VA_ARGS__)
#define vvp(...) vv(P,__VA_ARGS__)
#define vvt(...) vv(T,__VA_ARGS__)
//optional
#define vvoi(...) vv(optional<ll>,__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 vn(type, name, ...) auto name = make_v<type>(__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 setp = set<P>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll,xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
//初期化子を与える
template<template<class...> class MAP, class K, class V, class ... A>
struct init_map : public MAP<K, V, A...> {
V init_value;
init_map(V init_value = 0) : MAP<K, V, A...>(), init_value(init_value) {}
V &operator[](const K &k) {
if (MAP<K, V, A...>::count(k)==0) {
return MAP<K, V, A...>::operator[](k) = init_value;
}
return MAP<K, V, A...>::operator[](k);
}
};
template<class... A> using map2 = init_map<map, A...>;
template<class... A> using umap2 = init_map<umap, A...>;
template<class... A> using umap_f2 = init_map<umap_f, A...>;
//任意のマクロサポート用 使う度に初期化する //todo これを消す
int index_, v1_, v2_, v3_;
/*@formatter:off*/
string to_string(char c) { string ret = ""; ret += c; return ret;}
template<class T> class pq_min_max { vector<T> d; void make_heap() { for (int i = d.size(); i--;) { if (i & 1 && d[i - 1] < d[i]) swap(d[i - 1], d[i]); int k = down(i); up(k, i); } } inline int parent(int k) const { return ((k >> 1) - 1) & ~1; } int down(int k) { int n = d.size(); if (k & 1) { /* min heap*/ while (2 * k + 1 < n) { int c = 2 * k + 3; if (n <= c || d[c - 2] < d[c]) c -= 2; if (c < n && d[c] < d[k]) { swap(d[k], d[c]); k = c; } else break; } } else { /* max heap*/ while (2 * k + 2 < n) { int c = 2 * k + 4; if (n <= c || d[c] < d[c - 2]) c -= 2; if (c < n && d[k] < d[c]) { swap(d[k], d[c]); k = c; } else break; } } return k; } int up(int k, int root = 1) { if ((k | 1) < (int) d.size() && d[k & ~1] < d[k | 1]) { swap(d[k & ~1], d[k | 1]); k ^= 1; } int p; while (root < k && d[p = parent(k)] < d[k]) { /*max heap*/ swap(d[p], d[k]); k = p; } while (root < k && d[k] < d[p = parent(k) | 1]) { /* min heap*/ swap(d[p], d[k]); k = p; } return k; }public: pq_min_max() {} pq_min_max(const vector<T> &d_) : d(d_) { make_heap(); } template<class Iter> pq_min_max(Iter first, Iter last) : d(first, last) { make_heap(); } void operator+=(const T &x) { int k = d.size(); d.push_back(x); up(k); } void pop_min() { if (d.size() < 3u) { d.pop_back(); } else { swap(d[1], d.back()); d.pop_back(); int k = down(1); up(k); } } void pop_max() { if (d.size() < 2u) { d.pop_back(); } else { swap(d[0], d.back()); d.pop_back(); int k = down(0); up(k); } } const T &get_min() const { return d.size() < 2u ? d[0] : d[1]; } const T &get_max() const { return d[0]; } int size() const { return d.size(); } bool empty() const { return d.empty(); }};
//小さいほうからM個取得するpq
template<class T> struct helper_pq_size { pq_min_max<T> q; T su = 0; int max_size = 0; helper_pq_size() {} helper_pq_size(int max_size) : max_size(max_size) {} void clear() { q = pq_min_max<T>(); su = 0; } void operator+=(T v) { su += v; q += (v); if (sz(q) > max_size) { su -= q.get_max(); q.pop_max(); } } T sum() { return su; } T top() { return q.get_min(); } void pop() { su -= q.get_min(); q.pop_min(); } T poll() { T ret = q.get_min(); su -= ret; q.pop_min(); return ret; } ll size() { return q.size(); }};
//大きいほうからM個取得するpq
template<class T> struct helper_pqg_size { pq_min_max<T> q; T su = 0; int max_size = 0; helper_pqg_size() {} helper_pqg_size(int max_size) : max_size(max_size) {} void clear() { q = pq_min_max<T>(); su = 0; } void operator+=(T v) { su += v; q += (v); if (sz(q) > max_size) { su -= q.get_min(); q.pop_min(); } } T sum() { return su; } T top() { return q.get_max(); } void pop() { su -= q.get_max(); q.pop_max(); } T poll() { T ret = q.get_max(); su -= ret; q.pop_min(); return ret; } ll size() { return q.size(); }};;
template<class T, class Container = vector<T>,class Compare = std::less<typename Container::value_type>>
struct helper_pqg { priority_queue<T, Container, Compare> q;/*小さい順*/ T su = 0; helper_pqg() {} 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>
using helper_pq = helper_pqg<T, vector<T>, greater<T>>;
#if __cplusplus >= 201703L
//小さいほうからsize個残る
//Tがoptionalなら空の時nullを返す
template<class T> struct pq {
helper_pq<T> a_q;/*大きい順*/ helper_pq_size<T> b_q;/*大きい順*/ bool aquery;
T su = 0;
pq(int size = inf) {aquery = size == inf;if (!aquery) { b_q = helper_pq_size<T>(size); }}
void clear() { if (aquery) a_q.clear(); else b_q.clear(); }
void operator+=(T v) { if (aquery) a_q += v; else b_q += v; }
//optionalなら空の時nullを返す
T top() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q) == 0)return T(); return a_q.top(); } else { if (sz(b_q) == 0)return T(); return b_q.top(); } } else { if (aquery)return a_q.top(); else return b_q.top(); } }
T sum() { if (aquery) return a_q.sum(); else return b_q.sum(); }
//optionalなら空の時何もしない
void pop() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q))a_q.pop(); } else { if (sz(b_q))b_q.pop(); }} else { if (aquery)a_q.pop(); else b_q.pop(); }} /*T*/
T poll() { if constexpr(is_optional<T>::value) { if (aquery) { if (sz(a_q) == 0)return T(); return a_q.poll(); } else { if (sz(b_q) == 0)return T(); return b_q.poll(); } } else { if (aquery)return a_q.poll(); else return b_q.poll(); } }
ll size() { if (aquery) return a_q.size(); else return b_q.size(); }
/*@formatter:off*/
};
template<class T> struct pqg { helper_pqg<T> a_q;/*大きい順*/ helper_pqg_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pqg(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pqg_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
#else
//小さいほうからsize個残る
template<class T> struct pq { helper_pq<T> a_q;/*大きい順*/ helper_pq_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pq(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pq_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
//大きいほうからsize個残る
template<class T> struct pqg { helper_pqg<T> a_q;/*大きい順*/ helper_pqg_size<T> b_q;/*大きい順*/ bool aquery; T su = 0; pqg(int size = inf) { aquery = size == inf; if (!aquery) { b_q = helper_pqg_size<T>(size); } } void clear() { if (aquery) a_q.clear(); else b_q.clear(); } void operator+=(T v) { if (aquery) a_q += v; else b_q += v; } T sum() { if (aquery)return a_q.sum(); else return b_q.sum(); } T top() { if (aquery) return a_q.top(); else return b_q.top(); } void pop() { if (aquery) a_q.pop(); else b_q.pop(); } T poll() { if (aquery) return a_q.poll(); else return b_q.poll(); } ll size() { if (aquery) return a_q.size(); else return b_q.size(); }};
#endif
#define pqi pq<ll>
#define pqgi pqg<ll>
template<class T> string deb_tos(pq<T> &q) { vector<T> res; auto temq = q; while (sz(temq))res.push_back(temq.top()), temq.pop(); stringstream ss; ss<< res; return ss.str();}
template<class T> string deb_tos(pqg<T> &q) { vector<T> res; auto temq = q; while (sz(temq))res.push_back(temq.top()), temq.pop(); stringstream ss; ss<< res; return ss.str();}
/*@formatter:off*/
//マクロ 繰り返し
//↓@オーバーロード隔離
//todo 使わないもの非表示
#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 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)
#ifdef use_for
//ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J) i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K)i = (j + 1 == J && k + 1 == K) ? i + 1 : i, j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j, k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L) i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i, j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j, k = (l + 1 == L ?(k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M) i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i, j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, k = (l + 1 == L && m + 1 == M ?(k + 1 == K ? 0 : k + 1) : k), l = m + 1 == M ? l+1 == L ? 0 : l+1 : l, m = m + 1 == M ? 0 : m + 1
#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J) for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K) for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L) for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I; nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M)for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I; nex_ind5(i, j, k, l, m, J, K, L, M))
//i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)
template<class T> void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) { while (1) { j++; if (j >= J) { j = 0; i++; if (i < I) { J = (int) s[i].size(); } } if (i >= I || J) return; }}
template<class T> void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K, vector<vector<vector<T>>> &s) { while (1) { k++; if (k >= K) { k = 0; j++; if (j >= J) { j = 0; i++; if (i >= I)return; } } J = (int) s[i].size(); K = (int) s[i][j].size(); if (J && K) return; }}
#define repv_2(i, a) repss2(i, sz(a))
//正方形である必要はない
//直前を持つのとどっちが早いか
#define repv_3(i, j, a) for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), i = 0, j = 0; i < repvI; nex_repv2(i,j,repvI,repvJ,a))
//箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a) for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), repvK =(int)a[0][0].size(), i = 0, j = 0, k=0; i < repvI; nex_repv3(i,j,k,repvI,repvJ,repvK,a))
#define repv_5(i, j, k, l, a) repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a) repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]), sz(a[0][0][0][0]))
#endif
template<typename T> struct has_rbegin_rend { private:template<typename U> static auto check(U &&obj) -> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});static std::false_type check(...);public:static constexpr bool value = decltype(check(std::declval<T>()))::value; };
template<typename T> constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template<typename Iterator> class Range { public:Range(Iterator &&begin, Iterator &&end) noexcept: m_begin(std::forward<Iterator>(begin)), m_end(std::forward<Iterator>(end)) {}Iterator begin() const noexcept { return m_begin; }Iterator end() const noexcept { return m_end; }private:const Iterator m_begin;const Iterator m_end; };
template<typename Iterator> static inline Range<Iterator> makeRange(Iterator &&begin, Iterator &&end) noexcept { return Range<Iterator>{std::forward<Iterator>(begin), std::forward<Iterator>(end)}; }
template<typename T> static inline decltype(auto) makeReversedRange(const std::initializer_list<T> &iniList) noexcept { return makeRange(std::rbegin(iniList), std::rend(iniList)); }
template<typename T, typename std::enable_if_t<has_rbegin_rend_v<T>, std::nullptr_t> = nullptr> static inline decltype(auto) makeReversedRange(T &&c) noexcept { return makeRange(std::rbegin(c), std::rend(c)); }/* rbegin(), rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/template<typename T, typename std::enable_if<!has_rbegin_rend<T>::value, std::nullptr_t>::type = nullptr> static inline void makeReversedRange(T &&) noexcept { static_assert(has_rbegin_rend<T>::value, "Specified argument doesn't have reverse iterator."); }
//#define use_for
#define form3(k, v, st) for(auto&&[k, v] : st)
#define form4(k, v, st, r) for(auto&&[k, v] : range(st.begin(), st.lower_bound(r)))
#define form5(k, v, st, l, r) for(auto&&[k, v] : range(st.lower_bound(l), st.lower_bound(r)))
#define form(...) over5(__VA_ARGS__,form5,form4,form3)(__VA_ARGS__)
#define forrm1(st) for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
#define forrm3(k, v, st) for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
//向こう側で
// ++itか it = st.erase(it)とする
#define fors1(st) for (auto &&it = st.begin(); it != st.end(); )
#define fors2(v, st) for (auto &&it = st.begin(); it != st.end(); )
#define fors3(v, st, r) for (auto &&it = st.begin(); it != st.end() && (*it) < r; )
#define fors4(v, st, l, r) for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; )
#ifdef use_for
#define forslr3(st, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b) for (auto &&forslr_it = st.begin(); forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b) for (auto &&forslr_it = st.lower_bound(l); forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define fora_f_init_2(a, A) ;
#define fora_f_init_3(fora_f_i, a, A) auto &&a = A[fora_f_i];
#define fora_f_init_4(a, b, A, B) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i];
#define fora_f_init_5(fora_f_i, a, b, A, B) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i];
#define fora_f_init_6(a, b, c, A, B, C) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i];
#define fora_f_init_7(fora_f_i, a, b, c, A, B, C) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i];
#define fora_f_init_8(a, b, c, d, A, B, C, D) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i]; auto && d = D[fora_f_i];
#define fora_f_init_9(fora_f_i, a, b, c, d, A, B, C, D) auto &&a = A[fora_f_i]; auto &&b = B[fora_f_i]; auto &&c = C[fora_f_i]; auto && d = D[fora_f_i];
#define fora_f_init(...) over9(__VA_ARGS__,fora_f_init_9, fora_f_init_8, fora_f_init_7, fora_f_init_6, fora_f_init_5, fora_f_init_4, fora_f_init_3, fora_f_init_2)(__VA_ARGS__)
#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B) auto &&a = A[forr_i]; auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B) auto &&a = A[forr_i]; auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i]; auto && d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D) auto &&a = A[forr_i]; auto &&b = B[forr_i]; auto &&c = C[forr_i]; auto && d = D[forr_i];
#define forr_init(...) over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6, forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)
#define forp_init3(k, v, S) auto &&k = S[forp_i].first;auto &&v = S[forp_i].second;
#define forp_init4(forp_i, k, v, S) auto &&k = S[forp_i].first;auto &&v = S[forp_i].second;
#define forp_init(...) over4(__VA_ARGS__,forp_init4,forp_init3,forp_init2,forp_init1)(__VA_ARGS__)
#define forrm_init(k, v, ...) auto &&k = (*forrm_it).fi;auto &&v = (*forrm_it).se;
#define fors_init(v, ...) auto &&v = (*it);
#define forlr_init(a, A, ngl, ngr) auto a = A[forlr_i]; auto prev = forlr_i ? A[forlr_i-1] : ngl;auto next = forlr_i+1< rep2lim? A[forlr_i+1] : ngr;
#define forslr_init4(a, A, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr) auto a = (*forslr_it); auto prev = (forslr_it!=A.begin())? (*std::prev(forslr_it)) : ngl;auto next = (forslr_it!=std::prev(A.end()))? (*std::next(forslr_it)) : ngr;
#define forslr_init(...) over6(__VA_ARGS__,forslr_init6,forslr_init5,forslr_init4)(__VA_ARGS__);
//こうしないとmapがおかしくなる
#define fora_f_2(a, A) for(auto&& a : A)
#define fora_f_3(fora_f_i, a, A) rep(fora_f_i, sz(A))
#define fora_f_4(a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_5(fora_f_i, a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_6(a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_7(fora_f_i, a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_8(a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define fora_f_9(fora_f_i, a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define forr_2(a, A) rer(forr_i, sz(A)-1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A)-1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A)-1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A)-1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A)-1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A)-1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A)-1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A)-1)
#endif
//↑@オーバーロード隔離
//rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__,rer4,rer3,rer2,)(__VA_ARGS__)
//自分込みで残りがREM以上の間ループを回す
#define rem(i, N, REM) for (int i = 0; i < N - REM + 1; i++)
//char用のrep
#define repc(i, m, n) for(char i = m,repc3lim=n; i < repc3lim ; ++i)
//i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__,reps5,reps4,reps3,reps2,)(__VA_ARGS__)
#define repss(...) over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a, repss2) (__VA_ARGS__)
//vectorのindexを走査する
//repv(i,j,vvi)
#define repv(...) over6(__VA_ARGS__,repv_6,repv_5,repv_4,repv_3,repv_2,)(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A)-1; i >= 0 ; i--)
//repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)
#ifdef use_for
#define fora_f(...) over9(__VA_ARGS__, fora_f_9, fora_f_8, fora_f_7, fora_f_6, fora_f_5, fora_f_4, fora_f_3, fora_f_2)(__VA_ARGS__)
#endif
#define forr(...) over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3, forr_2)(__VA_ARGS__)
//0~N-2まで見る
#define forar_init(v, rv, A) auto &&v = A[forar_i]; auto && rv = A[forar_i+1];
#define forar(v, rv, A) rep(forar_i, sz(A) - 1)
#if __cplusplus >= 201703L
template<size_t M_SZ, bool indexed, class Iterator, class T, class U=T, class V=T, class W=T>
class ite_vec_merge : public Iterator { std::size_t i = 0; vector<T> &A; vector<U> &B; vector<V> &C; vector<W> &D;public : ite_vec_merge(Iterator ita, vector<T> &A) : Iterator(ita), A(A), B(A), C(A), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B) : Iterator(ita), A(A), B(B), C(A), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C) : Iterator(ita), A(A), B(B), C(C), D(A) {} ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C, vector<W> &D) : Iterator(ita), A(A), B(B), C(C), D(D) {} auto &operator++() { ++i; this->Iterator::operator++(); return *this; } auto operator*() const noexcept { if constexpr(!indexed && M_SZ == 1) { return tuple<T &>(A[i]); } else if constexpr(!indexed && M_SZ == 2) { return tuple<T &, U &>(A[i], B[i]); } else if constexpr(!indexed && M_SZ == 3) { return tuple<T &, U &, V &>(A[i], B[i], C[i]); } else if constexpr(!indexed && M_SZ == 4) { return tuple<T &, U &, V &, W &>(A[i], B[i], C[i], D[i]); } else if constexpr(indexed && M_SZ == 1) { return tuple<int, T &>(i, A[i]); } else if constexpr(indexed && M_SZ == 2) { return tuple<int, T &, U &>(i, A[i], B[i]); } else if constexpr(indexed && M_SZ == 3) { return tuple<int, T &, U &, V &>(i, A[i], B[i], C[i]); } else if constexpr(indexed && M_SZ == 4) { return tuple<int, T &, U &, V &, W &>(i, A[i], B[i], C[i], D[i]); } else { assert(0); return tuple<int>(i); } }};
template<size_t M_SZ, bool indexed, class T, class U=T, class V=T, class W=T>
class vec_merge { vector<T> &a; vector<U> &b; vector<V> &c; vector<W> &d;public : vec_merge(vector<T> &a) : a(a), b(a), c(a), d(a) {} vec_merge(vector<T> &a, vector<U> &b) : a(a), b(b), c(a), d(a) {} vec_merge(vector<T> &a, vector<U> &b, vector<V> &c) : a(a), b(b), c(c), d(a) {} vec_merge(vector<T> &a, vector<U> &b, vector<V> &c, vector<W> &d) : a(a), b(b), c(c), d(d) {} auto begin() const { if constexpr(M_SZ == 1) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a}; } else if constexpr(M_SZ == 2) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b}; } else if constexpr(M_SZ == 3) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b, c}; } else if constexpr(M_SZ == 4) { return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a, b, c, d}; } else { assert(0); return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{std::begin(a), a}; } } auto end() const { if constexpr(M_SZ == 1) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a}; } else if constexpr(M_SZ == 2) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b}; } else if constexpr(M_SZ == 3) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b, c}; } else if constexpr(M_SZ == 4) { return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a, b, c, d}; } else { assert(0); return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{std::end(a), a}; } }};
#endif
#define fora_2(a, A) for(auto&& a : A)
#if __cplusplus >= 201703L
#define fora_3(i, a, A) for(auto[i, a] : vec_merge<1, true, decl_t<decltype(A)>>(A))
#define fora_4(a, b, A, B) for(auto[a, b] : vec_merge<2, false, decl_t<decltype(A)>, decl_t<decltype(B)>>(A, B))
#define fora_5(i, a, b, A, B) for(auto[i, a, b] : vec_merge<2, true, decl_t<decltype(A)>, decl_t<decltype(B)>>(A, B))
#define fora_6(a, b, c, A, B, C) for(auto[a, b, c] : vec_merge<3, false, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>>(A, B, C))
#define fora_7(i, a, b, c, A, B, C) for(auto[i, a, b, c] : vec_merge<3, true, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>>(A, B, C))
#define fora_8(a, b, c, d, A, B, C, D) for(auto[a, b, c, d] : vec_merge<4, false, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>, decl_t<decltype(D)>>(A, B, C, D))
#define fora_9(i, a, b, c, d, A, B, C, D) for(auto[i, a, b, c, d] : vec_merge<4, true, decl_t<decltype(A)>, decl_t<decltype(B)>, decl_t<decltype(C)>, decl_t<decltype(D)>>(A, B, C, D))
#endif
//構造化束縛ver
//1e5要素で40ms程度
//遅いときはfora_fを使う
#define fora(...) over9(__VA_ARGS__, fora_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3, fora_2)(__VA_ARGS__)
//#define forr(v, a) for(auto&& v : makeReversedRange(a))
//参照を取らない
/*@formatter:off*/
#ifdef use_for
template<class U> vector<U> to1d(vector<U> &a) { return a; }
template<class U> auto to1d(vector<vector<U>> &a) { vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)res.push_back(a2); return res;}
template<class U> vector<U> to1d(vector<vector<vector<U>>> &a) { vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) res.push_back(a3); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)res.push_back(a4); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)for (auto &&a5 : a4)res.push_back(a5); return res;}
template<class U> vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {vector<U> res; for (auto &&a1 : a)for (auto &&a2 : a1)for (auto &&a3 : a2) for (auto &&a4 : a3)for (auto &&a5 : a4)for (auto &&a6 : a5)res.push_back(a6); return res;}
#define forv(a, b) for(auto a : to1d(b))
//インデックスを前後含めて走査
#define ring(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)
//値と前後を見る
#define ringv(v, d) index_=0;for (auto prev = d[sz(d)-1],next= (int)d.size()>1?d[1]:d[0],v = d[0]; index_ < sz(d); index_++, prev = v, v = next, next = (index_>=sz(d)-1?d[0]:d[index_+1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i,sz(d))
#endif
#define forrm(...) over5(__VA_ARGS__,forrm5,forrm4,forrm3,forrm2,forrm1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__,fors4,fors3,fors2,fors1)(__VA_ARGS__)
#define forslr(...) over6(__VA_ARGS__,forslr6,forslr5,forslr4,forslr3)(__VA_ARGS__)
#define forp3(k, v, st) rep(forp_i,sz(st))
#define forp4(forp_i, k, v, st) rep(forp_i,sz(st))
#define forp(...) over4(__VA_ARGS__,forp4,forp3)(__VA_ARGS__)
//to_vec(rep(i, N))のように使い
//iが走査した値を持つvectorを返す
#define to_vec2(type, my_for) \
[&](){ \
vector<type> ret; \
my_for{ \
ret.push_back(i); \
} \
return ret; \
}()
#define to_vec1(my_for) to_vec2(int, my_for)
#define to_vec(...) over2(__VA_ARGS__,to_vec2,to_vec1)(__VA_ARGS__)
//マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const double PI = 3.1415926535897932384626433832795029L;
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); }};
}
//stream まとめ
/*@formatter:off*/
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 << get<0>(p) << " " << get<1>(p) << " " << get<2>(p);return os;}
ostream &operator<<(ostream &os, F p) {os << get<0>(p) << " " << get<1>(p) << " " << get<2>(p)<<" "<< get<3>(p);return os;}
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec_) {for (ll i = 0; i < vec_.size(); ++i)os << vec_[i] << (i + 1 == vec_.size() ? "" : " ");return os;}
template<typename T> ostream &operator<<(ostream &os, const 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, const map<T, U> &m) {os<<endl;for (auto &&v:m) os << v << endl;return os;}
template<typename T, typename U> ostream &operator<<(ostream &os, const unordered_map<T, U> &m) {os<<endl;for (auto &&v:m) os << v << endl;return os;}
template<typename T, typename U> string deb_tos(const unordered_map<T, U> &m) { map<T, U> a; for (auto &&v:m) { a[v.first] = v.second; } stringstream ss; ss << a; return ss.str();}
template<class T> ostream &operator<<(ostream &os, const set<T>& s) { fora(v, s) { os << v << " "; } return os;}
template<class T> ostream &operator<<(ostream &os, const mset<T>& s) { fora(v, s) { os << v << " "; } return os;}
template<class T> ostream &operator<<(ostream &os, const deque<T>& a) { fora(v, a) { os << v << " "; } return os;}
ostream &operator<<(ostream &os, const vector<vector<char>> &vec_) { rep(h, sz(vec_)) { rep(w, sz(vec_[0])) { os << vec_[h][w]; } os << endl; } return os;}
ostream &operator<<(ostream &os, const vector<vector<my_optional<char>>> &vec_) {rep(h, sz(vec_)) { rep(w, sz(vec_[0])) { os << vec_[h][w]; } os << endl; } return os;}
//tuple "," 区切り
#if __cplusplus >= 201703L
template<class Tuple, size_t... Indicies>void helper_os_tuple(ostream &os, const Tuple &tup, index_sequence<Indicies...>) { stringstream ss; auto f=[&](auto a){ ss<<", "<<a; }; (...,f(get<Indicies>(tup))); os<<ss.str().substr(2);}
template<class... T>ostream &operator<<(ostream &os, const tuple<T...> &tup) {helper_os_tuple(os, tup, index_sequence_for<T...>{});return os;}
#endif
template<class T> struct range_now {
int l;
vector<T> A;
range_now(vector<T>&& A, int l) : A(A), l(l){}
};
/*@formatter:off*/
//template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>& a) {fora_f(v,a)os<<v<<endl;return os;}
template<typename W, typename H> void resize(W &vec_, const H head) { vec_.resize(head); }
template<typename W, typename H, typename ... T> void resize(W &vec_, const H &head, const T ... tail) {vec_.resize(head);for (auto &v: vec_)resize(v, tail...);}
//#define use_for_each //_each _all_of _any_of _none_of _find_if _rfind_if _contains _count_if _erase_if _entry_if
#ifdef use_for_each
//todo Atcoderの過去問がc++17に対応したら
#if __cplusplus >= 201703L
//for_each以外はconst & (呼び出し側のラムダも)
template<typename T, typename F> bool all_of2(const T &v, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : v) { if (!all_of2(v_, f))return false; } return true; } else { return f(v); }}
template<typename T, typename F> bool any_of2(const T &v, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : v) { if (any_of2(v_, f))return true; } return false; } else { return f(v); }}
template<typename T, typename F> bool none_of2(const T &v, F f) {return all_of2(v, [&](auto a){return !f(a);});}
/*@formatter:off*/
//存在しない場合
//1次元 Nを返す
//多次元-1を返す
template<typename T, typename F> ll find_if2(const vector<T> &v, F f) { rep(i, sz(v)) { if (f(v[i]))return i; } return sz(v);}
template<typename T, typename F> tuple<int, int> find_if2(const vector<vector<T> > &v, F f) { rep(i, sz(v)) { rep(j, sz(v[i])) { if (f(v[i][j])) { return tuple<int, int>(i, j); }}} return tuple<int, int>(-1, -1);}
template<typename T, typename F> auto find_if2(const vector<vector<vector<T> > > &v, F f) { rep(i, sz(v)) { if (auto ret = find_if2(v[i], f); get<0>(ret) != -1) { return tuple_cat(tuple<int>(i), ret); }} auto bad = tuple_cat(tuple<int>(-1), find_if2(v[0], f)); return bad;}
template<class T, class F> auto find_if2(const range_now<T> &v, F f) {return find_if2(v.A, f) + v.l;}
//存在しない場合
//1次元 -1を返す
//多次元-1を返す
template<typename T, typename F> ll rfind_if2(const vector<T> &v, F f) { rer(i, sz(v) - 1) { if (f(v[i]))return i; } return -1;}
template<typename T, typename F> tuple<int, int> rfind_if2(const vector<vector<T> > &v, F f) { rer(i, sz(v) - 1) { rer(j, sz(v[i]) - 1) { if (f(v[i][j])) { return tuple<int, int>(i, j); }}} return tuple<int, int>(-1, -1);}
template<typename T, typename F> auto rfind_if2(const vector<vector<vector<T> > > &v, F f) { rer(i, sz(v) - 1) { if (auto ret = rfind_if2(v[i], f); get<0>(ret) != -1) { return tuple_cat(tuple<int>(i), ret); }} auto bad = tuple_cat(tuple<int>(-1), rfind_if2(v[0], f)); return bad;}
//todo まとめられそう string,vector全般
template<class T> bool contains(const string &s, const T &v) { return s.find(v) != string::npos; }
template<typename T> bool contains(const vector<T> &v, const T &val) { return std::find(v.begin(), v.end(), val) != v.end(); }
template<typename T, typename F> bool contains_if2(const vector<T> &v, F f) { return find_if(v.begin(), v.end(), f) != v.end(); }
template<typename T, typename F> ll count_if2(const T &v, F f) { if constexpr(has_value_type<T>::value) { ll ret = 0; for (auto &&v_ : v) { ret += count_if2(v_, f); } return ret; } else { return f(v); }}
template<typename T, typename F> void for_each2(T &a, F f) { if constexpr(has_value_type<T>::value) { for (auto &&v_ : a)for_each2(v_, f); } else { f(a); }}
#else
template<typename T, typename F> bool all_of2(const T &v, F f) { return f(v); }
template<typename T, typename F> bool all_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> bool any_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> bool none_of2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> ll find_if2(const 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(const T &v, F f) { return f(v); }
template<typename T, typename F> ll rfind_if2(const 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(const string &s, const T &v) { return s.find(v) != string::npos; }
template<typename T> bool contains(const vector<T> &v, const T &val) { return std::find(v.begin(), v.end(), val) != v.end(); }
template<typename T, typename F> bool contains_if2(const vector<T> &v, F f) { return find_if(v.begin(), v.end(), f) != v.end(); }
template<typename T, typename F> ll count_if2(const T &v, F f) { return f(v); }
template<typename T, typename F> ll count_if2(const 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 &a, F f) {
f(a);
}
template<typename T, typename F> void for_each2(vector<T> &a, F f) {
for (auto &&v_ : a)for_each2(v_, f);
}
#endif
template<typename W> ll count_od(const vector<W> &a) { return count_if2(a, [](ll v) { return v & 1; }); }
template<typename W> ll count_ev(const vector<W> &a) { return count_if2(a, [](ll v) { return !(v & 1); }); }
//削除した後のvectorを返す
template<typename T, typename F> vector<T> erase_if2(const vector<T> &v, F f) { vector<T> nv; rep(i, sz(v)) { if (!f(v[i])) { nv.push_back(v[i]); }} return nv;}
template<typename T, typename F> vector<vector<T>> erase_if2(const vector<vector<T>> &v, F f) { vector<vector<T>> res; rep(i, sz(v)) { res[i] = erase_if2(v[i], f); } return res;}
template<typename T, typename F> vector<T> entry_if2(const vector<T> &v, F f) {vector<T> nv;rep(i, sz(v)) { if (f(v[i])) { nv.push_back(v[i]); }}return nv;}
template<typename T, typename F> vector<vector<T>> entry_if2(const vector<vector<T>> &v, F f) {vector<vector<T>> res;rep(i, sz(v)) { res[i] = entry_if2(v[i], f); }return res;}
template<typename T, typename F> ll l_rfind_if(const vector<T> &v, F f) {rer(i, sz(v) - 1) { if (f(v[i]))return i; }return -1;}
template<typename T, typename F> bool l_contains_if(const vector<T> &v, F f) {rer(i, sz(v) - 1) { if (f(v[i]))return true; }return false;}
template<class A, class B, class C> auto t_all_of(A a, B b, C c) { return std::all_of(a, b, c); }
template<class A, class B, class C> auto t_any_of(A a, B b, C c) { return std::any_of(a, b, c); }
template<class A, class B, class C> auto t_none_of(A a, B b, C c) { return std::none_of(a, b, c); }
template<class A, class B, class C> auto t_find_if(A a, B b, C c) { return std::find_if(a, b, c); }
template<class A, class B, class C> auto t_count_if(A a, B b, C c) { return std::count_if(a, b, c); }
#define all_of_s__2(a, right) (t_all_of(ALL(a),lamr(right)))
#define all_of_s__3(a, v, siki) (t_all_of(ALL(a),[&](auto v){return siki;}))
#define all_of_s(...) over3(__VA_ARGS__,all_of_s__3,all_of_s__2)(__VA_ARGS__)
//all_of(A, %2);
//all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a,lamr(right))
#define all_of__3(a, v, siki) all_of2(a,[&](auto v){return siki;})
#define all_of(...) over3(__VA_ARGS__,all_of__3,all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a,f)
#define any_of_s__2(a, right) (t_any_of(ALL(a),lamr(right)))
#define any_of_s__3(a, v, siki) (t_any_of(ALL(a),[&](auto v){return siki;}))
#define any_of_s(...) over3(__VA_ARGS__,any_of_s__3,any_of_s__2)(__VA_ARGS__)
#define any_of__2(a, right) any_of2(a,lamr(right))
#define any_of__3(a, v, siki) any_of2(a,[&](auto v){return siki;})
#define any_of(...) over3(__VA_ARGS__,any_of__3,any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a,f)
#define none_of_s__2(a, right) (t_none_of(ALL(a),lamr(right)))
#define none_of_s__3(a, v, siki) (t_none_of(ALL(a),[&](auto v){return siki;}))
#define none_of_s(...) over3(__VA_ARGS__,none_of_s__3,none_of_s__2)(__VA_ARGS__)
#define none_of__2(a, right) none_of2(a,lamr(right))
#define none_of__3(a, v, siki) none_of2(a,[&](auto v){return siki;})
#define none_of(...) over3(__VA_ARGS__,none_of__3,none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a,f)
#define find_if_s__2(a, right) (t_find_if(ALL(a),lamr(right))-a.begin())
#define find_if_s__3(a, v, siki) (t_find_if(ALL(a),[&](auto v){return siki;})-a.begin())
#define find_if_s(...) over3(__VA_ARGS__,find_if_s__3,find_if_s__2)(__VA_ARGS__)
#define find_if__2(a, right) find_if2(a,lamr(right))
#define find_if__3(a, v, siki) find_if2(a,[&](auto v){return siki;})
#define find_if__4(a, l, v, siki) (find_if2(decltype(a)(a.begin()+l , a.end()),[&](auto v){return siki;}) + l)
#define find_if(...) over4(__VA_ARGS__,find_if__4, find_if__3,find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a,f)
#define rfind_if_s__2(a, right) l_rfind_if(a, lamr(right))
#define rfind_if_s__3(a, v, siki) l_rfind_if(a, [&](auto v){return siki;})
#define rfind_if_s(...) over3(__VA_ARGS__,rfind_if_s__3,rfind_if_s__2)(__VA_ARGS__)
#define rfind_if__2(a, right) rfind_if2(a,lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a,[&](auto v){return siki;})
#define rfind_if(...) over3(__VA_ARGS__,rfind_if__3,rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a,f)
#define contains_if_s__2(a, right) l_contains_if(a, lamr(right))
#define contains_if_s__3(a, v, siki) l_contains_if(a, [&](auto v){return siki;})
#define contains_if_s(...) over3(__VA_ARGS__,contains_if_s__3,contains_if_s__2)(__VA_ARGS__)
#define contains_if__2(a, right) contains_if2(a,lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a,[&](auto v){return siki;})
#define contains_if(...) over3(__VA_ARGS__,contains_if__3,contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a,f)
#define count_if_s__2(a, right) (t_count_if(ALL(a),lamr(right)))
#define count_if_s__3(a, v, siki) (t_count_if(ALL(a),[&](auto v){return siki;}))
#define count_if_s(...) over3(__VA_ARGS__,count_if_s__3,count_if_s__2)(__VA_ARGS__)
#define count_if__2(a, right) count_if2(a,lamr(right))
#define count_if__3(a, v, siki) count_if2(a,[&](auto v){return siki;})
#define count_if(...) over3(__VA_ARGS__,count_if__3,count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a,f)
//vector<vi>で、viに対して操作
#define for_each_s__2(a, right) do{fora(v,a){v right;}}while(0)
#define for_each_s__3(a, v, shori) do{fora(v,a){shori;}}while(0)
#define for_each_s(...) over3(__VA_ARGS__,for_each_s__3,for_each_s__2)(__VA_ARGS__)
//vector<vi>で、intに対して操作
#define for_each__2(a, right) for_each2(a,lamr(right))
#define for_each__3(a, v, shori) for_each2(a,[&](auto& v){shori;})
#define for_each(...) over3(__VA_ARGS__,for_each__3,for_each__2)(__VA_ARGS__)
#define for_each_f(a, f) for_each2(a, f);
template<class T, class F> vector<T> help_for_eached(const vector<T> &A, F f) { vector<T> ret = A; for_each(ret, v, f(v)); return ret;}
#define for_eached__2(a, right) help_for_eached(a, lamr(right))
#define for_eached__3(a, v, shori) help_for_eached(a, lam(v, shori))
#define for_eached(...) over3(__VA_ARGS__,for_eached__3,for_eached__2)(__VA_ARGS__)
#define for_eached_f(a, f) for_eached2(a, f);
#define each for_each
#define eached for_eached
//#define erase_if_s__2(a, right) l_erase_if2(a,lamr(right))
//#define erase_if_s__3(a, v, siki) l_erase_if2(a,[&](auto v){return siki;})
//#define erase_if_s(...) over3(__VA_ARGS__,erase_if_s__3,erase_if_s__2)(__VA_ARGS__)
#define erase_if__2(a, right) erase_if2(a,lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a,[&](auto v){return siki;})
#define erase_if(...) over3(__VA_ARGS__,erase_if__3,erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a,f)
//#define entry_if_s__2(a, right) l_entry_if2(a,lamr(right))
//#define entry_if_s__3(a, v, siki) l_entry_if2(a,[&](auto v){return siki;})
//#define entry_if_s(...) over3(__VA_ARGS__,entry_if_s__3,entry_if_s__2)(__VA_ARGS__)
#define entry_if__2(a, right) entry_if2(a,lamr(right))
#define entry_if__3(a, v, siki) entry_if2(a,[&](auto v){return siki;})
#define entry_if(...) over3(__VA_ARGS__,entry_if__3,entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) entry_if2(a,f)
#endif
//機能削除 todo
//string.replace()は長さを指定するため、間違えやすい
/*@formatter:off*/
void replace(str &a, char key, char v) { replace(ALL(a), key, v); }
template<class T, class U> void my_replace(T& s, int l, int r, const U& t){s.replace(l, r-l, t);}
#define replace my_replace
template<class T, class U, class W> void replace(vector<W> &a, T key, U v) { rep(i, sz(a))if (a[i] == key)a[i] = v; }
template<class T, class U, class W> void replace(vector<vector<W>> &A, T key, U v) { rep(i, sz(A))replace(A[i], key, v); }
void replace(str &a, char key, str v) { if (v == "")a.erase(remove(ALL(a), key), a.end()); }
//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; }
void replace(str &a) { int dec = 0; if ('a' <= a[0] && a[0] <= 'z')dec = 'a'; if ('A' <= a[0] && a[0] <= 'Z')dec = 'A'; fora(v, a) { v -= dec; }}
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 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)); }
vi iota(ll s, ll len) {vi ve(len);iota(ALL(ve), s);return ve;}
//[iterator, iterator)等と渡す
// vectorに変換もできる
#if __cplusplus >= 201703L
template<class I, class J>
struct body_range {
I itl;
J itr;
body_range(I it, J end) : itl(it), itr(end) {}
I begin() { return itl; }
I end() { return itr; }
//毎回コピーする
operator vector<typename I::value_type>() {
return vector<typename I::value_type>(itl, itr);
}
};
template<class I, class J, require_t(is_integral_v<I>)>
vector<int> range(I l, J r){
return iota(l, r-l);
}
template<class I, require_t(is_integral_v<I>)>
vector<int> range(I r){
return iota(0, r);
}
template<class I, require_t(!is_integral_v<I>)>
auto range(I itl, I itr){
return body_range(itl, itr);
}
#endif
/*@formatter:off*/
//tuple<vecs...> = take_vt(vt)
#if __cplusplus >= 201703L
template<class Tup_l, class Tup_r, size_t ... Indicies> auto helper_take_vector_tuple(Tup_l &res, const Tup_r &rhs, index_sequence<Indicies...>) { (..., get<Indicies>(res).emplace_back(get<Indicies>(rhs))); }
template<class... T> auto take_vector_tuple(const vector<tuple<T...>> &elems) {tuple<vector<T>...> res;for (auto &&elem : elems) { helper_take_vector_tuple(res, elem, index_sequence_for<T...>{}); }return res;}
//tie_vt(A,B,C) = vt;
template<class... T> struct tie_vector_tuple { tuple<vector<T> &...> v; tie_vector_tuple(vector<T> &...args) : v(args...) {} template<class Tup, size_t ...Indicies> void helper_emplace(int i, Tup &rhs, index_sequence<Indicies...>) { (..., (get<Indicies>(v).emplace_back(get<Indicies>(rhs)))); } template<size_t ... Indicies> void clear(index_sequence<Indicies...>) { (..., (get<Indicies>(v).clear())); } void operator=(vector<tuple<T...>> &rhs) {clear(index_sequence_for<T...>{});rep(i, sz(rhs)) { helper_emplace(i, rhs[i], index_sequence_for<T...>{}); }}};
/*@formatter:off*/
//vt = make_vt(A, B, C)
template<class H, class... T> auto make_vector_tuple(const vector<H> &head, const vector<T> &...tails) { vector<tuple<H, T...>> res; rep(i, sz(head)) { res.emplace_back(head[i], tails[i]...); } return res;}
#endif
/*@formatter:off*/
#define mvt make_vector_tuple
#define tie_vt tie_vector_tuple
#define make_vt make_vector_tuple
#define take_vt take_vector_tuple
/*@formatter:off*/
//基本ソート@0
template<class T> void sort(vector<T> &a, int l = -1, int r = -1) {set_lr12(l, r, sz(a));fast_sort(a.begin() + l, a.begin() + r);}
template<class T> void rsort(vector<T> &a, int l = -1, int r = -1) {set_lr12(l, r, sz(a));fast_sort(a.begin() + l, a.begin() + r, greater<T>());};
//f(tup)の大きさでソート
template<class U, class F> void sort(vector<U> &a, F f) { fast_sort(ALL(a), [&](U l, U r) { return f(l) < f(r); }); };
template<class U, class F> void rsort(vector<U> &a, F f) { fast_sort(ALL(a), [&](U l, U r) { return f(l) > f(r); }); };
enum tuple_comparator { /*tcom_less = 1728, tcom_greater = 1729, */ fisi = 0, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd, 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};
//todo 短くする
#define set_4(i0, i1, o0, o1) [&](U l, U r) { return get<i0>(l) != get<i0>(r) ? get<i0>(l) o0 get<i0>(r) : get<i1>(l) o1 get<i1>(r) ;}
#define set_6(i0, i1, i2, o0, o1, o2) [&](U l, U r) { return get<i0>(l) != get<i0>(r) ? get<i0>(l) o0 get<i0>(r) : get<i1>(l) != get<i1>(r) ? get<i1>(l) o1 get<i1>(r) : get<i2>(l) o2 get<i2>(r); }
//functionを返すため少し遅い todo
#if __cplusplus >= 201703L
template<class... T, class U=tuple<T...>> function<bool(U, U)> get_function2(const vector<tuple<T...>> &a, tuple_comparator Compare) { if constexpr(sizeof...(T) >= 2) { int type = Compare; if (type == 0) return set_4(0, 1, <, <); if (type == 1) return set_4(0, 1, <,>); if (type == 2) return set_4(0, 1, >, <); if (type == 3) return set_4(0, 1, >, >); if (type == 4) return set_4(1, 0, <, <); if (type == 5) return set_4(1, 0, <,>); if (type == 6) return set_4(1, 0, >, <); if (type == 7) return set_4(1, 0, >, >); } if constexpr(sizeof...(T) >= 3) { int type = Compare - 8; if (type == 0) return set_6(0, 1, 2, <, <, <); else if (type == 1) return set_6(0, 1, 2, <, <,>); else if (type == 2) return set_6(0, 1, 2, <,>, <); else if (type == 3) return set_6(0, 1, 2, <,>, >); else if (type == 4) return set_6(0, 1, 2, >, <, <); else if (type == 5) return set_6(0, 1, 2, >, <,>); else if (type == 6) return set_6(0, 1, 2, >, >, <); else if (type == 7) return set_6(0, 1, 2, >, >, >); else if (type == 8) return set_6(0, 2, 1, <, <, <); else if (type == 9) return set_6(0, 2, 1, <, <,>); else if (type == 10) return set_6(0, 2, 1, <,>, <); else if (type == 11) return set_6(0, 2, 1, <,>, >); else if (type == 12) return set_6(0, 2, 1, >, <, <); else if (type == 13) return set_6(0, 2, 1, >, <,>); else if (type == 14) return set_6(0, 2, 1, >, >, <); else if (type == 15) return set_6(0, 2, 1, >, >, >); else if (type == 16) return set_6(1, 0, 2, <, <, <); else if (type == 17) return set_6(1, 0, 2, <, <,>); else if (type == 18) return set_6(1, 0, 2, <,>, <); else if (type == 19) return set_6(1, 0, 2, <,>, >); else if (type == 20) return set_6(1, 0, 2, >, <, <); else if (type == 21) return set_6(1, 0, 2, >, <,>); else if (type == 22) return set_6(1, 0, 2, >, >, <); else if (type == 23) return set_6(1, 0, 2, >, >, >); else if (type == 24) return set_6(1, 2, 0, <, <, <); else if (type == 25) return set_6(1, 2, 0, <, <,>); else if (type == 26) return set_6(1, 2, 0, <,>, <); else if (type == 27) return set_6(1, 2, 0, <,>, >); else if (type == 28) return set_6(1, 2, 0, >, <, <); else if (type == 29) return set_6(1, 2, 0, >, <,>); else if (type == 30) return set_6(1, 2, 0, >, >, <); else if (type == 31) return set_6(1, 2, 0, >, >, >); else if (type == 32) return set_6(2, 0, 1, <, <, <); else if (type == 33) return set_6(2, 0, 1, <, <,>); else if (type == 34) return set_6(2, 0, 1, <,>, <); else if (type == 35) return set_6(2, 0, 1, <,>, >); else if (type == 36) return set_6(2, 0, 1, >, <, <); else if (type == 37) return set_6(2, 0, 1, >, <,>); else if (type == 38) return set_6(2, 0, 1, >, >, <); else if (type == 39) return set_6(2, 0, 1, >, >, >); else if (type == 40) return set_6(2, 1, 0, <, <, <); else if (type == 41) return set_6(2, 1, 0, <, <,>); else if (type == 42) return set_6(2, 1, 0, <,>, <); else if (type == 43) return set_6(2, 1, 0, <,>, >); else if (type == 44) return set_6(2, 1, 0, >, <, <); else if (type == 45) return set_6(2, 1, 0, >, <,>); else if (type == 46) return set_6(2, 1, 0, >, >, <); else if (type == 47) return set_6(2, 1, 0, >, >, >); } return [&](U l, U r) { return true; };}
template<class... T> void sort(vector<tuple<T...>> &a, tuple_comparator Compare) {auto f = get_function2(a, Compare);fast_sort(ALL(a), f);}
#endif
/*@formatter:off*/
#undef set_4
#undef set_6
#if __cplusplus >= 201703L
//sort_tuple
template<class H1, class H2, class... T> void sortt(vector<H1> &head1, vector<H2> &head2, vector<T> &...tails) { auto vec_t = make_vt(head1, head2, tails...); sort(vec_t); tie_vt(head1, head2, tails...) = vec_t;}
template<class H1, class H2, class... T> void rsortt(vector<H1> &head1, vector<H2> &head2, vector<T> &...tails) { auto vec_t = make_vt(head1, head2, tails...); rsort(vec_t); tie_vt(head1, head2, tails...) = vec_t;}template<class F, class... T> void helper_sortt_f(F f, vector<T> &...a) { auto z = make_vt(a...); sort(z, f); tie_vt(a...) = z;}template<class F, class... T> void helper_rsortt_f(F f, vector<T> &...a) { auto z = make_vt(a...); rsort(z, f); tie_vt(a...) = z;}
//sortt(a,b,c,d, f)まで対応->
template<class A, class B, class F, require_t(!is_vector<F>::value)>
void sortt(vector<A> &a, vector<B> &b, F f) { helper_sortt_f(f, a, b); }
template<class A, class B, class F, require_t(!is_vector<F>::value)>
void rsortt(vector<A> &a, vector<B> &b, F f) { helper_rsortt_f(f, a, b); }template<class A, class B, class C, class F, require_t(!is_vector<F>::value)> void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) { helper_sortt_f(f, a, b, c); }template<class A, class B, class C, class F, require_t(!is_vector<F>::value)> void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) { helper_rsortt_f(f, a, b, c); }template<class A, class B, class C, class D, class F, require_t(!is_vector<F>::value)> void sortt(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d, F f) { helper_sortt_f(f, a, b, c, d); }template<class A, class B, class C, class D, class F, require_t(!is_vector<F>::value)> void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d, F f) { helper_rsortt_f(f, a, b, c, d); }// sort_tuple f }
#endif
/*@formatter:off*/
//任意引数は取らない
template<class T> vi sorti(const vector<T> &a) { auto b = a; vi ind = iota(0, sz(b)); sortt(b, ind); return ind;}
template<class T> vi rsorti(const vector<T> &a) {auto b = a; vi ind = iota(0, sz(b)); rsortt(b, ind); return ind;}
#if __cplusplus >= 201703L
template<class T, class F> vi sorti(const vector<T> &a, F f) { vi ind = iota(0, sz(a)); if constexpr(is_same_v<F, tuple_comparator>) { auto f2 = get_function2(a, f); auto g = [&](int i, int j) { return f2(a[i], a[j]); }; fast_sort(ALL(ind), g); } else { auto g = [&](int i) { return f(a[i]); }; sort(ind, g); } return ind;}
template<class T, class F, require_t(is_function_v<F>)> vi rsorti(const vector<T> &a, F f) { vi ind = iota(0, sz(a)); auto g = [&](int i) { return f(a[i]); }; rsort(ind, g); return ind;}
//任意引数にfを渡したい場合は (make_vt(a, b, c), f)
template<class H, class... Ts> vi sortti(vector<H> head, vector<Ts>... tails) { vi ind = iota(0, sz(head)); auto vec = make_vt(head, tails..., ind); sort(vec); auto rets = take_vt(vec); return get<sizeof...(tails) + 1>(rets);}
template<class H, class... Ts> vi rsortti(vector<H> head, vector<Ts>... tails) { vi ind = iota(0, sz(head)); auto vec = make_vt(head, tails..., ind); rsort(vec); auto rets = take_vt(vec); return get<sizeof...(tails) + 1>(rets);}
#endif
/*@formatter:off*/
template<class... T, class U> auto sorted(U head, T... a) {sort(head, a...);return head;}
template<class... T, class U> auto rsorted(U head, T... a) {rsort(head, a...);return head;}
//@5
void sort(string &a) { sort(ALL(a)); }
void rsort(string &a) { sort(RALL(a)); }
void sort(int &a, int &b) { if (a > b)swap(a, b); }
void sort(int &a, int &b, int &c) { sort(a, b); sort(a, c); sort(b, c);}
void rsort(int &a, int &b) { if (a < b)swap(a, b); }
void rsort(int &a, int &b, int &c) { rsort(a, b); rsort(a, c); rsort(b, c);}
template<class T> bool includes(vector<T> &a, vector<T> &b) { vi c = a; vi d = b; sort(c); sort(d); return includes(ALL(c), ALL(d));}
template<class T> bool distinct(const vector<T> &A) { if ((int) (A).size() == 1)return true; if ((int) (A).size() == 2)return A[0] != A[1]; if ((int) (A).size() == 3)return (A[0] != A[1] && A[1] != A[2] && A[0] != A[2]); auto B = A; sort(B); int N = (B.size()); unique(B); return N == (int) (B.size());}
template<class H, class... T> bool distinct(const H &a, const T &...b) { return distinct(vector<H>{a, b...}); }
/*@formatter:off*/
template<class T, class U> void inc(pair<T, U> &a, U v = 1) { a.first += v, a.second += v; }
template<class T, class U> void inc(T &a, U v = 1) { a += v; }
template<class T, class U = int> 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 = int> 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, class U, class W> void dec(vector<T> &a, vector<U> &b, W v = 1) {for (auto &u :a)dec(u, v);for (auto &u :b)dec(u, v);}
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 san(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 san(0, i, sz(a)) && san(0, j, sz(a)); }
#define inside ins
ll u0(ll a) { return a < 0 ? 0 : a; }
template<class T> vector<T> u0(vector<T> &a) { vector<T> ret = a; fora(v, ret) { v = u(v); } return ret;}
//todo 名前
bool d_(int a, int b) {if (b == 0)return false;return (a % b) == 0;}
//エラー
void ole() {
#ifdef _DEBUG
cerr << "ole" << endl;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(string s = "") {cerr << s << endl;assert(0 == 1);exit(0);}
void tle() { while (inf)cout << inf << endl; }
//@汎用便利関数 入力
ll in() {ll ret;cin >> ret;return ret;}
template<class T> T in() { T 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...);}
//value_typeを持つ場合呼べる
//len回要素を追加する
template<class Iterable, class T = typename Iterable::value_type> Iterable tin(int len) { Iterable ret; T tem; while (len--) { cin >> tem; ret += tem; } return ret;}
template<class T> T tin() { T ret; cin >> ret; return ret;}
template<class T> T tind(int len = 0) { auto ret = tin<T>(len); dec(ret, 1); return ret;}
#define din_t2(type, a) type a;cin>>a
#define din_t3(type, a, b) type a,b;cin>>a>> b
#define din_t4(type, a, b, c) type a,b,c;cin>>a>>b>>c
#define din_t5(type, a, b, c, d) type a,b,c,d;cin>>a>>b>>c>>d
#define din_t6(type, a, b, c, d, e) type a,b,c,d,e;cin>>a>>b>>c>>d>>e
#define din_t7(type, a, b, c, d, e, f) type a,b,c,d,e,f;cin>>a>>b>>c>>d>>e>>f
#define din_t(...) over7(__VA_ARGS__,din_t7,din_t6,din_t5,din_t4,din_t3 ,din_t2)(__VA_ARGS__)
#define din(...) din_t(int,__VA_ARGS__)
#define d_in
#define dsig(...) din_t(signed,__VA_ARGS__)
#define dst(...) din_t(string,__VA_ARGS__)
#define dstr dst
#define d_str dst
#define dcha(...) din_t(char,__VA_ARGS__)
#define dchar dcha
#define ddou(...) din_t(double,__VA_ARGS__)
#define din1d(a) din_t2(int, a);a--
#define din2d(a, b) din_t3(int, a,b);a--,b--
#define din3d(a, b, c) din_t4(int, a,b,c);a--,b--,c--
#define din4d(a, b, c, d) din_t5(int, a,b,c,d);a--,b--,c--,d--
#define dind(...) over4(__VA_ARGS__,din4d,din3d,din2d ,din1d)(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
template<class T> void err2(T &&head) { cerr << head; }
template<class T, class... U> void err2(T &&head, U &&... tail) { cerr << head << " "; err2(tail...);}
template<class T, class... U> void err(T &&head, U &&... tail) { cerr << head << " "; err2(tail...); cerr << "" << endl;}
template<class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
//debで出力する最大長
constexpr int DEB_LEN = 20;
constexpr int DEB_LEN_H = 12;
string deb_tos(const int &v) { if (abs(v) == inf || abs(v) == linf)return "e"; else return to_string(v); }
template<class T> string deb_tos(const T &a) {stringstream ss;ss << a;return ss.str();}
string deb_tos(const P& p){ stringstream ss; ss<<"{"; ss<<p.fi; ss<<", "; ss<<p.se; ss<<"}"; return ss.str();}
#ifdef use_epsdou
string deb_tos(const epsdou &a) {return deb_tos(a.v);}
#endif
template<class T> string deb_tos(const optional<T> &a) { if (a.has_value()) { return deb_tos(a.value()); } else return "e"; }
template<class T> string deb_tos(const vector<T> &a, ll W = inf) { stringstream ss; if (W == inf)W = min(sz(a), DEB_LEN); if (sz(a) == 0)return ss.str(); rep(i, W) { ss << deb_tos(a[i]); if (typeid(a[i]) == typeid(P)) { ss << endl; } else { ss << " "; } } return ss.str();}
template<class T> string deb_tos(const vector<vector<T> > &a, vi H, vi W, int key = -1) { stringstream ss; ss << endl; vi lens(sz(W)); fora(h, H) { rep(wi, sz(W)) { if (sz(a[h]) <= W[wi])break; lens[wi] = max(lens[wi], sz(deb_tos(a[h][W[wi]])) + 1); lens[wi] = max(lens[wi], sz(deb_tos(W[wi])) + 1); } } if (key == -1)ss << " *|"; else ss << " " << key << "|"; int wi = 0; fora(w, W) { ss << std::right << std::setw(lens[wi]) << w; wi++; } ss << "" << endl; rep(i, sz(W))rep(lens[i])ss << "_"; rep(i, 3)ss << "_"; ss << "" << endl; fora(h, H) { ss << std::right << std::setw(2) << h << "|"; int wi = 0; fora(w, W) { if (sz(a[h]) <= w)break; ss << std::right << std::setw(lens[wi]) << deb_tos(a[h][w]); wi++; } ss << "" << endl; } return ss.str();}
template<class T> string deb_tos(const vector<vector<T> > &a, ll H = inf, ll W = inf, int key = -1) { H = (H != inf) ? H : min({H, sz(a), DEB_LEN_H}); W = min({W, sz(a[0]), DEB_LEN_H}); vi hs, ws; rep(h, H) { hs.push_back(h); } rep(w, W) { ws.push_back(w); } return deb_tos(a, hs, ws, key);}
template<class T> string deb_tos(const vector<vector<vector<T> > > &a, ll H = inf) { stringstream ss; if (H == inf)H = DEB_LEN_H; H = min(H, sz(a)); rep(i, H) { ss << endl; ss << deb_tos(a[i], inf, inf, i); } return ss.str();}
template<class T> string deb_tos(vector<set<T> > &a, ll H = inf, ll W = inf, int key = -1) { vector<vector<T> > b(sz(a)); rep(i, sz(a)) { fora(v, a[i]) { b[i].push_back(v); }} return deb_tos(b, H, W, key);}
template<class T, size_t A> string deb_tos(T (&a)[A]) { return deb_tos(vector<T>(begin(a), end(a))); }
template<class T, size_t A, size_t B> string deb_tos(T (&a)[A][B]) { return deb_tos(vector<vector<T> >(begin(a), end(a))); }
template<class T, size_t A, size_t B, size_t C> string deb_tos(T (&a)[A][B][C]) { return deb_tos(vector<vector<vector<T> > >(begin(a), end(a))); }
/*@formatter:off*/
template<class T> void out2(T head) { cout << head; res_mes += deb_tos(head);}
template<class T, class... U> void out2(T head, U ... tail) { cout << head << " "; res_mes += deb_tos(head) + " "; out2(tail...);}
template<class T, class... U> void out(T head, U ... tail) { cout << head << " "; res_mes += deb_tos(head) + " "; out2(tail...); cout << "" << endl; res_mes += "\n";}
template<class T> void out(T head) { cout << head << endl; res_mes += deb_tos(head) + "\n";}
void out() { cout << "" << endl; }
#else
#define err(...);
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;}
#endif
template<class H, class ... T>void outl(const vector<H> &h, const vector<T> &... t) {rep(i, sz(h)) out(h[i], t[i]...);}
//テーブルをスペースなしで出力
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; }
/*@formatter:off*/
template<class T> void na(vector<T> &a, ll n) { a.resize(n); rep(i, n)cin >> a[i];}
template<class T> void na(set<T> &a, ll n) { rep(i, n)a.insert(in()); }
#define dna(a, n) vi a; na(a, n);/*nを複数使うと n==in()の時バグる事に注意*/
#define dnad(a, n) vi a; nad(a, n);
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> void nad(set<T> &a, ll n) { rep(i, n)a.insert(in() - 1); }
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];}
template<class T, class U> void na2(set<T> &a, set<U> &b, ll n) { rep(i, n) { a.insert(in()); b.insert(in()); }}
#define dna2(a, b, n) vi a,b; na2(a,b,n);
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];}
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]--;}
#define dna2d(a, b, n) vi a,b; na2d(a,b,n);
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,b,c; na3(a,b,c,n);
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,b,c; na3d(a,b,c,n);
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,b,c,d; na4(a,b,c,d,n);
#define dna4d(a, b, c, d, n) vi a,b,c,d; na4d(a,b,c,d,n);
#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 dnt(S, h, w) vvi(S,h,w);nt(S,h,w);
#define dntc(S, h, w) vvc(S,h,w);nt(S,h,w);
#define dnts(S, h, w) vvs(S,h,w);nt(S,h,w);
//デバッグ
#define sp << " " <<
/*@formatter:off*/
#define deb1(x) debugName(x)<<" = "<<deb_tos(x)
#define deb_2(x, ...) deb1(x) <<", "<< deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) <<", "<< deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) <<", "<< deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) <<", "<< deb_4(__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__)
/*@formatter:off*/
#ifdef _DEBUG
#define deb(...) do{was_deb=true;cerr<< over10(__VA_ARGS__,deb10,deb9,deb8,deb7,deb6,deb5,deb_4,deb_3,deb_2,deb1)(__VA_ARGS__) <<endl;}while(0)
void print_n_base(int x, int base) {string S;while (x) {S += (char)('0'+x % base);x /= base;}cerr << S << endl;}
template<class T> void print_n_base(vector<T> X, int base) {cerr << endl; for (auto &&x:X) { print_n_base(x, base); } cerr << endl;}
//n進数
#define deb2(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 2);
#define deb3(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 3);
#define deb4(x) was_deb=true;cerr<<debugName(x)<<" = ";print_n_base(x, 4);
#define deb_ex_deb(x, len) debugName(x)<<" = "<<deb_tos(x, len)
#define call_deb_ex_deb(x, len) deb_ex_deb(x, len)
//要素が存在する行だけ出力(vvt)
#define deb_ex(v) do {int N = sz(v);int s = N;int t = 0;rep(i, N) {if (sz(v[i])) {chmi(s, i);chma(t, i);}}auto ex_v = sub(v, s, N);str S = deb_tos(ex_v, sz(ex_v));debugName(v);cerr<<" = "<<endl;cerr << S << endl;} while (0);
#define debi(A) {int len=min(sz(A),20); was_deb=true;cerr<<debugName(A)<<" = "<<endl;rep(i, len)cerr<<std::right << std::setw((int)(sz(tos(A[i]))+(i ? 1 : 0)))<<(i%10);cerr<<endl;rep(i, len)cerr<<std::right << std::setw((int)(sz(tos(A[i]))+(i ? 1 : 0)))<<A[i];cerr<<endl;}
template<class T, class F> string deb_tos_f(vector<T> &A, F f) { vi I; rep(i, sz(A)) { if (f(A[i]))I.push_back(i); } was_deb = true; stringstream ss; fora(ii, i, I)ss << std::right << std::setw((int) (max(sz(tos(A[i])), sz(tos(i))) + (ii ? 1 : 0))) << i; ss << endl; fora(ii, i, I)ss << std::right << std::setw((int) (max(sz(tos(A[i])), sz(tos(i))) + (ii ? 1 : 0))) << A[i]; return ss.str();}
template<class T, class F> string deb_tos_f(vector<vector<T> > &a, F f, int key = -1) {vi hs, ws_; int H = sz(a), W = sz(a[0]); vi exh(H), exw(W); rep(h, H) { rep(w, W) { if (f(a[h][w])) { exh[h] = true; exw[w] = true; } } } rep(h, H) if (exh[h])hs.push_back(h); rep(w, W) if (exw[w])ws_.push_back(w); return deb_tos(a, hs, ws_, key);}
template<class T, class F> string deb_tos_f(vector<vector<vector<T>>> &a, F f) { stringstream ss; int H = sz(a); if (sz(a) == 0)return ss.str(); int cou = 0; rep(i, H) { if (any_of(a[i], v, f(v))) { ss << deb_tos_f(a[i], f, i); cou++; } if(cou>50)break; } ss << "" << endl; return ss.str();}
#define debf_normal(tab, f) do{cerr<<debugName(tab)<<" = "<<endl;cerr<< deb_tos_f(tab, f)<<endl;}while(0);
#define debf2(tab, siki_r) debf_normal(tab, lamr(siki_r))
#define debf3(tab, v, siki) debf_normal(tab, lam(siki))
//S, sikir
//S, v, siki
#define debf(...) over3(__VA_ARGS__,debf3,debf2,debf1)(__VA_ARGS__)
#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#define deb_ex(...) ;
#define debf(...) ;
#define debi(...) ;
#endif
#define debugline(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n'
/*@formatter:off*/
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
using bint =__int128;
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 to_bint(string &s) {__int128 ret = 0; for (ll i = 0; i < (ll) s.length(); ++i) if ('0' <= s[i] && s[i] <= '9') ret = 10 * ret + s[i] - '0'; return ret;}
void operator>>(istream &iss, bint &v) {string S; iss >> S; v = 0; rep(i, sz(S)) { v *= 10; v += S[i] - '0'; }}
//便利関数
/*@formatter:off*/
//テスト用
#define rand xor128_
unsigned long xor128_(void) {static unsigned long x = 123456789, y = 362436069, z = 521288629, w = 88675123; unsigned long t; t = (x ^ (x << 11)); x = y; y = z; z = w; return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));}
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); }}}
ll rand(ll max) { return rand(0, max); }
template<class T> T rand(vector<T> &A) { return A[rand(sz(A) - 1)]; }
//重複することがある
template<class T> vector<T> ranv(vector<T> &A, int N) {vector<T> ret(N); rep(i, N) { ret[i] = rand(A); } return ret;}
template<class T> vector<T> ranv_unique(vector<T> &A, int N) {vector<T> ret(N); umapi was; rep(j, N) { int i; while (1) { i = rand(sz(A) - 1); if (was.find(i) == was.end())break; } ret[j] = A[i]; was[i] = 1; } return ret;}
vi ranv(ll n, ll min, ll max) {vi v(n); rep(i, n)v[i] = rand(min, max); return v;}
/*@formatter:off*/
#ifdef _DEBUG
bool timeup(int time) {static bool never = true; if (never)message += "may timeup, because slow"; never = false; auto end_time = system_clock::now(); auto part = duration_cast<milliseconds>(end_time - start_time); auto lim = milliseconds(time); return part >= lim;}
#else
bool timeup(int time) {
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#endif
void set_time() { past_time = system_clock::now(); }
//MS型(millisecqnds)で返る
//set_timeをしてからの時間
auto calc_time_milli() {auto now = system_clock::now(); auto part = duration_cast<milliseconds>(now - past_time); return part;}
auto calc_time_micro() {auto now = system_clock::now(); auto part = duration_cast<microseconds>(now - past_time); return part;}
auto calc_time_nano() {auto now = system_clock::now(); auto part = duration_cast<nanoseconds>(now - past_time); return part;}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS=std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {if (b < nanoseconds(1)) { return a / nanoseconds(1); } int v = a / b; return v;}
//set_time();
//rep(i,lim)shori
//lim*=time_nanbai();
//rep(i,lim)shoriと使う
//全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {auto dec = duration_cast<nanoseconds>(past_time - start_time); auto part = calc_time_nano(); auto can_time = nanoseconds(milli * 1000 * 1000); can_time -= part; can_time -= dec; return div(can_time, part);}
/*@formatter:off*/
//#define use_rand
#ifdef use_rand
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;}
//便利 汎用
#endif
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]); }}
template<class Iterable, class T = typename Iterable::value_type> vector<pair<T, int>> run_length(const Iterable &a) {vector<pair<T, int>> 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;}
/*@formatter:off*/
//#define use_mgr //_goldd _goldt
#ifdef use_mgr
//->[i, f(i)]
template<class T, class U, class F> auto mgr(T ok, U ng, const F &f, require_arg(is_integral<T>::value &&is_integral<U>::value)) { auto mid = (ok + ng); if (ok < ng) while (ng - ok > 1) { mid = (ok + ng) >> 1; if (f(mid))ok = mid; else ng = mid; } else while (ok - ng > 1) { mid = (ok + ng) >> 1; if (f(mid))ok = mid; else ng = mid; } return ok;}
//[l, r)の中で,f(i)がtrueとなる範囲を返す okはそこに含まれる
template<class F> P mgr_range(int l, int r, F f, int ok) {if (f(ok) == 0) { out("f(ok) must true"); re(); } return mp(mgr(ok, l - 1, f), mgr(ok, r, f) + 1);}
template<class F> auto mgrd(dou ok, dou ng, F f, int kai = 100) {if (ok < ng) rep(i, kai) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid; else ng = mid; } else rep(i, kai) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid; else ng = mid; } return ok;}
template<class F> dou mgrd_time(dou ok, dou ng, F f, int time = 1980) {bool han = true; if (ok < ng) while (1) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid, han = true; else ng = mid, han = false; deb(mid, han); if (timeup(time)) { break; } } else while (1) { dou mid = (ok + ng) / 2; if (f(mid))ok = mid, han = true; else ng = mid, han = false; deb(mid, han); if (timeup(time)) { break; } } return ok;}
//todo 減らす
template<class F> auto 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 make_tuple(resIndex, calc(resIndex));}
template<class F> auto 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 make_tuple(resIndex, calc(resIndex));}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template<class F> auto 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 make_tuple(left, calc(left));}
template<class F> auto 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 make_tuple(left, calc(left));}
//l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template<class F> auto 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 make_tuple(mini, calc(mini));}
template<class F> auto 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 make_tuple(maxi, calc(maxi));}
template<class F> auto 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 make_tuple(mini, calc(mini));}
template<class F> auto 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 make_tuple(maxi, calc(maxi));}
#endif
//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; }
//エラー-1
template<typename W, typename T> ll find(vector<W> &a, int l, const T key) {rep(i, l, sz(a))if (a[i] == key)return i;return -1;}
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);}
//getid(find())を返す 1次元にする
template<typename W, typename T> int findi(vector<vector<W >> &a, const T key) {rep(i, sz(a))rep(j, sz(a[0]))if (a[i][j] == key)return i * sz(a[0]) + j;return -1;}
template<typename W, typename U> tuple<int, int, int> 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 tuple<int, int, int>(i, j, k); return tuple<int, int, int>(-1, -1, -1);}
//無ければ-1
int find(string &s, const string key) { int klen = sz(key); rep(i, sz(s) - klen + 1) { if (s[i] != key[0])continue; if (s.substr(i, klen) == key) { return i; } }return -1;}
int find(string &s, int l, const string key) { int klen = sz(key); rep(i, l, sz(s) - klen + 1) { if (s[i] != key[0])continue; if (s.substr(i, klen) == key) { return i; } } return -1;}
int find(string &s, const char key) { rep(i, sz(s)) { if (s[i] == key)return i; } return -1;}
int find(string &s, int l, const char key) { rep(i, l, sz(s)) { if (s[i] == key)return i; } return -1;}
//N箇所について右のkeyの場所を返す
template<typename W, typename T> vi finds(const W &a, const T& key) { int n = sz(a); vi rpos(n, -1); rer(i, n-1){ if(i<n-1){ rpos[i] = rpos[i+1]; } if(a[i]==key)rpos[i] = i; } return rpos;}
template<typename W, typename T> vi rfinds(const W &a, const T& key) { int n = sz(a); vi lpos(n, -1); rep(i, n){ if(i> 0){ lpos[i] = lpos[i-1]; } if(a[i]==key)lpos[i] = i; } return lpos;}
//todoz
#if __cplusplus >= 201703L
template<typename W, typename T, class Iterable = typename W::value_type>
ll count(const W &a, const T &k) { return count_if(a, ==k); }
template<typename W, class Iterable = typename W::value_type> vi count(const W &a) {
vi res;
for_each(a, v, if (sz(res) <= (int) v)res.resize((int) v + 1);
res[v]++;);
return res;
}
#else
ll count(const string& S, const char& c){
int res=0;
fora(s, S){
res += s==c;
}
return res;
}
#endif
ll count(const str &a, const 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;}
/*@formatter:off*/
//'a' = 'A' = 0 として集計 既に-'a'されていても動く
vi count(str &a, int l, int r) { vi cou(26); char c = 'a'; if ('A' <= a[l] && a[l] <= 'Z')c = 'A'; if ('a' <= a[l] && a[l] <= 'z') c = 'a'; else c = 0; rep(i, l, r)++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> auto rev(const vector<T> &a) { auto b = a; reverse(ALL(b)); return b;}
/* ＼反転 */ template<class U>
auto 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]; return b;}
/* ｜反転 */ template<class U>
auto revw(vector<vector<U>> &a) { vector<vector<U> > b(sz(a), vector<U>(sz(a[0]))); int W = sz(a[0]); rep(h, sz(a)) rep(w, sz(a[0])) { b[h][W - 1 - w] = a[h][w]; } return b;}
/* ー反転 */ template<class U>
auto revh(vector<vector<U>> &a) { vector<vector<U> > b(sz(a), vector<U>(sz(a[0]))); int H = sz(a); rep(h, sz(a)) rep(w, sz(a[0])) { b[H - 1 - h][w] = a[h][w]; } return b;}
/* ／反転 */ template<class U>
auto revr(vector<vector<U>> &a) { vector<vector<U> > b(sz(a[0]), vector<U>(sz(a))); int H = sz(a); int W = sz(a[0]); rep(h, sz(a)) rep(w, sz(a[0]))b[w][h] = a[H - 1 - h][W - 1 - w]; return b;}
auto rev(const string &a) { string b = a; reverse(ALL(b)); return b;}
template<class T> auto rev(const T &v, int i) {return v[sz(v) - 1 - i];}
int rev(int N, int i) {return N-1-i;}
constexpr ll p10[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000ll, 100000000000ll, 1000000000000ll, 10000000000000ll, 100000000000000ll, 1000000000000000ll, 10000000000000000ll, 100000000000000000ll, 1000000000000000000ll};
//0は0桁
ll keta(ll v, int if_zero_res) { if(!v)return if_zero_res;if (v < p10[9]) { if (v < p10[4]) { if (v < p10[2]) { if (v < p10[1]) { if (v < p10[0])return 0; else 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 return 15; } else { if (v < p10[17]) { if (v < p10[16]) return 16; else return 17; } else { if (v < p10[18])return 18; else return 19; }}}}}
#if __cplusplus >= 201703L
ll getr(ll a, ll keta) { return (a / pow<ll>(10, keta)) % 10; }
#else
ll getr(ll a, ll keta) { return (a / (int)pow(10, keta)) % 10; }
#endif
//上から何桁目か
ll getl(ll a, ll ket) {int sketa = keta(a, 1);return getr(a, sketa - 1 - ket);}
ll dsum(ll v, ll sin = 10) {ll ret = 0;for (; v; v /= sin)ret += v % sin;return ret;}
ll mask10(ll v) { return p10[v] - 1; }
//変換系
template<class T, class U> auto to_v1(vector<reference_wrapper<U>>& ret, vector<T> &A) { rep(i, sz(A))ret.push_back(A[i]); return ret;}
template<class T, class U> auto to_v1(vector<reference_wrapper<U>>& ret, vector<vector<T> > &A) {rep(i, sz(A))to_v1(ret, A[i]);return ret;}
//参照付きで1次元に起こす
template<class T> auto to_v1(vector<vector<T> > &A) { vector<reference_wrapper<decl2_t<decltype(A)>>> ret; rep(i, sz(A))to_v1(ret, A[i]); return ret;}
//[v] := iとなるようなvectorを返す
//存在しない物は-1
//空でも動く(なぜか)
template<class T> auto keys(const T &a) {vector<decltype((a.begin())->fi)> res;for (auto &&k :a)res.push_back(k.fi);return res;}
template<class T> auto values(const T &a) {vector<decltype((a.begin())->se)> res;for (auto &&k :a)res.push_back(k.se);return res;}
//todo 可変長で
template<class T> constexpr T min(T a, T b, T c) { return a >= b ? b >= c ? c : b : a >= c ? c : a; }
template<class T> constexpr T max(T a, T b, T c) { return a <= b ? b <= c ? c : b : a <= c ? c : a; }
//1次元のコンテナ
template<class T> int mini(const vector<T> &a) { return min_element(ALL(a)) - a.begin(); }
template<class T> int maxi(const vector<T> &a) { return max_element(ALL(a)) - a.begin(); }
template<class T> T sum(const T &A) {return A;}
template<class T> T sum(const vector<T> &A, int l = -1, int r = -1) {T s = 0;set_lr12(l, r, sz(A));rep(i, l, r)s += sum(A[i]);return s;}
//1次元のIterableに使える
template<class T, require_t(!has_value_type<T>::value)>T min(T &a) { return a; }
template<class V, require_t(has_value_type<V>::value)>auto min(V &a, ll s = -1, ll n = -1) { using Ret_t = decl2_t<V>; auto ret = MAX<Ret_t>(); set_lr12(s, n, sz(a)); if (s == n) { return INF<Ret_t>(); } else { rep(i, s, n) { ret = min(ret, min(a[i])); } return ret; }}
template<class T, require_t(!has_value_type<T>::value)> T max(T &a) { return a; }
template<class V, require_t(has_value_type<V>::value)> auto max(V &a, ll s = -1, ll n = -1) { using Ret_t = decl2_t<V>; auto ret = MIN<Ret_t>(); set_lr12(s, n, sz(a)); if (s == n) { return -INF<Ret_t>(); } else { rep(i, s, n) { ret = max(ret, max(a[i])); } return ret; }}
template<class T> T mul(vector<T> &v, ll t = inf) {T ret = v[0];rep(i, 1, min(t, sz(v)))ret *= v[i];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;}
//indexを持つvectorを返す
/*@formatter:off*/
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<W> &xx, const T v, int s, ll t) { rep(i, s, t)xx[i] = v; }
template<typename W, typename T> void fill(vector<vector<W>> &xx, T v, int sh, int th, int sw, int tw) { rep(h, sh, th)rep(w, sw, tw)xx[h][w] = v; }
//#define use_fill //_sum _array _max _min
#ifdef use_fill
template<typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) { rep(i, N){fill(a[i], v);}}
template<class T, class U> void fill(vector<T> &a, const vi &ind, U val) { fora(v, ind) { a[v] = val; }}
template<typename A, size_t N> auto sum(A (&a)[N], int l = -1, int r = -1) {set_lr12(l, r, N);auto res = sum(a[l]);if (l == r) {return res - res;}rep(i, l + 1, r)res += sum(a[i]);return res;}
template<typename A, size_t N> auto max(A (&a)[N], int l = -1, int r = -1) { set_lr12(l, r, N); auto res = max(a[l]); if (l == r) { return -INF<decltype(res)>(); } rep(i, l + 1, r)res = max(res, max(a[i])); return res;}
template<typename A, size_t N> auto min(A (&a)[N], int l = -1, int r = -1) { set_lr12(l, r, N); auto res = min(a[l]); if (l == r) { return INF<decltype(res)>(); } rep(i, l + 1, r)res = min(res, min(a[i])); return res;}
#endif
vi inds_(vi &a) { int n = max(a) + 1; vi ret(n, -1); rep(i, sz(a)) { assert(ret[a[i]] ==-1);ret[a[i]] = i; } return ret;}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
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;}
template<class T> struct ruiC {
vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
/*先頭0*/
ruiC() : rui(1, 0) {}
T operator()(ll l, ll r) { if (l > r) { cerr << "ruic "; deb(l, r); assert(0); } return rui[r] - rui[l]; }
T operator()(int r = inf) { return operator()(0, min(r, sz(rui) - 1)); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
T operator[](ll i) { return rui[i]; }
/*0から順に追加される必要がある*/
void operator+=(T v) { rui.push_back(rui.back() + v); }
void add(int i, T v) {if (sz(rui) - 1 != i)ole();operator+=(v);}
T back() { return rui.back(); }
ll size() { return rui.size(); }
auto begin() { return rui.begin(); }
auto end() { return rui.end(); }
};
template<class T> string deb_tos(const ruiC<T> &a) {return deb_tos(a.rui);}
template<class T> ostream &operator<<(ostream &os, ruiC<T> a) { fora(v, a.rui){os << v << " "; } return os;}
template<class T> vector<T> ruiv(const 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(const vector<T> &a) { vector<T> ret = ruiv(a); return ruiC<T>(ret);}
template<class T> ruiC<T> ruic() { return ruiC<T>(); }
//imoは0-indexed
//ruiは1-indexed
template<class T> vector<T> imo(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)ret[i + 1] += ret[i]; return ret;}
//#define use_rui //_imo _ruic _ruiv
#ifdef use_rui
//kと同じものの数
template<class T, class U> vi imo(const vector<T> &a, U k) { vi equ(sz(a)); rep(i, sz(a)){ equ[i] = a[i]==k; } return imo(equ);}
template<class T> vector<T> imox(const 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(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)chmi(ret[i + 1], ret[i]); return ret;}
template<class T> vector<T> ima(const vector<T> &v) { vector<T> ret = v; rep(i, sz(ret) - 1)chma(ret[i + 1], ret[i]); return ret;}
template<class T> vector<T> rimi(const vector<T> &v) { vector<T> ret = v; rer(i, sz(ret) - 1, 1)chmi(ret[i - 1], ret[i]); return ret;}
template<class T> vector<T> rima(const vector<T> &v) { vector<T> ret = v; rer(i, sz(ret) - 1, 1)chma(ret[i - 1], ret[i]); return ret;}
template<class T> struct ruimax {
template<typename Monoid> struct SegmentTree { /*pairで処理*/ int sz; vector<Monoid> seg; const Monoid M1 = mp(MIN<T>(), -1); Monoid f(Monoid a, Monoid b) { return max(a, b); } void build(vector<T> &a) { int n = sz(a); sz = 1; while (sz < n) sz <<= 1; seg.assign(2 * sz, M1); rep(i, n) { seg[i + sz] = mp(a[i], i); } for (int k = sz - 1; k > 0; k--) { seg[k] = f(seg[k << 1], seg[(k << 1) | 1]); } } Monoid query(int a, int b) { Monoid L = M1, R = M1; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) L = f(L, seg[a++]); if (b & 1) R = f(seg[--b], R); } return f(L, R); } Monoid operator[](const int &k) const { return seg[k + sz]; } };
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
public:
int n;
ruimax(vector<T> &a) : ve(a), n(sz(a)) { int index = -1; T ma = MIN<T>(); rv.resize(n + 1); ri.resize(n + 1); rv[0] = -INF<T>(); ri[0] = -1; rep(i, n) { if (chma(ma, a[i])) { index = i; } rv[i + 1] = ma; ri[i + 1] = index; } }
T operator()(int l, int r) { if (!(l <= r && 0 <= l && r <= n)) { deb(l, r, n); assert(0); } if (l == 0) { return rv[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).first; } }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } }
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template<class T> struct ruimin {
template<typename Monoid> struct SegmentTree { /*pairで処理*/ int sz;vector<Monoid> seg; const Monoid M1 = mp(MAX<T>(), -1); Monoid f(Monoid a, Monoid b) { return min(a, b); } void build(vector<T> &a) { int n = sz(a); sz = 1; while (sz < n) sz <<= 1; seg.assign(2 * sz, M1); rep(i, n) { seg[i + sz] = mp(a[i], i); } for (int k = sz - 1; k > 0; k--) { seg[k] = f(seg[k << 1], seg[(k << 1) | 1]); } } Monoid query(int a, int b) { Monoid L = M1, R = M1; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) L = f(L, seg[a++]); if (b & 1) R = f(seg[--b], R); } return f(L, R); } Monoid operator[](const int &k) const { return seg[k + sz]; } };
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
int n;
public:
ruimin(vector<T> &a) : ve(a), n(sz(a)) { int index = -1; T mi = MAX<T>(); rv.resize(n + 1); ri.resize(n + 1); rv[0] = INF<T>(); ri[0] = -1; rep(i, n) { if (chmi(mi, a[i])) { index = i; } rv[i + 1] = mi; ri[i + 1] = index; } }
T operator()(int l, int r) { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return rv[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).first; } }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) { { assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } } assert(l <= r && 0 <= l && r <= n); if (l == 0) { return ri[r]; } else { if (!build)seg.build(ve), build = true; return seg.query(l, r).second; } }
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};/*@formatter:off*/
vvi() ruib(vi &a) { vvi(res, 61, sz(a) + 1); rep(k, 61) { rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }} return res;}
vector<ruiC<int>> ruibc(vi &a) {vector<ruiC<int>> ret(61); vvi(res, 61, sz(a)); rep(k, 61) { rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; } ret[k] = ruic(res[k]); } return 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);}
template<class T> struct ruiC2 {
int H;
vector<ruiC<T>> rui;
ruiC<T> dummy;//変なのをよばれたときはこれを返す//todo
ruiC2(const vector<vector<T>> &ru) : rui(sz(ru)), H(sz(ru)) { for (int h = 0; h < H; h++) { if (sz(ru[h]) == 0)continue; if (sz(dummy) == 1) dummy = ruic(vector<T>(sz(ru[h]))); rui[h] = ruic(ru[h]); } }
//WについてHを返す
vector<T> operator()(ll l, ll r) { if (l > r) { cerr << "ruic "; deb(l, r); assert(0); } vector<T> res(H); for (int h = 0; h < H; h++)res[h] = rui[h](l, r); return res; }
//HについてWを返す
ruiC<T> &operator[](ll h) {
#ifdef _DEBUG
if (h >= H) {message += "warning ruiC h >= H";}
#endif
if (h >= H || sz(rui[h]) == 1)return dummy;else return rui[h];
}
/*@formatter:off*/
// vector<T> operator()(int r) { return operator()(0, r); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
/*0から順に追加される必要がある*/
// T back() { return rui.back(); }
// ll size() { return rui.size(); }
// auto begin(){return rui.begin();}
// auto end(){return rui.end();}
};
template<class T, class U> ruiC<ll> ruicou(vector<T> &a, U b) { vi cou(sz(a)); rep(i, sz(a)) { cou[i] = a[i] == b; } return ruic(cou);}
//メモリは形式によらず(26*N)
// rui(l,r)でvector(26文字について, l~rのcの個数)
// rui[h] ruic()を返す
// 添え字は'a', 'A'のまま扱う (予め-='a','A'されているものが渡されたらそれに従う)
template<typename Iterable, class is_Iterable = typename Iterable::value_type>
ruiC2<ll> ruicou(const Iterable &a) { int H = max(a) + 1; vvi(cou, H); rep(i, sz(a)) { if (sz(cou[a[i]]) == 0)cou[a[i]].resize(sz(a)); cou[a[i]][i] = 1; } return ruiC2<ll>(cou); }
/*@formatter:off*/
//h query
template<class T> vector<T> imoh(vector<vector<T>> &v, int w) { vector<T> ret(sz(v)); rep(h, sz(ret)) { ret[h] = v[h][w]; } rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; } return ret;}
template<class T> vector<T> ruih(vector<vector<T>> &v, int w) { vector<T> ret(sz(v) + 1); rep(h, sz(v)) { ret[h + 1] = v[h][w]; } rep(i, sz(v)) { ret[i + 1] += ret[i]; } return ret;}
template<class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) { vector<T> ret = ruih(a, w); return ruiC<T>(ret);}
//xor
template<class T> struct ruixC {
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);}
//差分を返す(累積を取ると元に戻る)
//101なら
//1111を返す
//元の配列で[l, r)へのxorは
//[l]と[r]へのxorになる https://atcoder.jp/contests/abc155/tasks/abc155_f
vi ruix_diff(vi &A) { int N = sz(A); assert(N); vi res(N + 1); res[0] = A[0]; rep(i, 1, N) { res[i] = A[i - 1] ^ A[i]; } res[N] = A[N - 1]; return res;}
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> struct rruiC {
vector<T> rui;
int n;
rruiC(vector<T> &a) : n(sz(a)) { rui.resize(n + 1); rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; } }
/*[r l)*/
T operator()(int r, int l) { r++; l++; assert(l <= r && l >= 0 && r <= n); return rui[l] - rui[r]; }
T operator()(int l) { return operator()(n - 1, l); }
T operator[](int i) { return operator()(i); }
};
template<class T> ostream &operator<<(ostream &os, rruiC<T> a) { fora(v, a.rui){os << v << " "; } return os;}
template<class T> string deb_tos(rruiC<T> &a) {return deb_tos(a.rui);}
#define rrui rruic
template<class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }
//掛け算
template<class T> struct ruimulC {
vector<T> rv;
int n;
ruimulC(vector<T> &a) : rv(a), n(sz(a)) { rv.resize(n + 1); rv[0] = 1; rep(i, n) { rv[i + 1] = a[i] * rv[i]; } }
ruimulC() : n(0) { rv.resize(n + 1); rv[0] = 1; }
void operator+=(T v) { rv.push_back(rv.back() * v); n++; }
T operator()(int l, int r) { assert(l <= r && 0 <= l && r <= n); return rv[r] / rv[l]; }
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template<class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template<class T> ruimulC<T> ruimul() { vector<T> a; return ruimulC<T>(a);}
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, class W> T lowerBound(ruiC <T> &a, U v, W banpei) { return lowerBound(a.rui, v, banpei); }
template<class T, class U, class W> T upperBound(ruiC <T> &a, U v, W banpei) { return upperBound(a.rui, v, banpei); }
template<class T, class U, class W> T rlowerBound(ruiC <T> &a, U v, W banpei) { return rlowerBound(a.rui, v, banpei); }
template<class T, class U, class W> T rupperBound(ruiC <T> &a, U v, W banpei) { return rupperBound(a.rui, v, banpei); }
#endif
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62);//オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
//bget(n)次元
// NならN-1まで
vector<vi> bget2(vi &a, int keta_size) { vvi(res, keta_size, sz(a)); rep(k, keta_size) { rep(i, sz(a)) { res[k][i] = bget(a[i], k); }} return res;}
vi bget1(vi &a, int keta) { vi res(sz(a)); rep(i, sz(a)) { res[i] = bget(a[i], keta); } return res;}
#if __cplusplus >= 201703L
ll bget(ll m, ll keta, ll sinsuu) { m /= pow<ll>(sinsuu, keta); return m % sinsuu;}
#else
ll bget(ll m, ll keta, ll sinsuu) { m /= (ll)pow(sinsuu, keta); return m % sinsuu;}
#endif
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62);//オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
#if __cplusplus >= 201703L
ll bit(ll n, ll sinsuu) { return pow<ll>(sinsuu, n); }
#else
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
#endif
ll mask(ll n) { return (1ll << n) - 1; }
//aをbitに置きなおす
//{0, 2} -> 101
ll bit(const vi &a) { int m = 0; for (auto &&v:a) m |= bit(v); return m;}
//{1, 1, 0} -> 011
//bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bit_bool(vi &a) { int m = 0; rep(i, sz(a)) if (a[i])m |= bit(i); return m;}
#define bcou __builtin_popcountll
//最下位ビット
ll lbit(ll n) { assert(n);return n & -n; }
ll lbiti(ll n) { assert(n);return log2(n & -n); }
//最上位ビット
ll hbit(ll n) { assert(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) { assert(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;}
/*over*/#define forbit1_2(i, mas) for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, i = !mas ? 0 :log2(forbitj); forbitm; forbitm = forbitm ^ forbitj, forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
/*over*/#define forbit1_3(i, N, mas) for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, i = !mas ? 0 :log2(forbitj); forbitm && i < N; forbitm = forbitm ^ forbitj, forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
//masの立ってるindexを見る
// i, [N], mas
#define forbit1(...) over3(__VA_ARGS__, forbit1_3, forbit1_2)(__VA_ARGS__)
//masが立っていないindexを見る
// i, N, mas
#define forbit0(i, N, mas) forbit1(i, (mask(N) & (~(mas))))
//forsubをスニペットして使う
//Mの部分集合(0,M含む)を見る 3^sz(S)個ある
#define forsub_all(m, M) for (int m = M; m != -1; m = m == 0 ? -1 : (m - 1) & M)
//BASE進数
template<size_t BASE> class base_num {
int v;
public:
base_num(int v = 0) : v(v) {};
int operator[](int i) { return bget(v, i, BASE); }
void operator++() { v++; }
void operator++(signed) { v++; }
operator int() { return v; }
};
#define base3(mas, lim, BASE) for (base_num<BASE> mas; mas < lim; mas++)
#define base2(mas, lim) base3(mas, lim, 2)
#define base(...) over3(__VA_ARGS__,base3,base2,base1)(__VA_ARGS__)
//aにある物をtrueとする
vb bool_(vi a, int n) { vb ret(max(max(a) + 1, n)); rep(i, sz(a))ret[a[i]] = true; return ret;}
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; } res = 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 use_compress
//[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;}
#ifdef use_compress
//ind[i] := i番目に小さい数
//map[v] := vは何番目に小さいか
vi compress(vi &a, umapi &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(); }}
#endif
//要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(ALL(a),v))
#define lowerIndex(a, v) (lower_bound(ALL(a),v)-a.begin())
#define upperIndex(a, v) (upper_bound(ALL(a),v)-a.begin())
#define rlowerIndex(a, v) (upper_bound(ALL(a),v)-a.begin()-1)
#define rupperIndex(a, v) (lower_bound(ALL(a),v)-a.begin()-1)
template<class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) { auto it = lower_bound(a.begin(), a.end(), v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) { auto it = upper_bound(a.begin(), a.end(), v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(vector<T> &a, U v, W banpei) { auto it = upper_bound(a.begin(), a.end(), v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(vector<T> &a, U v, W banpei) { auto it = lower_bound(a.begin(), a.end(), v); if (it == a.begin())return banpei; else { return *(--it); }}
//todo 消せないか
template<class T, class U, class W> T lowerBound(set<T> &a, U v, W banpei) { auto it = a.lower_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(set<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(set<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(set<T> &a, U v, W banpei) {auto it = a.lower_bound(v);if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T lowerBound(mset<T> &a, U v, W banpei) { auto it = a.lower_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T upperBound(mset<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.end())return banpei; else return *it;}
template<class T, class U, class W> T rlowerBound(mset<T> &a, U v, W banpei) { auto it = a.upper_bound(v); if (it == a.begin())return banpei; else { return *(--it); }}
template<class T, class U, class W> T rupperBound(mset<T> &a, U v, W banpei) {auto it = a.lower_bound(v);if (it == a.begin())return banpei; else { return *(--it); }}
#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) {out(s...); exit(0); }
//便利 数学 math
//sub ⊂ top
bool subset(int sub, int top) {return (sub & top) == sub;}
//-180 ~ 180 degree
double atand(double h, double w) {return atan2(h, w) / PI * 180;}
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {if (m < 0) m *= -1;return (a % m + m) % m;}
//ll pow(ll a) { return a * a; };
template<class T> T fact(int v) { static vector<T> fact(2, 1); if (sz(fact) <= v) { rep(i, sz(fact), v + 1) { fact.emplace_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];}
//二項係数の偶奇を返す
int com_mod2(int n,int r){return n == ( r | (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];}
#define gcd my_gcd
template<class T, class U, class V = typename max_type<T, U>::type>
V gcd(T a_, U b_) { V a = a_; V b = b_; while (b) a %= b, swap(a, b); return abs(a);}
template<class T>T gcd(const vector<T>& b) { T res = b[0]; rep(i, 1, sz(b))res = gcd(b[i], res); return res;}
#define lcm my_lcm
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; }}
#define hypot my_hypot
double hypot(double dx, double dy){return std::sqrt(dx*dx+ dy*dy);}
ll sig0(int t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
bint sig0(bint t) {return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
//ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {if (s > t)swap(s, t);return sig0(t - s) + s * (t - s + 1);}
#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) { assert(((v - st) % ad) == 0); return (v - st) / ad;}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad;}
// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) { if (st >= v) return st; return (v - st + ad - 1) / ad * ad + st;}
//第何項か
ll lower_tosa_i(ll st, ll ad, ll v) { if (st >= v) return 0; return (v - st + ad - 1) / ad;}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }
//b * res <= aを満たす [l, r)を返す div
P drange_ika(int a, int b) { P null_p = mp(linf, linf); if (b == 0) { if (a >= 0) { return mp(-linf, linf + 1)/*全て*/; } else { return null_p/*無い*/; } } else { if (a >= 0) { if (b > 0) { return mp(-linf, a / b + 1); } else { return mp(-(a / -b), linf + 1); } } else { if (b > 0) { return mp(-linf, -ceil(-a, b) + 1); } else { return mp(ceil(-a, -b), linf + 1); } } }}
//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); }
/*@formatter:off*/
//機能拡張
#define dtie(a, b) int a, b; tie(a, b)
template<class T, class U> string to_string(T a, U b) { string res = ""; res += a; res += b; return res;}
template<class T, class U, class V> string to_string(T a, U b, V c) { string res = ""; res += a; res += b; res += c; return res;}
template<class T, class U, class V, class W> string to_string(T a, U b, V c, W d) { string res = ""; res += a; res += b; res += c; res += d; return res;}
template<class T, class U, class V, class W, class X> string to_string(T a, U b, V c, W d, X e) { string res = ""; res += a; res += b; res += c; res += d; res += e; return res;}
//todo stringもセットで
//find_ifはsubrを使う
string sub(string &A, int l, int r) { assert(0 <= l && l <= r && r <= sz(A)); return A.substr(l, r - l);}
template<class T> vector<T> sub(const vector<T> &A, int l, int r) { assert(0 <= l && l <= r && r <= sz(A)); vector<T> ret(r - l); std::copy(A.begin() + l, A.begin() + r, ret.begin()); return ret;}
template<class T> vector<T> sub(const vector<T> &A, int r) { return sub(A, 0, r); }
#if __cplusplus >= 201703L
template<class I, require_t(has_value_type<I>::value)> I subn(const I &A, int l, int len) { return sub(A, l, l + len); }
#endif
template<class T, class F>
//sub2で呼ぶ
vector<T> sub(const vector<vector<T> >& A, int h, int w, int ah,int aw, F f){ vector<T> res; while(0<= h && h < sz(A) && 0 <= w && w < sz(A[h]) && f(A[h][w])){ res.emplace_back(A[h][w]); h += ah; w += aw; } return res;}
template<class T> vector<T>sub(const vector<vector<T> >& A, int h, int w, int ah,int aw){return sub(A, h, w, ah, aw, [&](T v){return true;});}
//range_nowを返す(find_ifでしか使われない)
#if __cplusplus >= 201703L
template<class T> auto subr(const vector<T> &A, int l) {return range_now(vector<T>(A.begin()+l, A.end()), l);}
#endif
#define sub25(A, h, w, ah, aw) sub(A, h, w, ah, aw)
#define sub26(A, h, w, ah, aw, siki_r) sub(A, h, w, ah, aw, [&](auto v){return v siki_r;})
#define sub27(A, h, w, ah, aw, v, siki) sub(A, h, w, ah, aw, [&](auto v){return siki;})
#define sub2(...) over7(__VA_ARGS__,sub27,sub26,sub25)(__VA_ARGS__)
constexpr int bsetlen = 50001;
//constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] < b[i])return true;if (a[i] > b[i])return false;}return false;}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] > b[i])return true;if (a[i] < b[i])return false;}return false;}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] < b[i])return true;if (a[i] > b[i])return false;}return true;}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {rer(i, bsetlen - 1) {if (a[i] > b[i])return true;if (a[i] < b[i])return false;}return true;}
string operator~(string &a) {string res = a;for (auto &&c:res) {if (c == '0')c = '1';else if (c == '1')c = '0';else {cerr << "cant ~" << a << "must bit" << endl;exit(0);}}return res;}
ostream &operator<<(ostream &os, bset& a) { bitset<10> b; vi list; rep(i,bsetlen){ if(a[i])list.push_back(i),b[i]=1; } os<<b<<", "<<list; return os;}
int hbiti(bset&a){rer(i,bsetlen){if(a[i])return i;}return -1;}
#define hk(a, b, c) (a <= b && b < c)
//O(N/64)
bset nap(bset &a, int v) {bset r = a | a << v;return r;}
bset nap(bset &a, bset &v) {bset r = a;rep(i, bsetlen) {if (v[i])r |= a << i;}return r;}
template<class T> int count(set<T> &S, T l, T r) { assert(l < r); auto it = S.lower_bound(l); return it != S.end() && (*it) < r;}
//template<class T> void seth(vector<vector<T>> &S, int w, vector<T> &v) {assert(sz(S) == sz(v));assert(w < sz(S[0]));rep(h, sz(S)) { S[h][w] = v[h]; }}
template<class T> vector<T> geth(vector<vector<T>> &S, int w) { assert(w < sz(S[0])); vector<T> ret(sz(S)); rep(h, sz(S)) { ret[h] = S[h][w]; } return ret;}
//vector<bool>[i]は参照を返さないため、こうしないとvb[i] |= trueがコンパイルエラー
vb::reference operator|=(vb::reference a, bool b){return a = a | b;}
vb::reference operator&=(vb::reference a, bool b){return a = a & b;}
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+(const pair<T, U> &a, const pair<T, U> &b) { return pair<T, U>(a.fi + b.fi, a.se + b.se); }
template<class T, class U> pair<T,U> operator-(const pair<T,U> &a, const pair<T,U> & b) {return pair<T,U>(a.fi-b.fi,a.se-b.se);}
template<class T, class U> pair<T,U> operator-(const pair<T, U>& a){return pair<T, U>(-a.first, -a.second);}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rhs) {
#ifdef _DEBUG
static bool was = false;if (!was)message += "str += 65 is 'A' not \"65\" ";was = true;
#endif
return lhs + (char) rhs;
}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const int lhs, const basic_string<CharT, Traits, Alloc> &rhs) {
#ifdef _DEBUG
static bool was = false;if (!was)message += "str += 65 is 'A' not \"65\" ";was = true;
#endif
return (char)lhs + rhs;
}
template<typename CharT, typename Traits, typename Alloc> void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) { lhs = lhs + rv;}
template<typename CharT, typename Traits, typename Alloc> basic_string<CharT, Traits, Alloc> operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) { const int rv2 = rv; return lhs + rv2;}
template<typename CharT, typename Traits, typename Alloc> void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {const int v = rv; lhs += v; }
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+(U v,const vector<T> &a) { vector<T> ret = a; ret.insert(ret.begin(), v); return ret;}template<class T> vector<T> operator+(const vector<T>& a, const vector<T>& b) { vector<T> ret; ret = a; fora(v, b){ret += v; } return ret;}template<class T> vector<T> &operator+=(vector<T> &a,const vector<T> &b) { rep(i, sz(b)) {/*こうしないとa+=aで両辺が増え続けてバグる*/ a.push_back(b[i]); } return a;}template<class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) { for(auto&& bv : b) { a[bv.first] += bv.second; } return a;}template<class T, class U> vector<T> operator+(const vector<T> &a, const U& v) { vector<T> ret = a; ret += v; return ret;}template<class T, class U> auto operator+=(uset<T> &a, U v) { return a.insert(v); }
template<class T> vector<T> operator%(vector<T>& a, int v){ vi ret(sz(a)); rep(i,sz(a)){ ret[i] = a[i] % v; } return ret;}
template<class T> vector<T> operator%=(vector<T>& a, int v){ rep(i,sz(a)){ a[i] %= v; } return a;}
vi operator&(vi& a, vi& b){ assert(sz(a)==sz(b)); vi ret(sz(a)); rep(i,sz(a)){ ret[i] = min(a[i],b[i]); } return ret;}
template<class T> void operator+=(mset<T> &a, vector<T>& v) { for(auto&& u : v)a.insert(u); }
template<class T> void operator+=(set<T> &a, vector<T>& v) { for(auto&& u : v)a.insert(u); }
template<class T> void operator+=(vector<T> &a, set<T>& v) { for(auto&& u : v)a.emplace_back(u); }
template<class T> void operator+=(vector<T> &a, mset<T>& v) { for(auto&& u : v)a.emplace_back(u); }
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(T &v, unsigned ll i) { v.erase(v.begin() + i); }
template<typename T> void erase(T &v, unsigned ll s, unsigned ll e) { v.erase(v.begin() + s, v.begin() + e); }
template<class T, class... I> auto erased(T& v, I... arg){ auto ret = v; erase(ret, arg...); return ret;}
template<typename T> void pop_front(vector<T> &v) { erase(v, 0); }
template<typename T> void entry(vector<T> &v, unsigned ll s, unsigned ll e) { erase(v, e, sz(v));erase(v,0,s);}
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); }
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;}
ll stoi(string& s){return stol(s);}
#define assert_yn(yn_v, v); assert(yn_v == 0 || yn_v == v);yn_v = v;
//不完全な対策、現状はautohotkeyで対応
int yn_v = 0;
void yn(bool a) { assert_yn(yn_v, 1);if (a)cout << "yes" << endl; else cout << "no" << endl; }
void fyn(bool a) { assert_yn(yn_v, 1);yn(a); exit(0);}
void Yn(bool a) { assert_yn(yn_v, 2);if (a)cout << "Yes" << endl; else cout << "No" << endl; }
void fYn(bool a) { assert_yn(yn_v, 2);Yn(a); exit(0);}
void YN(bool a) { assert_yn(yn_v, 3);if (a)cout << "YES" << endl; else cout << "NO" << endl; }
void fYN(bool a) { assert_yn(yn_v, 3);YN(a); exit(0);}
int ab_v = 0;
void fAb(bool a) { assert_yn(ab_v, 1);if(a)cout<<"Alice"<<endl;else cout<<"Bob";}
void fAB(bool a) { assert_yn(yn_v, 2);if(a)cout<<"ALICE"<<endl;else cout<<"BOB";}
int pos_v = 0;
void Possible(bool a) { assert_yn(pos_v, 1);if (a)cout << "Possible" << endl; else cout << "Impossible" << endl; exit(0);}
void POSSIBLE(bool a) { assert_yn(pos_v, 2);if (a)cout << "POSSIBLE" << endl; else cout << "IMPOSSIBLE" << endl; exit(0);}
void fPossible(bool a) { assert_yn(pos_v, 1)Possible(a);exit(0);}
void fPOSSIBLE(bool a) { assert_yn(pos_v, 2)POSSIBLE(a);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)}; }
//未分類
//0,2,1 1番目と2番目の次元を入れ替える
template<class T> auto irekae(vector<vector<vector<T> > > &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c) resize(res,a,b,c);rep(i,a)rep(j,b)rep(k,c)
vector<vector<vector<T> > > res; if (x == 0 && y == 1 && z == 2) { res = A; } else if (x == 0 && y == 2 && z == 1) { irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) { res[i][j][k] = A[i][k][j]; } } else if (x == 1 && y == 0 && z == 2) { irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) { res[i][j][k] = A[j][i][k]; } } else if (x == 1 && y == 2 && z == 0) { irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) { res[i][j][k] = A[k][i][j]; } } else if (x == 2 && y == 0 && z == 1) { irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) { res[i][j][k] = A[j][k][i]; } } else if (x == 2 && y == 1 && z == 0) { irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) { res[i][j][k] = A[k][j][i]; } } return res;
#undef irekae_resize_loop
}
template<class T> auto irekae(vector<vector<T>>&A,int i=1,int j=0){ vvt(res,sz(A[0]),sz(A)); rep(i,sz(A)){ rep(j,sz(A[0])){ res[j][i]=A[i][j]; } } return res;}
//tou分割する
template<typename Iterable> vector<Iterable> table(const Iterable &a, int tou = 2) {int N = sz(a); vector<Iterable> res(tou); int hab = N / tou; vi lens(tou, hab); rep(i, N % tou) { lens[tou - 1 - i]++; } int l = 0; rep(i, tou) { int len = lens[i]; int r = l + len; res[i].resize(len); std::copy(a.begin() + l, a.begin() + r, res[i].begin()); l = r; } return res;}
//長さn毎に分割する
template<typename Iterable> vector<Iterable> table_n(const Iterable &a, int len) { int N = sz(a); vector<Iterable> res(ceil(N, len)); vi lens(N / len, len); if (N % len)lens.push_back(N % len); int l = 0; rep(i, sz(lens)) { int len = lens[i]; int r = l + len; res[i].resize(len); std::copy(a.begin() + l, a.begin() + r, res[i].begin()); l = r; } return res;}
//縦を返す
vi& geth(vvi()& a, int w){ static vi ret; ret.resize(sz(a)); rep(i,sz(a)){ ret[i] = a[i][w]; } return ret;}
//@起動時
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;
//#define pre prev
//#define nex next
//gra mll pr
//上下左右
const string udlr = "udlr";
string UDLR = "UDLR";//x4と連動 UDLR.find('U') := x4[0]
vc atoz = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x','y', 'z'};
vc AtoZ = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X','Y', 'Z'};
//右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {while (++i < 4) { if (inside(h + h4[i], w + w4[i], H, W))return i; }return i;}
#define mei(nh, nw, h, w) for (int i = mei_inc(h, w, H, W, -1), nh = i<4? h + h4[i] : 0, nw = i<4? w + w4[i] : 0; i < 4; i=mei_inc(h,w,H,W,i), nh = h+h4[i], nw = w+w4[i])
int mei_inc8(int h, int w, int H, int W, int i) { while (++i < 8) { if (inside(h + h8[i], w + w8[i], H, W))return i; } return i;}
#define mei8(nh, nw, h, w) for (int i = mei_inc8(h, w, H, W, -1), nh = i<8? h + h8[i] : 0, nw = i<8? w + w8[i] : 0; i < 8; i=mei_inc8(h,w,H,W,i), nh = h+h8[i], nw = w+w8[i])
int mei_incv(int h, int w, int H, int W, int i, vp &p) { while (++i < sz(p)) { if (inside(h + p[i].fi, w + p[i].se, H, W))return i; } return i;}
#define meiv(nh, nw, h, w, p) for (int i = mei_incv(h, w, H, W, -1, p), nh = i<sz(p)? h + p[i].fi : 0, nw = i<sz(p)? w + p[i].se : 0; i < sz(p); i=mei_incv(h,w,H,W,i,p), nh = h+p[i].fi, nw = w+p[i].se)
//H*Wのグリッドを斜めに分割する
//右上
vector<vp> naname_list_ne(int H, int W) { vector<vp> res(H + W - 1); rep(sh, H) { int sw = 0; res[sh] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh--; nw++; if (0 <= nh && nw < W) { res[sh] += mp(nh, nw); }else{ break; } } } rep(sw, 1, W) { int sh = H - 1; res[H + sw - 1] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh--; nw++; if (0 <= nh && nw < W) { res[H + sw-1] += mp(nh, nw); }else{ break; } } } return res;}
//右下
vector<vp> naname_list_se(int H, int W) { vector<vp> res(H + W - 1); rep(sh, H) { int sw = 0; res[sh] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh++; nw++; if (0 <= nh && nh< H && nw < W) { res[sh] += mp(nh, nw); } else { break; } } } rep(sw, 1, W) { int sh = 0; res[H + sw - 1] += mp(sh, sw); int nh = sh; int nw = sw; while (1) { nh++; nw++; if (0 <= nh && nh < H && nw < W) { res[H + sw - 1] += mp(nh, nw); } else { break; } } } return res;}
//グラフ内で #undef getid
//#define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1) (__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
#define set_shuffle() std::random_device seed_gen;std::mt19937 engine(seed_gen())
#define shuffle(a) std::shuffle((a).begin(), (a).end(), engine);
//1980 開始からtime ms経っていたらtrue
vb bit_bool(int v, int len) { assert(bit(len) > v); vb ret(len); rep(i, len) { ret[i] = bget(v, i); } return ret;}
vi tov(vb& a){ vi ret; rep(i,sz(a)){ if(a[i])ret.push_back(i); } return ret;}
bool kaibun(const str& S){return S==rev(S);}
template<class T> vector<T> repeat(const vector<T> &A, int kaisu) { vector<T> ret; while (kaisu--) { ret += A; } return ret;}
#define rge range
#define upd update
//S[{s, t, d}]
#define strs slice_str
struct slice_str {
string S;
slice_str() {}
slice_str(const string &S) : S(S) {}
slice_str(int len, char c) : S(len, c) {}
auto size(){return S.size();}
char& operator[](int p) { return S[p]; }
string operator[](initializer_list<int> p) { if (sz(p) == 1) { return S.substr(0, *(p.begin())); } else if (sz(p) == 2) { int l = *(p.begin()); int r = *(next(p.begin())); return S.substr(l, r - l); } else { auto it = p.begin(); int s = *(it++); int t = *(it++); int d = *(it); if (d == -1) { int s_ = sz(S) - s - 1; int t_ = sz(S) - t - 1; return rev(S).substr(s_, t_ - s_); } else if (d < 0) { t = max(-1ll, t); string ret; while (s > t) { ret += S[s]; s += d; } return ret; } else { t = min(sz(S), t); string ret; while (s < t) { ret += S[s]; s += d; } return ret; } } }
operator string &() { return S; }
template<class T> void operator+=(const T &a) { S += a; }
bool operator==(const slice_str& rhs){return S==rhs.S;}
auto pop_back(){return S.pop_back();}
};
ostream &operator<<(ostream &os, const slice_str &a) { os << a.S; return os;}
istream &operator>>(istream &iss, slice_str &a) {iss >> a.S;return iss;}
template<class T> bool can(const T &v, int i) { return 0 <= i && i < sz(v); }
#if __cplusplus >= 201703L
//template<class T> auto sum(int a, T v...) {return (v + ... + 0);}
#endif
#define VEC vector
//string.substr()は長さを指定するため、間違えやすい
#define substr my_substr
#endif /*UNTITLED15_TEMPLATE_H*/
#endif
//† ←template終了
/*@formatter:on*/
//vectorで取れる要素数
//bool=> 1e9 * 8.32
//int => 1e8 * 2.6
//ll => 1e8 * 1.3
//3次元以上取るとメモリがヤバい
//static配列を使う
vvc (ba);
ll N, M, H, W;
vi A, B, C;
namespace {/*@formatter:off*/
#undef getid
#undef getid_1
#undef getid_2
//#define type_id_graph
#ifdef type_id_graph
//#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c,ty,id; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c,ty=ve[gi].ty, id = ve[gi].id, true); ++gi)
#define forg_f_init(ve) int f = ve[gi].f, t = ve[gi].t, ty = ve[gi].ty, id = ve[gi].id; auto& c = ve[gi].c
#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim; ++gi)
#define fort_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim ; ++gi)
#define fort_f_init(gi, ve) int f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, id = ve[gi].id;if(t == p)continue;
//#define fort_f(gi, ve) for (ll gi = 0, f, t, c, ty, id,wasp = (p != -1 && ve[gi].t == p) ? 1 : 0; (wasp = wasp ? 1 : (p != -1 && ve[gi].t == p) ? 1 : 0,gi + wasp < ve.size()) &&(tie(f, t, c, ty, id) = wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c, ve[gi + 1].ty, ve[gi + 1].id) : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c, ve[gi].ty, ve[gi].id), true); ++gi)
#define fore(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c, ty, id; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, ty = ve[gi].ty, id = ve[gi].id, true); ++gi)
template<class T> struct edge_ { typedef T value_type;int f, t, ty, id; T c; edge_(int f, int t, T c = 1, int ty = -1, int id= -1) : f(f), t(t), c(c), ty(ty), id(id) {} 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<<" "<< e.ty<<" "<<e.id;return os;}
template<typename T> class graph {
public :
typedef T value_type;
vector<vector<edge_<T>>> g;
vector<edge_<T>> edges;
int n;
explicit graph(int n) : n(n) { g.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {this->n = n;g.resize(n);}
int size() { return n; }
vector<edge_<T> > &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int ty, 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;
explicit digraph(int n) : graph<T>(n) {}
explicit digraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
void add(int f, int t, T c = 1, int ty = -1, int eid = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {debugline("digraph add");deb(f, t, c);ole();}
int id = sz(edges);
if(eid != -1)id = eid;
g[f].emplace_back(f, t, c, ty, id);
edges.emplace_back(f, t, c, ty, id);//edgesを使わないなら消せる
}
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 set_edges() override{ 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;
explicit undigraph(int n) : graph<T>(n) {}
explicit undigraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
int next_id = 0;
// f < t
void add(int f, int t, T c = 1, int ty = -1, int eid = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("undigraph add"); deb(f, t, c); ole(); }
int id = eid;
if(id == -1){
id = next_id++;
}
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を使わないなら消せる
edges.emplace_back(t, f, c, ty, id);
}
void add(edge_<T> &e) { int f = e.f, t = e.t,ty = e.ty,id=e.id; T c = e.c; add(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 set_edges () override{ if (sz(edges))return; rep(i, n)fora(e, g[i])edges.push_back(e); }
};
#else //#ifdef type_id_graph
#define forg_f_init(ve) int f = ve[gi].f, t = ve[gi].t; auto& c = ve[gi].c
#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim; ++gi)
// /*temp2*/#define forg_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
//#define fort_f(gi, ve) for (ll gi = 0, f, t, c,wasp = (p != -1 && ve[gi].t == p) ? 1 : 0; (wasp = wasp ? 1 : (p != -1 && ve[gi].t == p) ? 1 : 0,gi + wasp < ve.size()) &&(tie(f, t, c) = wasp ? make_tuple(ve[gi + 1].f, ve[gi + 1].t, ve[gi + 1].c) : make_tuple(ve[gi].f, ve[gi].t, ve[gi].c), true); ++gi)
#define fort_f(gi, ve) for (ll gi = 0,forg_flim = ve.size(); gi < forg_flim ; ++gi)
#define fort_f_init(gi, ve) int f = ve[gi].f, t = ve[gi].t, c = ve[gi].c;if(t == p)continue;
#define fore(gi, ve) for (ll gi = 0,forg_flim = ve.size(), f, t, c; gi < forg_flim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); ++gi)
template<class T> struct edge_ {typedef T value_type;int f, t; T c; edge_(int f, int t, T c = 1) : f(f), t(t), c(c) {} 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 {
public :
typedef T value_type;
vector<vector<edge_<T>>> g;
vector<edge_<T>> edges;
int n;
explicit graph(int n) : n(n) { g.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {this->n = n;g.resize(n);}
int size() { return n; }
vector<edge_<T> > &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c) = 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;
explicit digraph(int n) : graph<T>(n) {}
explicit digraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {debugline("digraph add");deb(f, t, c);ole();}
g[f].emplace_back(f, t, c);
edges.emplace_back(f, t, c);//edgesを使わないなら消せる
}
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 set_edges() override{ 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;
explicit undigraph(int n) : graph<T>(n) {}
explicit undigraph(int n, const vector<edge_<T>>& E) : graph<T>(n) { fora(e,E){ add(e.f,e.t,e.c); } }
// f < t
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("undigraph add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
edges.emplace_back(f, t, c);//edgesを使わないなら消せる
edges.emplace_back(t, f, c);
}
void add(edge_<T> &e) { int f = e.f, t = e.t; T c = e.c; add(f, t, c); }
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 set_edges () override{ if (sz(edges))return; rep(i, n)fora(e, g[i])edges.push_back(e); }
};
#endif
#define dijkstra_path dis_path
template<class T,class I> vi dis_path(digraph<T> &g, vector<T> &dis, int s, int t, I init_value) { assert(dis[t] != init_value); auto rg = rev(g); int now = t; vi path; path.push_back(now); T cost = 0; while (now != s) { rep(gi, sz(rg[now])) { int m = rg[now][gi].t; if (dis[m] == init_value)continue; if (dis[m] + rg[now][gi].c + cost == dis[t]) { cost += rg[now][gi].c; now = m; break; } } path.push_back(now); } rev(path); return path;}
template<class T,class I> vi dis_path(undigraph<T> &g, vector<T> &dis, int s, int t, I init_value) { assert(dis[t] != init_value); int now = t; vi path; path.push_back(now); T cost = 0; while (now != s) { rep(gi, sz(g[now])) { int m = g[now][gi].t; if (dis[m] == init_value)continue; if (dis[m] + g[now][gi].c + cost == dis[t]) { cost += g[now][gi].c; now = m; break; } } path.push_back(now); } rev(path); return path;}
template<class T,class I> vi dis_path(digraph<T> &g, vector<vector<T>> &dis, int s, int t, I init_value) { return dis_path(g, dis[s], s, t, init_value); }
template<class T,class I> vi dis_path(undigraph<T> &g, vector<vector<T>> &dis, int s, int t, I init_value) { return dis_path(g, dis[s], s, t, init_value); }
vi to_vi(const int& i){return vi{i};}
vi to_vi(const vi& v){return v;}
#define dijk dijkstra
//O(N^2)
template<class T, class U, class I> vector<T> dijkstra_mitu(graph<T> &g, const U &S_, I init_value) { vi S = to_vi(S_); int n = g.n; T initValue = MAX<T>(); vector<T> dis(n, initValue); fora(s, S) { if (!(0 <= s && s < g.n)) { debugline("dijkstra_mitu"); deb(s, g.n); ole(); } dis[s] = 0; } vb used(n); while (true) { int v = -1; rep(u, n) { if (!used[u] && (v == -1 || dis[u] < dis[v]))v = u; } if (v == -1)break; if (dis[v] == initValue)break; used[v] = true; rep(u, sz(g[v])) { auto e = g[v][u]; dis[e.t] = min(dis[e.t], dis[v] + e.c); } } /*基本、たどり着かないなら-1*/ for (auto &&d :dis) { if (d == initValue) { d = init_value; }} return dis;}
template<class T, class U, class I> vector<T> dijkstra_01(graph<T> &g, const U &S_, I init_value) {int N = g.n; vi S = to_vi(S_); T tinf = INF<T>(); vector<T> dis(N, tinf); deque<int> q; fora(s, S) { dis[s] = 0; q.push_back(s); } vb was(N); while (!q.empty()) { int f = q.front(); q.pop_front(); if (was[f])continue; was[f] = true; fora(e, g[f]) { if (dis[e.t] > dis[f] + e.c) { if (e.c) { dis[e.t] = dis[f] + 1; q.push_back(e.t); } else { dis[e.t] = dis[f]; q.push_front(e.t); } } } } rep(i, N)if (dis[i] == tinf)dis[i] = init_value; return dis;}
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 emplace(u64 key, const T &value) { ++size_; v[getbit(key ^ last)].emplace_back(key, value); } void push(u64 key, const T &value) { emplace(key, value); } pair<u64, T> top() { 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; } void pop() { ; } int size() { return size_; }};
//01, 密グラフ, normalを自動で判断する
template<class Q, class T, class U,class I> vector<T> private_dijkstra(graph<T> &g, U &S_, I init_value) { vi S = to_vi(S_); fora(s, S) { if (!(0 <= s && s < g.n)) { debugline("dijkstra"); deb(s, g.n); ole(); } } bool cost01 = true; rep(i, g.n) { forg_f(gi, g[i]) {forg_f_init(g[i]); cost01 &= (c == 0 || c == 1); }} if (cost01)return dijkstra_01(g, S_, init_value); else if ((g.n + sz(g.edges)) * log2(g.n) > g.n * g.n) { return dijkstra_mitu(g, S, init_value); } T initValue = MAX<T>(); vector<T> dis(g.n, initValue); Q q; fora(s, S) { dis[s] = 0; q.emplace(0, s); } while (q.size()) { T nowc; int i; tie(nowc, i) = q.top(); 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, class U,class I> vector<T> dijkstra(graph<T> &g, U S_, I init_value) { if (typeid(T) == typeid(int)) { return private_dijkstra<radixheap<int>>(g, S_, init_value); } else { return private_dijkstra<priority_queue<pair<T, int>, vector<pair<T, int >>, greater<pair<T, int >> >>(g, S_, init_value); }}
//dijkstra_cou<mint> : 数える型で書く return vp(dis,cou)
template<class COU,class T=int,class I> auto dijkstra_cou(const graph<T> &g, int s, I init_value) { if (!(0 <= s && s < g.n)) { debugline("dijkstra"); deb(s, g.n); ole(); } err("count by type COU "); err("int or mint"); T initValue = MAX<T>(); vector<T> dis(g.n, initValue); vector<COU> cou(g.n); cou[s] = 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_f(gi, g[i]){ forg_f_init(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_f(gi, g[i]){ forg_f_init(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, class I> vector<vector<T>> warshall(graph<T> &g, I init_value) { int n = g.n; assert(n < 1e4); vector<vector<T> > dis(n, vector<T>(n, INF<T>())); rep(i, n)fora(e, g.g[i]) { if (dis[e.f][e.t] > e.c) { dis[e.f][e.t] = e.c; }} rep(i, n)dis[i][i] = 0; rep(k, n) rep(i, n) rep(j, n) { if (dis[i][j] > dis[i][k] + dis[k][j]) { dis[i][j] = dis[i][k] + dis[k][j]; }} rep(i, n)rep(j, n) if (dis[i][j] == linf)dis[i][j] = init_value; return dis;}
//密グラフの時、warshallに投げる
//01等の判定もここで出来る
template<class T, class I> vector<vector<T>> dijkstra_all(graph<T> &g, I init_value) { int n = g.n; assert(n < 1e4); if (n * n < (n + sz(g.edges)) * 14) { /*O(N^3) vs O(N (N+M)log N)*/ return warshall(g, init_value); } vector<vector<T>> dis(n); rep(i, n) { dis[i] = dijkstra(g, i, 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( 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( 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; }};
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; rmq_dep.push_back(d); disv[x] = dis; in[x] = cnt++; forg_f(gi, g[x]) { forg_f_init(g[x]); if (t == p) { continue; } dfs(t, x, d + 1, dis + c); id_[cnt] = x; rmq_dep.push_back(d); cnt++; } } void precalc() { never = false; cnt = 0; rmq_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(rmq_dep);
#ifdef _DEBUG
if (n >= 100)return; cerr << "---tree---" << endl; rep(i, n) { if (!(i == root || sz(g[i]) > 1))continue; cerr << i << " -> "; vi ts; forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != par_[i])ts.push_back(t); } rep(i, sz(ts) - 1)cerr << ts[i] << ", "; if (sz(ts))cerr << ts.back() << endl; } cerr << endl;
#endif
} int pos; void hld_build() { never_hld = false; if (never)precalc(); g.resize(n); vid.resize(n, -1); head.resize(n); heavy.resize(n, -1); depth.resize(n); inv.resize(n); subl.resize(n); subr.resize(n); dfs(root, -1); t = 0; dfs_hld(root);
#ifdef _DEBUG
if (n >= 100)return; 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; cerr << "!!query!! edge or not edge carefull!!" << endl;
#endif
} int dfs(int curr, int prev) { int sub = 1, max_sub = 0; heavy[curr] = -1;
forg_f(gi, g[curr]) { forg_f_init(g[curr]); int next = t; if (next != prev) { depth[next] = depth[curr] + 1; int sub_next = dfs(next, curr); sub += sub_next; if (max_sub < sub_next) max_sub = sub_next, heavy[curr] = next; } } return sub; } int t = 0;
#ifndef __CLION_IDE__
void dfs_hld(int v = 0) { vid[v] = subl[v] = t; t++; inv[subl[v]] = v; if (0 <= heavy[v]) { head[heavy[v]] = head[v]; dfs_hld(heavy[v]); }
forg_f(gi, g[v]){forg_f_init(g[v]); if (depth[v] < depth[t]) if (t != heavy[v]) { head[t] = t; dfs_hld(t); } subr[v] = t; }}
#endif//__CLION_IDE__
vector<signed> rmq_dep;
vi par_, depth, disv;
vi childs;
vi par_id_;//親への辺のidを持つ
vvi(ids_);//隣接で辺のidを持つ
public:
using undigraph<T>::g; using undigraph<T>::n; using undigraph<T>::edges;
int root;
//(f,t)と(t,f)は同じidを持ち、[0,n-1]でadd順に割り振られる
//部分木の [左端、右端) index
//部分木の辺に加算する場合
//add(subl[i],subr[i],x)
//add(sub[i],sub[i+1],-x)
vector<int> vid, head, heavy, inv, subl, subr;
tree(int n_, int root = 0) : undigraph<T>(n_), root(root) { n = n_; }
tree(int n_, int root, const vector<edge_<T>> &E) : undigraph<T>(n_), root(root) {n = n_;fora(e, E) { add(e.f, e.t, e.c); }}
// f < t
void add(int f, int t, T c = 1) {
#ifdef _DEBUG
if ((n % k5) == 0) {re("tree must resize");}
#endif
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("tree add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
edges.emplace_back(f, t, c);/*edgesを使わないなら消せる*/
edges.emplace_back(t, f, c);
}
void add_di(int f, int t, T c = 1) {
#ifdef _DEBUG
if ((n % k5) == 0) { re("tree must resize"); }
#endif
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("tree add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); edges.emplace_back(f, t, c);/*edgesを使わないなら消せる*/ }
void root_change(int roo) { root = roo; precalc(); }
//葉になりえない頂点を根にする
void root_change_mid() {
#ifdef _DEBUG
message += "N>2 (mid)\n";
#endif
assert(n > 2); rep(i, n) { if (sz(g[i]) > 1) { root_change(i); return; } } }
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; }
int dep(int a) { if (never)precalc(); return disv[a]; }
int par(int a) { if (never)precalc(); return par_[a]; }
bool isleaf(int i) {if (never)precalc();return (sz(g[i]) == 1 && i != root);}
bool leaf(int i) { return isleaf(i); }
vi child(int r) { vi res; res.push_back(r); queue<int> q; q.push(r); while (!q.empty()) { int i = q.front(); res.push_back(i); q.pop(); forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != par(i))q.push(t); } } return res; }
vb child_ex(int r) { vb res(n); res[r] = true; queue<int> q; q.push(r); while (!q.empty()) { int i = q.front(); res[i] = true; q.pop(); forg_f(gi, g[i]) {forg_f_init(g[i]); if (t != par(i))q.push(t); } } return res; }
int dfs_count_subtree(int p, int i) { childs[i] = 1; fort_f(gi, g[i]) { fort_f_init(gi, g[i]); childs[i] += dfs_count_subtree(i, t); } return childs[i]; }
#define count_child count_subtree
int count_subtree(int f) { if (sz(childs) == 0) { if (never)precalc(); childs.resize(n); dfs_count_subtree(-1, root); } return childs[f]; }
//fからtの辺を切った時のtの大きさ
int count_subtree(int f, int t) { if (par(f) == t) { return n - count_subtree(f); } else { return count_subtree(t); } }
int size(int f, int t){return count_subtree(f, t);}
int size(){return n;}
vi path(int a, int b) { vi res; for_each_l(a, b, [&](int i) { res.push_back(i); }); return res; }
//idはedgesに使えない ↓edge(id)とする
//pathに含まれる辺のid達を返す
vi pathe(int a,int b){
#ifdef _DEBUG
static bool was = 0;if(!was)message+="can't edges[id]. must edge(id)\n";was=1;
#endif
if(sz(par_id_)==0){ ids_.resize(n); par_id_.resize(n); rep(i,0,sz(edges),2){ ids_[edges[i].f].emplace_back(i>>1); ids_[edges[i].t].emplace_back(i>>1); } if(never)precalc();/*par_を呼ぶため*/ rep(i, n){ int pa = par_[i]; forg_f(gi, g[i]){ forg_f_init(g[i]); if(t==pa){ par_id_[i] = ids_[i][gi]; } } } } int u = lca(a,b); vi res; if (a != u) { do { res.emplace_back(par_id_[a]); a = par_[a]; } while (a != u); } vi rev; if (b != u) { do { rev.emplace_back(par_id_[b]); b = par_[b]; } while (b != u); } rer(i,sz(rev)-1){ res.emplace_back(rev[i]); } return res;
}
//親の辺のidを返す
int par_id(int i){if(sz(par_id_)==0){pathe(0,0);}return par_id_[i];}
//fのi番目の辺のidを返す
int ids(int f,int i) {if(sz(ids_)==0){pathe(0,0);}return ids_[f][i];}
//idから辺を返す
edge_<T> edge(int id){return edges[id<<1];}
/*O(N) hldを使わず木を普通にたどる liteの意*/
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]; } fnode(r); vi a; while (v != r) { a.push_back(v); v = par_[v]; } while(sz(a)){ fnode(a.back()); a.pop_back(); } }
void for_each_edge_l(int u, int v, function<void(edge_<int> &)> fedge) { int r = lca(u, v); while (u != r) { forg_f(gi, g[u]) {forg_f_init(g[u]); if (t == par_[u]) { fedge(g[u][gi]); u = par_[u]; break; } } } vector<edge_<int>> qs; while (v != r) { forg_f(gi, g[v]) { forg_f_init(g[v]); if (t == par_[v]) { qs.push_back(g[v][gi]); v = par_[v]; break; } } } while(sz(qs)){ fedge(qs.back()); qs.pop_back(); } }
//Fは半開 (u,v)は木の頂点
//中ではhldの頂点を見るため、seg木のupdateはhldのindexで行なう
void for_each_/*[l,r)*/(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 depth[f] > depth[t] ? vid[f] : vid[t];}
int bel(edge_<T> &e) { /*辺のクエリを扱うときどの頂点に持たせればいいか(vidを返すのでそのままupd出来る)*/ if (never_hld)hld_build();return depth[e.f] > depth[e.t] ? vid[e.f] : vid[e.t];}
template<class ... U> int operator()(U ... args) { return bel(args...); }
//path l -> r += v
template<class S> void seg_add(S &seg, int lhei, int rhei, int v) {for_each_(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); });}
template<class S> void seg_update(S &seg, int lhei, int rhei, int v) {for_each_(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); });}
template<class S> T seg_get(S &seg, int lhei, int rhei) { T res = seg.e; for_each_(lhei, rhei, [&](int l, int r) { res = seg.f(res, seg.get(l, r)); }); return res; }
template<class S> void seg_add_edge(S &seg, int lhei, int rhei, int v) { for_each_edge(lhei, rhei, [&](int l, int r) { seg.add(l, r, v); }); }
template<class S> void seg_update_edge(S &seg, int lhei, int rhei, int v) { for_each_edge(lhei, rhei, [&](int l, int r) { seg.update(l, r, v); }); }
template<class S> T seg_get_edge(S &seg, int lhei, int rhei) { T res = seg.e; for_each_edge(lhei, rhei, [&](int l, int r) { res = seg.f(res, seg.get(l, r)); }); return res; }
//単体 edgeは上で処理できる
template<class S> void seg_add(S &seg, int i, int v) { seg.add(bel(i), v); }
template<class S> void seg_update(S &seg, int i, int v) { seg.update(bel(i), v); }
template<class S> T seg_get(S &seg, int i) { return seg[i]; }
template<class S> void seg_del(S &seg, int i) { seg.del(bel(i)); }
//部分木iに対するクエリ
template<class S> void seg_add_sub(S &seg, int i, int v) {if (never_hld)hld_build();seg.add(subl[i], subr[i], v);}
template<class S> void seg_update_sub(S &seg, int i, int v) {if (never_hld)hld_build();seg.update(subl[i], subr[i], v);}
template<class S> T seg_get_sub(S &seg, int i, int v) {if (never_hld)hld_build();return seg.get(subl[i], subr[i], v);}
template<class S> void seg_add_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/seg.add(subl[i] + 1, subr[i], v);}
template<class S> void seg_update_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/seg.update(subl[i] + 1, subr[i], v);}
template<class S> T seg_get_sub_edge(S &seg, int i, int v) {if (never_hld)hld_build();/*iの上の辺が数えられてしまうため、i+1から*/return seg.get(subl[i] + 1, subr[i], v);}
};
//辺が多いのでedgesを持たない
//cost oo, ox, xo, xx 渡す
template<class T=int> class ungrid_k6 : public undigraph<T> {
vi costs;
public:
using undigraph<T>::g; using undigraph<T>::n; using undigraph<T>::edges;
int H, W;
vector<vector<char>> ba;
char wall;
void add(int f, int t, T c = 1){
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("grid_k6 add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
g[t].emplace_back(t, f, c);
//undigraphと違い、edgesを持たない
}
int getid(int h, int w) { assert(ins(h, w, H, W)); return W * h + w; }
int getid(P p) { return getid(p.first, p.second); }
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); }
int operator()(P p) { return getid(p); }
//辺は無い
ungrid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {}
//fh,fw,th,twでコストを返す linfならスルー
template<class F>void build(F func) { rep(h, H) { rep(w, W) { int fid = getid(h, w); auto add = [&](int fh, int fw, int th, int tw) { if (ins(th, tw, H, W)) { auto cost = func(fh, fw, th, tw); if (abs(cost) >= linf)return; g[fid].emplace_back(fid, getid(th, tw), cost); } }; add(h, w, h + 1, w); add(h, w, h - 1, w); add(h, w, h, w + 1); add(h, w, h, w - 1); } } }
ungrid_k6(vector<vector<char>> ba, char wall = '#') : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) { build([&](int fh, int fw, int th, int tw) { if (ba[fh][fw] == wall || ba[th][tw] == wall)return linf; else return 1ll; }); }
/*o -> o, o -> x, x -> o, x-> x*/
ungrid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx, char wall = '#') : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), costs({oo, ox, xo, xx}), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { int cm = 0; if (ba[fh][fw] == wall) { cm += 2; } if (ba[th][tw] == wall) { cm++; } return costs[cm]; }); }
//lambda
ungrid_k6(vector<vector<char>> ba, char wall, function<T(char, char)> f) : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { return f(ba[fh][fw], ba[th][tw]); }); }
ungrid_k6(vector<vector<char>> ba, char wall, function<T(int, int, int, int)> f) : H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build(f); }
void set_edges() { rep(i, n)fora(e, g[i])if (e.f < e.t)edges.push_back(e); }
};
//辺によりメモリを大量消費ためedgesを消している
//頂点10^6でメモリを190MB(制限の8割)使う
//左上から右下に移動できる
template<class T=int> class digrid_k6 : public digraph<T> {
vi costs;
public:
vector<vector<char>> ba;
char wall;
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
int H, W;
void add(int f, int t, T c = 1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("digrid_k6 add"); deb(f, t, c); ole(); }
g[f].emplace_back(f, t, c);
/*digraphと違いedgesを持たない*/
}
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){}
//fh,fw,th,twでコストを返す linfならスルー
template<class F>void build(F func) { rep(h, H) { rep(w, W) { int fid = getid(h, w); auto add = [&](int fh, int fw, int th, int tw) { if (ins(th, tw, H, W)) { auto cost = func(fh, fw, th, tw); if (abs(cost) >= linf)return; g[fid].emplace_back(fid, getid(th, tw), cost); } }; add(h, w, h + 1, w); add(h, w, h, w + 1); } } }
digrid_k6(vector<vector<char>> ba, char wall = '#') : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) { build([&](int fh, int fw, int th, int tw) { if (ba[fh][fw] == wall || ba[th][tw] == wall)return linf; else return 1ll; }); }
/*o -> o, o -> x, x -> o, x-> x*/
digrid_k6(vector<vector<char>> ba, int oo, int ox, int xo, int xx, char wall = '#') : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), costs({oo, ox, xo, xx}), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { int cm = 0; if (ba[fh][fw] == wall) { cm += 2; } if (ba[th][tw] == wall) { cm++; } return costs[cm]; }); }
//lambda
digrid_k6(vector<vector<char>> ba, char wall, function<T(char, char)> f) : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build([&](int fh, int fw, int th, int tw) { return f(ba[fh][fw], ba[th][tw]); }); }
digrid_k6(vector<vector<char>> ba, char wall, function<T(int, int, int, int)> f) : H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])), ba(ba), wall(wall) { build(f); }
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); }
};
//grid用のdijkstra
//vector<vector<t>>を返す
template<class G, class I> auto dijkstra(G &g, int fh, int fw, I init_value) { auto dis = dijkstra(g, g(fh, fw), init_value); vvi(res, g.H, g.W); rep(i, sz(dis)) { int h, w; tie(h, w) = g.get2(i); res[h][w] = dis[i]; } return res;}
//edgesを持たない
//dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template<class T=int>class segdi : public digraph<T>{int getid(int k){ if(k >= len*2-1){ return k; } else if(k < len - 1){ return k + len; }else{ return k - len + 1; } }void add(int f, int t, T c = 1) { f = getid(f); t = getid(t); if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("segdi add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/ }int mid;int len;
public:
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
//頂点が足りなくなったらresize
segdi(int n_) : digraph<T>(1) { int nn = 1; while (nn < n_)nn *= 2; n_ = nn; len = n_; this->resize(n_ + (n_ - 1) * 2 + n_); mid = n_ + (n_ - 1) * 2; int ad = len * 2 - 1; rep(i, len - 1) { add(i, i * 2 + 1, 0); add(i, i * 2 + 2, 0); if (i * 2 + 1 >= len - 1) { add(i * 2 + 1, i + ad, 0); add(i * 2 + 2, i + ad, 0); } else { add(i * 2 + 1 + ad, i + ad, 0); add(i * 2 + 2 + ad, i + ad, 0); } } }
void dfs(vi &list, int nl, int nr, int k, int l, int r) { if (r <= nl || nr <= l)return; if (l <= nl && nr <= r) { list += k; } else { dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r); dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r); } }
void rekkyo(vi &list, int l, int r) { l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { list.push_back(l); } if (!(r & 1)) { list.push_back(r - 1); } l >>= 1; r = (r - 1) >> 1; } }
//半開
void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/ int ad = 2 * len - 1; if (mid >= n) { this->resize(n + 100); } { int l = fl, r = fr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { if (l - len + 1 < 0)add(l + ad, mid, cost); else add(l, mid, cost); } if (!(r & 1)) { if (r - 1 - len + 1 < 0)add(r - 1 + ad, mid, cost); else add(r - 1, mid, cost); } l >>= 1; r = (r - 1) >> 1; } } { int l = tl, r = tr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { add(mid, l, 0); } if (!(r & 1)) { add(mid, r - 1, 0); } l >>= 1; r = (r - 1) >> 1; } } mid++; }
};
//edgesを持たない
//dijkstra(g,0)[t] とかける (t+n-1等とする必要はない)
template<class T=int>class segun : public undigraph<T>{int getid(int k){ if(k >= len*2-1){ return k; } else if(k < len - 1){ return k + len; }else{ return k - len + 1; } }void add(int f, int t, T c = 1) { f = getid(f); t = getid(t); if (!(0 <= f && f < n && 0 <= t && t < n)) { debugline("segun add"); deb(f, t, c); ole(); } g[f].emplace_back(f, t, c); /*digraphと違いedgesを持たない*/ g[t].emplace_back(t, f, c); /*digraphと違いedgesを持たない*/ } int mid; int len;
public:
using digraph<T>::g; using digraph<T>::n; using digraph<T>::edges;
//頂点が足りなくなったらresize
segun(int n_) : digraph<T>(1) { int nn = 1; while (nn < n_)nn *= 2; n_ = nn; len = n_; this->resize(n_ + (n_ - 1) * 2 + n_); mid = n_ + (n_ - 1) * 2; int ad = len * 2 - 1; rep(i, len - 1) { add(i, i * 2 + 1, 0); add(i, i * 2 + 2, 0); if (i * 2 + 1 >= len - 1) { add(i * 2 + 1, i + ad, 0); add(i * 2 + 2, i + ad, 0); } else { add(i * 2 + 1 + ad, i + ad, 0); add(i * 2 + 2 + ad, i + ad, 0); } } }
void dfs(vi &list, int nl, int nr, int k, int l, int r) { if (r <= nl || nr <= l)return; if (l <= nl && nr <= r) { list += k; } else { dfs(list, nl, (nl + nr) / 2, k * 2 + 1, l, r); dfs(list, (nl + nr) / 2, nr, k * 2 + 2, l, r); } }
void rekkyo(vi &list, int l, int r) { l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { list.push_back(l); } if (!(r & 1)) { list.push_back(r - 1); } l >>= 1; r = (r - 1) >> 1; } }
//半開
void add(int fl, int fr, int tl, int tr, int cost) { /*fは下側*/ int ad = 2 * len - 1; if (mid >= n) { this->resize(n + 100); } { int l = fl, r = fr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { if (l - len + 1 < 0)add(l + ad, mid, cost); else add(l, mid, cost); } if (!(r & 1)) { if (r - 1 - len + 1 < 0)add(r - 1 + ad, mid, cost); else add(r - 1, mid, cost); } l >>= 1; r = (r - 1) >> 1; } } { int l = tl, r = tr; l += len - 1; r += len - 1; while (l < r) { if (!(l & 1)) { add(mid, l, 0); } if (!(r & 1)) { add(mid, r - 1, 0); } l >>= 1; r = (r - 1) >> 1; } } mid++; }
};
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define o_getid(a,b,name,...) name
#define getid(...) o_getid(__VA_ARGS__, getid_2, getid_1) (__VA_ARGS__)
#define unionfind unionfind_graph
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; } }
template<class T>unionfind(graph<T>& g) : n(g.n), trees(g.n) { par.resize(n); siz.resize(n); es.resize(n); for (ll i = 0; i < n; i++) { par[i] = i; siz[i] = 1; } add(g); }
ll root(ll x) { if (par[x] == x) { return x; } else { return par[x] = root(par[x]); }}
ll operator()(ll x){return root(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;
}
template<class T>void add(graph<T>&g){fora(e,g.edges){unite(e.f,e.t);}}
template<class T>void unite(graph<T>&g){add(g);}
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); }
vector<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
//forg基本
template<class T> struct forg_edge_body {
vector<edge_<T>> &edges;
int i;
explicit forg_edge_body(int i, vector<edge_<T>> &edges): i(i), edges(edges) {}
auto operator++() {i++;}
auto operator*() {
#ifdef type_id_graph
return tuple<int, int, int, T, int, int>(i, edges[i].f, edges[i].t, edges[i].c, edges[i].ty, edges[i].id);
#else
return tuple<int, int, int, T>(i, edges[i].f, edges[i].t, edges[i].c);
#endif
}
template<class U>auto operator!=(const U& rhs){return i != rhs.i;}
};
/*@formatter:on*/
template<class T> struct fort_edge_body {
vector<edge_<T>> &edges;
int gi, ci;
int par;
void can_gi() {
while (gi < sz(edges) && edges[gi].t == par) {
gi++;
}
}
explicit fort_edge_body(int i, int par, vector<edge_<T>> &edges) : gi(i), ci(i), par(par), edges(edges) {
can_gi();
}
auto operator++() {
ci++;
gi++;
can_gi();
}
auto operator*() {
#ifdef type_id_graph
return tuple<int, int, int, T, int, int>(gi, edges[gi].f, edges[gi].t, edges[gi].c, edges[gi].ty, edges[gi].id);
#else
return tuple<int, int, int, T>(ci, edges[gi].f, edges[gi].t, edges[gi].c);
#endif
}
template<class U> auto operator!=(const U &rhs) { return gi != rhs.gi; }
};
template<class T> struct forg_edge {
vector<edge_<T>> &edges;
forg_edge_body<T> endp;
forg_edge(vector<edge_<T>> &edges) : edges(edges), endp(sz(edges), edges) {}
auto begin() { return forg_edge_body<T>(0, edges); }
auto end() { return endp; }
};
template<class T> struct fort_edge {
vector<edge_<T>> &edges;
fort_edge_body<T> endp;
int p;
fort_edge(int p, vector<edge_<T>> &edges) : p(p), edges(edges), endp(sz(edges), p, edges) {}
auto begin() { return fort_edge_body<T>(0, p, edges); }
auto end() { return endp; }
};
/*@formatter:off*/
/*@formatter:off*/
#ifdef type_id_graph
#define forg(gi, edges) for(auto[gi, f, t, c, ty, id] : forg_edge(edges))
#define fort(ci, edges) for(auto[ci, f, t, c, ty, id] : fort_edge(p, edges))
#else
#define forg(gi, edges) for(auto[gi, f, t, c] : forg_edge(edges))
#define fort(ci, edges) for(auto[ci, f, t, c] : fort_edge(p, edges))
#endif
//@出力
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) / 2 << endl; fore(gi, g.edges){ if (f < t)os << f << " " << t << " " << c << endl; } return os;}
//@判定
template<class T> bool nibu( 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 true;}
//頂点ではなく辺の数に依存した計算量 O(E)
template<class T> bool nibu_sub( graph<T> &g) { umapi col;/*0なら無色 */ queue<int> q; /*色は01か11 */ fora(e, g.edegs) { /*fとtの色を持つか否かは同じ*/ if (col[e.f] == 0)q.push(e.f); while (!q.empty()) { int f = q.front(); q.pop(); int fc = col[f]; forg_f(gi, g[f]) { forg_f_init(g[f]); int &tc = col[t]; /*fcには色がある*/ if (fc == tc)return false; /*違う色*/ if (tc)continue; /*無色*/ tc = fc ^ 2; q.push(tc); } } } return true;}
//二部グラフを色分けした際の頂点数を返す
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_f(gi, g[now]) { forg_f_init(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> bool close(undigraph<T> &g) { int n = 0; int e = 0; rep(i, g.n) { if (sz(g[i]))n++; forg_f(gi, g[i]) {forg_f_init(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_f(gi, g[i]) {forg_f_init(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);}
//@変形
//条件(f!=0等 f,t,cが使える)を満たすsubgraphをg2に代入
#define sub_di(g, g2, zhouken) {g2.resize(g.n);fore(gi, g.edges){if(zhouken){g2.add(f,t,c);}}}
#define sub_un(g, g2, zhouken) {g2.resize(g.n);fore(gi, g.edges){bool ok = zhouken; /*片方がアウトなら駄目という扱い*/swap(f,t); ok &= zhouken;if(ok && f < t){g2.add(f,t,c);}}}
//誘導部分グラフ(両辺がVに含まれる辺を含む最大のグラフを返す) yuudou
#define sub_di_guided(g, g2, V) {vi ex(max(V)); fora(v,V){ex[v]=1;}sub_di(g, g2, ex[f] && ex[t]);}
#define sub_un_guided(g, g2, V) {vi ex(max(V)); fora(v,V){ex[v]=1;}sub_un(g, g2, ex[f] && ex[t]);}
#define sub_tree sub_un
//閉路がなければ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;}
template<class T> digraph<T> rev(digraph<T> &g) { digraph<T> r(g.n); rep(i, g.n) { forg_f(gi, g[i]) {forg_f_init(g[i]); r.add(t, f, c); }} return r;}
//lc,rcは子を持つ中で一番左、右
//(g,ind,l,r)
template<class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r) {if (sz(ind)) {cerr << "ind must be empty" << endl;exit(0);}int N = sz(g);ind.resize(N);l.resize(N, inf);r.resize(N, -1);tree<T> h(N);queue<P> q;q.emplace(-1, 0);int c = 0;while (sz(q)) {int p = q.front().first;int i = q.front().second;q.pop();ind[i] = c;if (~p)chmi(l[ind[p]], c);if (~p)chma(r[ind[p]], c);c++;forg_f(gi, g[i]) {forg_f_init(g[i]);if (t != p)q.emplace(i, t);}}fora(e, g.edges) {if (e.f < e.t) {h.add(ind[e.f], ind[e.t], e.c);}}rep(i, N) {if (l[i] == inf)l[i] = -1;}return h;}
//lc,rcは子を持つ中で一番左、右
// たとえばl[lc[x]は2段下の最左
//(g,ind,l,r,lc,rc)
template<class T> tree<T> get_bfs_tree(tree<T> &g, vi &ind, vi &l, vi &r, vi &lc, vi &rc) { if (sz(ind)) { cerr << "ind must be empty" << endl; exit(0); } int N = sz(g); ind.resize(N); l.resize(N, inf); lc.resize(N, inf); r.resize(N, -1); rc.resize(N, -1); tree<T> h(N); queue<P> q; q.emplace(-1, 0); int c = 0; while (sz(q)) { int p = q.front().first; int i = q.front().second; q.pop(); ind[i] = c; if (~p) { chmi(l[ind[p]], c); chma(r[ind[p]], c); if (sz(g[i]) > 1) { chmi(lc[ind[p]], c); chma(rc[ind[p]], c); } } c++; forg_f(gi, g[i]) { forg_f_init(g[i]); if (t != p)q.emplace(i, t); } } fora(e, g.edges) { if (e.f < e.t) { h.add(ind[e.f], ind[e.t], e.c); } } rep(i, N) { if (l[i] == inf)l[i] = -1; if (lc[i] == inf)lc[i] = -1; } return h;}
//@集計
template<class T> vi indegree(graph<T> &g) {vi ret(g.size());rep(i, g.size()) { forg_f(gi, g[i]) {forg_f_init(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;}
#define kansetu articulation
//private
/*private*/ P farthest____(tree<> &E, int cur, int pre, int d, vi &D) { D[cur] = d; P r = {d, cur};
forg_f(gi, E[cur]) {
forg_f_init(E[cur]);
if (t != pre) {
P v = farthest____(E, t, cur, d + c, 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); fora(v, per) { forg_f(gi, g[v]) { forg_f_init(g[v]);chma(dp[t], dp[f] + c); }} return max(dp);}
//iから最も離れた距離
vi diameters(tree<> &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に対応するjと距離
vp diameters_p(tree<> &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(v1.second, D[0][i]); else res[i] = mp(v2.second, D[1][i]); } return res;}
int diameter(tree<> &E) { vi d = diameters(E); return max(d);}
//最も離れた二点を返す
P diameter_p(tree<> &E) { auto d = diameters_p(E); int dis = -1; int l = -1, r = -1; rep(i, sz(d)) { if (chma(dis, d[i].se)) { l = i; r = d[i].fi; } } return mp(l, r);}
//@列挙 取得
//閉路がある時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_f(gi, g[i]) { forg_f_init(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_f(gi, g[i]) { forg_f_init(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> 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, G.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, G.n) { if (!vis[i]) dfs(i, -1, k); } sort(arti.begin(), arti.end()); return arti;}
//閉路パスを一つ返す
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_f(gi, g[v]) { forg_f_init(g[i]);if (dfs(t))return true; } state[v] = -1; path.pop_back(); return false; })(i)) { return path; } } return vi();}
#ifdef type_id_graph
vi close_path_id(digraph<> &g) { auto D = close_path(g); if(sz(D)==0)return vi(); D += D[0]; vi ret; int cur = D[0]; rep(i,sz(D)-1){ forg_f(gi, g[D[i]]){forg_f_init(g[D[i]]); if(t == D[i+1]){ ret += id; break; } } } return ret;}
#endif
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;}
//iを含む最短閉路 https://atcoder.jp/contests/abc022/tasks/abc022_c
/*閉路が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_f(gi, rg[now]) { forg_f_init(rg[now]); if (--d[t] == 0) { q += t; res[t] = 0; } } } return res;}
//@アルゴリズム
//下にkrus_idがある
#define mst krus
template<class T> vi krus_i(vector<edge_<T>> &g, int group = 1, int n = -1) { if (n == -1)fora(e, g) { chma(n, max(e.f, e.t) + 1); }; vi res; unionfind uf(n); auto eis = sorti(g); int gcou = n; fora(ei, eis) { if (gcou == group)break; if (uf.unite(g[ei].f, g[ei].t)) { res += ei; gcou--; } } return res;}
template<class T> vector<edge_<T>> krus_ed(vector<edge_<T>> &g, int group=1, int n = -1) { auto inds = krus_i(g, group, n); vector<edge_<T>> ret; fora(i, inds) ret += g[i]; return ret;}
template<class T> vector<edge_<T>> krus_ed(undigraph<T> &g, int group = 1) { if (sz(g.edges) == 0)g.set_edges(); return krus_ed(g.edges, group, g.n);}
template<class T> T krus(undigraph<T> &g, int group = 1) { auto edges = krus_ed(g, group); T res=0; fora(e,edges)res += e.c; return res;}
//森を返す
template<class T> undigraph<T> krus_un(undigraph<T> &g, int group/*森になるので*/) { return undigraph<T>(g.n, krus_ed(g, group));}
template<class T> tree<T> krus_tr(undigraph<T> &g) { return tree<T>(g.n, 0,krus_ed(g));}
template<class T> int krus(vector<edge_<T>> &g, int group = 1) { auto edges = krus_ed(g, group); T res=0; fora(e, edges)res += e.c; return res;}
/*@formatter:off*/
//@実験
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;}
/*頂点数が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;}
template<class T,class I> vector<vector<int>> table(graph<T> &g,I init_value) { vvi(res, g.n, g.n,init_value); rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(g[i]);res[i][t] = c; }} return res;}
#ifdef type_id_graph
template<class T> vector<vector<edge_<T>>> type_list(digraph<T> &g) { vector<vector<edge_<T>>> res; rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(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) { forg_f(gi, g[i]) { forg_f_init(g[i]);chma(tn, ty); }} vector<vector<edge_<T>>> res(tn + 1); vi was(g.n); rep(i, g.n) { forg_f(gi, g[i]) { forg_f_init(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;}
//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;}
//graの方が早い
#endif
//type,idが使いたい場合は
//type_id_graph
// を付ける
#define edge edge_
/*@formatter:on*/}
void solve() {
in(N);
vi X, Y;
na2(X, Y, N);
undigraph<> g(N);
auto add = [&](vi &ind, vi &Z) {
rep(li, sz(ind) - 1) {
int l = ind[li];
int r = ind[li + 1];
g.add(l, r, abs(Z[r] - Z[l]));
}
};
auto ind = sortti(X, Y);
add(ind, X);
ind = sortti(Y, X);
add(ind, Y);
out(mst(g));
}
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) {
//solveを書き直す
//solveを呼び出す
}
exit(0);
#endif
return 0;
};
| a.cc:17:10: fatal error: boost/sort/pdqsort/pdqsort.hpp: No such file or directory
17 | #include <boost/sort/pdqsort/pdqsort.hpp>
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compilation terminated.
|
s490027876 | p03682 | C++ | a | a.cc:1:1: error: 'a' does not name a type
1 | a
| ^
|
s649224842 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Node {
int id;
int x;
int y;
};
struct Edge {
int from;
int to;
int distance;
bool operator<(const Edge &e) const { return distance < e.distance; }
};
int cmpx(Node a, Node b) { return a.x < b.x; }
int cmpy(Node a, Node b) { return a.y < b.y; }
struct UnionFind {
vector<int> par;
vector<ll> sizes;
UnionFind(int N) : par(N), sizes(N, 1) { rep(i, N) par[i] = i; }
// find root parent
int find(int x) {
if (x == par.at(x)) {
return x;
} else {
// update x's parent
return par.at(x) = find(par.at(x));
}
}
// merge x's and y's trees
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (sizes.at(x) < sizes.at(y))
swap(x, y);
// merge x as y's parent
par.at(y) = x;
sizes.at(x) += sizes.at(y);
}
// is same parents
bool same(int x, int y) { return find(x) == find(y); }
};
void solve(ll N, vector<Node> ns) {
ll cost = 0;
vector<Edge> es;
sort(ns.begin(), ns.end(), cmpx);
rep(i, N - 1) {
es.push_back((Edge){
from : ns.at(i).id,
to : ns.at(i + 1).id,
distance : ns.at(i + 1).x - ns.at(i).x
});
}
sort(ns.begin(), ns.end(), cmpy);
rep(j, N - 1) {
es.push_back((Edge){
from : ns.at(j).id,
to : ns.at(j + 1).id,
distance : ns.at(j + 1).y - ns.at(j).y
});
}
sort(all(es)); // sort by distance
UnionFind uf(N);
for (Edge e : es) {
if (!uf.same(e.from, e.to)) {
cost += e.distance;
uf.unite(e.from, e.to);
}
}
cout << cost << endl;
}
int main() {
ll N;
scanf("%lld", &N);
vector<Node> ns(N);
for (int i = 0; i < N; i++) {
(&ns[i])->id = i;
scanf("%lld", &ns[i].x);
scanf("%lld", &ns[i].y);
}
solve(N, std::move(ns));
return 0;
}
| a.cc: In constructor 'UnionFind::UnionFind(int)':
a.cc:27:48: error: 'i' was not declared in this scope
27 | UnionFind(int N) : par(N), sizes(N, 1) { rep(i, N) par[i] = i; }
| ^
a.cc:27:44: error: 'rep' was not declared in this scope
27 | UnionFind(int N) : par(N), sizes(N, 1) { rep(i, N) par[i] = i; }
| ^~~
a.cc: In function 'void solve(ll, std::vector<Node>)':
a.cc:64:7: error: 'i' was not declared in this scope
64 | rep(i, N - 1) {
| ^
a.cc:64:3: error: 'rep' was not declared in this scope
64 | rep(i, N - 1) {
| ^~~
a.cc:73:7: error: 'j' was not declared in this scope
73 | rep(j, N - 1) {
| ^
a.cc:81:8: error: 'all' was not declared in this scope; did you mean 'std::filesystem::perms::all'?
81 | sort(all(es)); // sort by distance
| ^~~
| std::filesystem::perms::all
In file included from /usr/include/c++/14/filesystem:51,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:200,
from a.cc:1:
/usr/include/c++/14/bits/fs_fwd.h:158:7: note: 'std::filesystem::perms::all' declared here
158 | all = 0777,
| ^~~
|
s478721690 | p03682 | C++ | int prim(vector<vector<edge>>& G){
int V(G.size());
int res = 0;
//Pi_i first: 距離 second: 頂点
priority_queue<Pi_i, vector<Pi_i>, greater<Pi_i>> que;
VI d(V, INF);
d[0] = 0;
que.push(MP(0, 0));
while(!que.empty()){
Pi_i p = que.top(); que.pop();
int v = p.second;
if(d[v] < p.first) continue;
d[v] = 0;
res += p.first;
for(edge &e : G[v]){
if(d[e.to] > e.cost){
d[e.to] = e.cost;
que.push(MP(d[e.to], e.to));
}
}
}
return res;
} | a.cc:1:10: error: 'vector' was not declared in this scope
1 | int prim(vector<vector<edge>>& G){
| ^~~~~~
a.cc:1:17: error: 'vector' was not declared in this scope
1 | int prim(vector<vector<edge>>& G){
| ^~~~~~
a.cc:1:24: error: 'edge' was not declared in this scope
1 | int prim(vector<vector<edge>>& G){
| ^~~~
a.cc:1:32: error: 'G' was not declared in this scope
1 | int prim(vector<vector<edge>>& G){
| ^
|
s592526431 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
struct union_find
{
vector<long long> par; //親の番号
vector<long long> rank; //木の深さ(根のランクは0)
vector<long long> siz; //要素xが根なら木の頂点数を格納する
//初期化子リストを用いた初期化
union_find(long long N) : par(N), rank(N), siz(N)
{
for (long long i = 0; i < N; i++)
{
par[i] = i;
rank[i] = 0;
siz[i] = 1;
}
}
//要素xが所属する木の根を再帰的に発見する
long long root(long long x)
{
if (par[x] == x)
return x;
return par[x] = root(par[x]); //経路圧縮
}
//要素xが属する木と要素yが属する木の併合
void unite(long long x, long long y)
{
long long rx = root(x);
long long ry = root(y);
if (rx == ry)
return; //同じ木に属してたらそのまま
if (rank[rx] < rank[ry])
{
par[rx] = ry; //根がryの木に併合
siz[ry] = siz[rx] + siz[ry];
}
else
{
par[ry] = rx; //根がrxの木に併合
siz[rx] = siz[rx] + siz[ry];
if (rank[rx] == rank[ry])
rank[rx]++;
}
}
//要素xが属する木と要素yが属する木が同じならtrueを返す
bool same(long long x, long long y)
{
return root(x) == root(y);
}
//要素xが属する木の頂点数を返す
long long size(long long x)
{
return siz[root(x)];
}
};
/*
クラスカル法
kruskal(V,E):無向グラフから最小全域木を作り使われる辺のコストを返す
使用するためにはunion_findが必要
計算量O(ElogV)
*/
struct kruskal_edge
{
long long u;
long long v;
long long cost;
};
//辺のコストの大小を比較
bool kruskal_comp(const kruskal_edge &e1, const kruskal_edge &e2)
{
return e1.cost < e2.cost;
}
vector<kruskal_edge> kruskal_side;
long long kruskal(long long V, long long E) //V:頂点数,E:辺数
{
sort(kruskal_side.begin(), kruskal_side.end(), kruskal_comp); //辺のコストが小さい順にソート
union_find kruskal_tree(V);
long long kruskal_res = 0;
for (long long i = 0; i < E; i++)
{
kruskal_edge ks = kruskal_side[i];
if (!kruskal_tree.same(ks.u, ks.v))
{
kruskal_tree.unite(ks.u, ks.v);
kruskal_res += ks.cost;
}
}
return kruskal_res;
}
typedef ll long long;
int main()
{
ll N;
cin >> N;
kruskal_side.resize(2 * (N - 1)); //edgeの本数だけ確保
map<pair<ll, ll>, ll> field(N); //ソート後に座標から頂点の番号を特定するのに必要
vector<pair<ll, ll>> xpairs(N); //x座標でソート用
vector<pair<ll, ll>> ypairs(N); //y座標でソート用
for (ll i = 0; i < N; i++)
{
ll a, b;
cin >> a >> b;
pair<ll, ll> P = make_pair(a, b), Q = make_pair(b, a);
field[P] = i;
xpairs[i] = P;
ypairs[i] = Q;
}
sort(xpairs.begin(), xpairs.end());
sort(ypairs.begin(), ypairs.end());
ll now = 0;
for (ll i = 0; i < N - 1; i++)
{
//xpairs
kruskal_side[now].u = field[xpairs[i]];
kruskal_side[now].v = field[xpairs[i + 1]];
kruskal_side[now].cost = xpairs[i + 1].first - xpairs[i].first;
now++;
//ypairs
kruskal_side[now].u = field[ypairs[i]];
kruskal_side[now].v = field[ypairs[i + 1]];
kruskal_side[now].cost = ypairs[i + 1].first - ypairs[i].first;
now++;
}
cout << kruskal(N, 2 * (N - 1)) << endl;
return 0;
} | a.cc:90:9: error: 'll' does not name a type
90 | typedef ll long long;
| ^~
a.cc: In function 'int main()':
a.cc:93:5: error: 'll' was not declared in this scope
93 | ll N;
| ^~
a.cc:94:12: error: 'N' was not declared in this scope
94 | cin >> N;
| ^
a.cc:96:25: error: template argument 1 is invalid
96 | map<pair<ll, ll>, ll> field(N); //ソート後に座標から頂点の番号を特定するのに必要
| ^
a.cc:96:25: error: template argument 3 is invalid
a.cc:96:25: error: template argument 4 is invalid
a.cc:97:23: error: template argument 1 is invalid
97 | vector<pair<ll, ll>> xpairs(N); //x座標でソート用
| ^~
a.cc:97:23: error: template argument 2 is invalid
a.cc:98:23: error: template argument 1 is invalid
98 | vector<pair<ll, ll>> ypairs(N); //y座標でソート用
| ^~
a.cc:98:23: error: template argument 2 is invalid
a.cc:99:12: error: expected ';' before 'i'
99 | for (ll i = 0; i < N; i++)
| ^~
| ;
a.cc:99:20: error: 'i' was not declared in this scope
99 | for (ll i = 0; i < N; i++)
| ^
a.cc:101:11: error: expected ';' before 'a'
101 | ll a, b;
| ^~
| ;
a.cc:102:16: error: 'a' was not declared in this scope
102 | cin >> a >> b;
| ^
a.cc:102:21: error: 'b' was not declared in this scope
102 | cin >> a >> b;
| ^
a.cc:104:14: error: invalid types 'int[int]' for array subscript
104 | field[P] = i;
| ^
a.cc:106:21: error: 'Q' was not declared in this scope
106 | ypairs[i] = Q;
| ^
a.cc:108:17: error: request for member 'begin' in 'xpairs', which is of non-class type 'int'
108 | sort(xpairs.begin(), xpairs.end());
| ^~~~~
a.cc:108:33: error: request for member 'end' in 'xpairs', which is of non-class type 'int'
108 | sort(xpairs.begin(), xpairs.end());
| ^~~
a.cc:109:17: error: request for member 'begin' in 'ypairs', which is of non-class type 'int'
109 | sort(ypairs.begin(), ypairs.end());
| ^~~~~
a.cc:109:33: error: request for member 'end' in 'ypairs', which is of non-class type 'int'
109 | sort(ypairs.begin(), ypairs.end());
| ^~~
a.cc:110:7: error: expected ';' before 'now'
110 | ll now = 0;
| ^~~~
| ;
a.cc:111:12: error: expected ';' before 'i'
111 | for (ll i = 0; i < N - 1; i++)
| ^~
| ;
a.cc:111:20: error: 'i' was not declared in this scope
111 | for (ll i = 0; i < N - 1; i++)
| ^
a.cc:114:22: error: 'now' was not declared in this scope; did you mean 'pow'?
114 | kruskal_side[now].u = field[xpairs[i]];
| ^~~
| pow
|
s824755107 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1000000007;
const ll LINF=1LL<<60;
const int INF=1<<30;
struct UnionFind {
vector<ll> par;
//要素nで初期化
UnionFind(ll n) : par(n, -1) { }
void init(ll n) { par.assign(n, -1); }
//xが属する集合の根を返す
ll root(ll x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
//xとyが同じ集合に属しているかを判定
bool issame(ll x, ll y) {
return root(x) == root(y);
}
//xが属する集合とyが属する集合をマージ
bool merge(ll x, ll y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // 計算量が減るよ
par[x] += par[y];
par[y] = x;
return true;
}
//xが属する集合のサイズ
ll size(ll x) {
return -par[root(x)];
}
};
struct edge { ll u, v, cost; };
bool comp(const edge& e1, const edge& e2) { return e1.cost < e2.cost;}
edge es[500000];
ll E = 0; // 辺数
ll kruskal(ll V) {
sort(es, es + E, comp); // edge.costが小さい順にソートする
UnionFind uf(V); // Union-Findの初期化
ll res = 0;
for (ll i = 0; i < E; i++) {
edge e = es[i];
if (!uf.issame(e.u, e.v)) {
uf.merge(e.u, e.v);
res += e.cost;
}
}
return res;
}
int main(){
ll n;cin>>n;
vector<P> a(n);
vector<P> b(n);
for(ll i = 0; i < n; i++) {
ll x,y;cin>>x>>y;
a[i] = mp(x,i);
b[i] = mp(y,i);
}
sort(ALL(a));
sort(ALL(b));
for(ll i = 0; i < n - 1; i++) {
es[E] = {a[i].sc,a[i + 1].sc,abs(a[i].fs - a[i + 1].fs)};
E++;
es[E] = {a[i + 1].sc,a[i].sc,abs(a[i].fs - a[i + 1].fs)};
E++;
cost[a[i].sc][a[i + 1].sc] = abs(a[i].fs - a[i + 1].fs);
cost[a[i + 1].sc][a[i].sc] = abs(a[i].fs - a[i + 1].fs);
}
for(ll i = 0; i < n - 1; i++) {
es[E] = {b[i].sc,b[i + 1].sc,abs(b[i].fs - b[i + 1].fs)};
E++;
es[E] = {b[i + 1].sc,b[i].sc,abs(b[i].fs - b[i + 1].fs)};
E++;
cost[b[i].sc][b[i + 1].sc] = min(cost[b[i].sc][b[i + 1].sc],abs(b[i].fs - b[i + 1].fs));
cost[b[i + 1].sc][b[i].sc] = min(cost[b[i + 1].sc][b[i].sc],abs(b[i].fs - b[i + 1].fs));
}
cout << kruskal(n) << endl;
return 0;
} | a.cc: In function 'int main()':
a.cc:87:17: error: 'cost' was not declared in this scope; did you mean 'cosl'?
87 | cost[a[i].sc][a[i + 1].sc] = abs(a[i].fs - a[i + 1].fs);
| ^~~~
| cosl
a.cc:95:17: error: 'cost' was not declared in this scope; did you mean 'cosl'?
95 | cost[b[i].sc][b[i + 1].sc] = min(cost[b[i].sc][b[i + 1].sc],abs(b[i].fs - b[i + 1].fs));
| ^~~~
| cosl
|
s935088943 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1000000007;
const ll LINF=1LL<<60;
const int INF=1<<30;
struct UnionFind {
vector<ll> par;
//要素nで初期化
UnionFind(ll n) : par(n, -1) { }
void init(ll n) { par.assign(n, -1); }
//xが属する集合の根を返す
ll root(ll x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
//xとyが同じ集合に属しているかを判定
bool issame(ll x, ll y) {
return root(x) == root(y);
}
//xが属する集合とyが属する集合をマージ
bool merge(ll x, ll y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // 計算量が減るよ
par[x] += par[y];
par[y] = x;
return true;
}
//xが属する集合のサイズ
ll size(ll x) {
return -par[root(x)];
}
};
struct edge { ll u, v, cost; };
bool comp(const edge& e1, const edge& e2) { return e1.cost < e2.cost;}
edge es[200001];
ll E = 0; // 辺数
ll kruskal(ll V) {
sort(es, es + E, comp); // edge.costが小さい順にソートする
UnionFind uf(V); // Union-Findの初期化
ll res = 0;
for (ll i = 0; i < E; i++) {
edge e = es[i];
if (!uf.issame(e.u, e.v)) {
uf.merge(e.u, e.v);
res += e.cost;
}
}
return res;
}
ll main(){
ll n;cin>>n;
vector<P> a(n);
vector<P> b(n);
for(ll i = 0; i < n; i++) {
ll x,y;cin>>x>>y;
a[i] = mp(x,i);
b[i] = mp(y,i);
}
sort(ALL(a));
sort(ALL(b));
for(ll i = 0; i < n - 1; i++) {
es[E] = {a[i].sc,a[i + 1].sc,abs(a[i].fs - a[i + 1].fs)};
E++;
es[E] = {a[i + 1].sc,a[i].sc,abs(a[i].fs - a[i + 1].fs)};
E++;
// cost[a[i].sc][a[i + 1].sc] = abs(a[i].fs - a[i + 1].fs);
// cost[a[i + 1].sc][a[i].sc] = abs(a[i].fs - a[i + 1].fs);
}
for(ll i = 0; i < n - 1; i++) {
es[E] = {b[i].sc,b[i + 1].sc,abs(b[i].fs - b[i + 1].fs)};
E++;
es[E] = {b[i + 1].sc,b[i].sc,abs(b[i].fs - b[i + 1].fs)};
E++;
// cost[b[i].sc][b[i + 1].sc] = min(cost[b[i].sc][b[i + 1].sc],abs(b[i].fs - b[i + 1].fs));
// cost[b[i + 1].sc][b[i].sc] = min(cost[b[i + 1].sc][b[i].sc],abs(b[i].fs - b[i + 1].fs));
}
cout << kruskal(n) << endl;
return 0;
} | a.cc:71:1: error: '::main' must return 'int'
71 | ll main(){
| ^~
|
s088508243 | p03682 | C++ | お手上げ | a.cc:1:1: error: '\U0000304a\U0000624b\U00004e0a\U00003052' does not name a type
1 | お手上げ
| ^~~~~~~~
|
s346311858 | p03682 | C++ | #ifdef BUILT_LOCAL
#include "niklib.h"
#endif
#include <iostream>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <string>
#include <cstdio>
#include <map>
#include <set>
#include <list>
using namespace std;
typedef struct {
int x, y;
} pos_t;
typedef struct {
pos_t *a, *b;
} path_t;
path_t make_path(pos_t *a, pos_t *b) {
path_t t;
t.a = a;
t.b = b;
return t;
}
int main() {
int n = 0;
scanf("%d", &n);
pos_t *p = (pos_t *) malloc(sizeof(pos_t) * n);
pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].x, &p[i].y);
px[i] = py[i] = &p[i];
}
auto cpx = [](pos_t *a, pos_t *b) { return a->x == b->x ? a < b : a->x < b->x; };
auto cpy = [](pos_t *a, pos_t *b) { return a->y == b->y ? a < b : a->y < b->y; };
sort(px, px + n, cpx);
sort(py, py + n, cpy);
auto dist = [](path_t &a) { return min(abs(a.a->x - a.b->x), abs(a.a->y - a.b->y)); };
auto comp = [&dist](path_t &a, path_t &b) { return dist(a) > dist(b); };
priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
set<pos_t *> t;
int r = 0;
t.insert(&p[0]);
auto pushnext = [&this](pos_t *pp) {
auto rx = lower_bound(px, px + n, pp, cpx);
auto ry = lower_bound(py, py + n, pp, cpy);
if (rx != px) q.push(make_path(*rx, *(rx - 1)));
if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
if (ry != py) q.push(make_path(*ry, *(ry - 1)));
if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
};
pushnext(&p[0]);
while (t.size() != n) {
auto pp = q.top();
q.pop();
if (t.find(pp.b) == t.end()) {
r += dist(pp);
t.insert(pp.b);
pushnext(pp.b);
}
}
printf("%d\n", r);
return 0;
} | a.cc: In function 'int main()':
a.cc:62:22: error: 'this' cannot be captured by reference
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc: In lambda function:
a.cc:63:31: error: 'px' is not captured
63 | auto rx = lower_bound(px, px + n, pp, cpx);
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:41:13: note: 'pos_t** px' declared here
41 | pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:63:35: error: 'px' is not captured
63 | auto rx = lower_bound(px, px + n, pp, cpx);
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:41:13: note: 'pos_t** px' declared here
41 | pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:63:40: error: 'n' is not captured
63 | auto rx = lower_bound(px, px + n, pp, cpx);
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:38:9: note: 'int n' declared here
38 | int n = 0;
| ^
a.cc:63:47: error: 'cpx' is not captured
63 | auto rx = lower_bound(px, px + n, pp, cpx);
| ^~~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:47:10: note: 'main()::<lambda(pos_t*, pos_t*)> cpx' declared here
47 | auto cpx = [](pos_t *a, pos_t *b) { return a->x == b->x ? a < b : a->x < b->x; };
| ^~~
a.cc:64:31: error: 'py' is not captured
64 | auto ry = lower_bound(py, py + n, pp, cpy);
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:42:13: note: 'pos_t** py' declared here
42 | pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:64:35: error: 'py' is not captured
64 | auto ry = lower_bound(py, py + n, pp, cpy);
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:42:13: note: 'pos_t** py' declared here
42 | pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:64:40: error: 'n' is not captured
64 | auto ry = lower_bound(py, py + n, pp, cpy);
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:38:9: note: 'int n' declared here
38 | int n = 0;
| ^
a.cc:64:47: error: 'cpy' is not captured
64 | auto ry = lower_bound(py, py + n, pp, cpy);
| ^~~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:48:10: note: 'main()::<lambda(pos_t*, pos_t*)> cpy' declared here
48 | auto cpy = [](pos_t *a, pos_t *b) { return a->y == b->y ? a < b : a->y < b->y; };
| ^~~
a.cc:65:19: error: 'px' is not captured
65 | if (rx != px) q.push(make_path(*rx, *(rx - 1)));
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:41:13: note: 'pos_t** px' declared here
41 | pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:65:23: error: 'q' is not captured
65 | if (rx != px) q.push(make_path(*rx, *(rx - 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:56:57: note: 'std::priority_queue<path_t, std::deque<path_t>, main()::<lambda(path_t&, path_t&)> > q' declared here
56 | priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
| ^
a.cc:66:23: error: 'px' is not captured
66 | if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:41:13: note: 'pos_t** px' declared here
41 | pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:66:28: error: 'n' is not captured
66 | if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:38:9: note: 'int n' declared here
38 | int n = 0;
| ^
a.cc:66:31: error: 'q' is not captured
66 | if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:56:57: note: 'std::priority_queue<path_t, std::deque<path_t>, main()::<lambda(path_t&, path_t&)> > q' declared here
56 | priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
| ^
a.cc:67:19: error: 'py' is not captured
67 | if (ry != py) q.push(make_path(*ry, *(ry - 1)));
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:42:13: note: 'pos_t** py' declared here
42 | pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:67:23: error: 'q' is not captured
67 | if (ry != py) q.push(make_path(*ry, *(ry - 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:56:57: note: 'std::priority_queue<path_t, std::deque<path_t>, main()::<lambda(path_t&, path_t&)> > q' declared here
56 | priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
| ^
a.cc:68:23: error: 'py' is not captured
68 | if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
| ^~
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:42:13: note: 'pos_t** py' declared here
42 | pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
| ^~
a.cc:68:28: error: 'n' is not captured
68 | if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:38:9: note: 'int n' declared here
38 | int n = 0;
| ^
a.cc:68:31: error: 'q' is not captured
68 | if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
| ^
a.cc:62:27: note: the lambda has no capture-default
62 | auto pushnext = [&this](pos_t *pp) {
| ^
a.cc:56:57: note: 'std::priority_queue<path_t, std::deque<path_t>, main()::<lambda(path_t&, path_t&)> > q' declared here
56 | priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
| ^
|
s891528123 | p03682 | C++ | #ifdef BUILT_LOCAL
#include "niklib.h"
#endif
#include <iostream>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <string>
#include <cstdio>
#include <map>
#include <set>
#include <list>
using namespace std;
typedef struct {
int x, y;
} pos_t;
typedef struct {
pos_t *a, *b;
} path_t;
path_t make_path(pos_t *a, pos_t *b) {
path_t t;
t.a = a;
t.b = b;
return t;
}
int main() {
int n = 0;
scanf("%d", &n);
pos_t *p = (pos_t *) malloc(sizeof(pos_t) * n);
pos_t **px = (pos_t **) malloc(sizeof(pos_t *) * n);
pos_t **py = (pos_t **) malloc(sizeof(pos_t *) * n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].x, &p[i].y);
px[i] = py[i] = &p[i];
}
auto cpx = [](pos_t *a, pos_t *b) { return a->x < b->x; };
auto cpy = [](pos_t *a, pos_t *b) { return a->y < b->y; };
sort(px, px + n, cpx);
sort(py, py + n, cpy);
auto dist = [](path_t &a) {
return min(abs(a.a->x - a.b->x), abs(a.a->y - a.b->y));
};
auto comp = [&dist](path_t &a, path_t &b) {
return dist(a) > dist(b);
};
priority_queue<path_t, deque<path_t>, typeof(comp)> q(comp);
set<pos_t *> t;
int r = 0;
t.insert(&p[0]);
auto rx = lower_bound(px, px + n, p.b, cpx);
auto ry = lower_bound(py, py + n, p.b, cpy);
if (rx != px) q.push(make_path(*rx, *(rx - 1)));
if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
if (ry != py) q.push(make_path(*ry, *(ry - 1)));
if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
while (t.size() != n) {
auto p = q.top();
q.pop();
if (t.find(p.b) != t.end()) {
continue;
}
r += dist(p);
t.insert(p.b);
auto rx = lower_bound(px, px + n, p.b, cpx);
auto ry = lower_bound(py, py + n, p.b, cpy);
if (rx != px) q.push(make_path(*rx, *(rx - 1)));
if (rx + 1 != px + n) q.push(make_path(*rx, *(rx + 1)));
if (ry != py) q.push(make_path(*ry, *(ry - 1)));
if (ry + 1 != py + n) q.push(make_path(*ry, *(ry + 1)));
}
printf("%d\n", r);
return 0;
} | a.cc: In function 'int main()':
a.cc:62:41: error: request for member 'b' in 'p', which is of pointer type 'pos_t*' (maybe you meant to use '->' ?)
62 | auto rx = lower_bound(px, px + n, p.b, cpx);
| ^
a.cc:63:41: error: request for member 'b' in 'p', which is of pointer type 'pos_t*' (maybe you meant to use '->' ?)
63 | auto ry = lower_bound(py, py + n, p.b, cpy);
| ^
|
s529321613 | p03682 | C++ | 1 | a.cc:1:1: error: expected unqualified-id before numeric constant
1 | 1
| ^
|
s278570444 | p03682 | C++ | #include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
using namespace std;
#define i64 long long
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
// int DP[MEM_SIZE][MEM_SIZE] = {0};
// int GMEM[MEM_SIZE][MEM_SIZE] = {0};
template<typename T> void DEBUG(T e){std::cout << e << std::endl;}
template<class T> void DEBUG(string str, T e){std::cout <<str << ">>" << e << std::endl;}
template<typename T> void DEBUG(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ DEBUG(v); } }
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
struct place{int i,x,y;};
struct edge{int u,v,cost;};
int par[200000]; //union-find
int ranks[200000]; //union-find
void init(int n){ //union-find
for(int i=0;i<n;i++){
par[i]=i;
ranks[i]=0;
}
}
int find(int x){ //union-find
if(par[x]==x){
return x;
}
else{
return par[x]=find(par[x]);
}
}
void unite(int x, int y){ //union-find
x=find(x);
y=find(y);
if(x==y) return;
if(ranks[x]<ranks[y]){
par[x]=y;
}
else{
par[y]=x;
if(ranks[x]==ranks[y]) ranks[x]++;
}
}
bool same(int x, int y){ //union-find
return find(x) == find(y);
}
bool comp(const edge & e1,const edge& e2)
{
return e1.cost<e2.cost;
}
bool sx(const place &a,const place &b)
{
return a.x < b.x;
}
bool sy(const place &a,const place &b)
{
return a.y < b.y;
}
void solve(void)
{
int N;
vector<place> V;
vector<edge>G;
vector<int>X(N),Y(N);
for (int i = 0; i < N; i++)
{
int xx, yy;
cin>>xx>>yy;
V.emplace_back((int)i,xx,yy);
}
sort(V.begin(),V.end(),sx);
for (int i = 0; i < N-1; i++)
{
edge e = {V[i].i,V[i+1].i,V[i+1].x - V[i].x};
G.push_back(e);
}
sort(V.begin(),V.end(),sy);
for (int i = 0; i < N-1; i++)
{
}
init(N);
sort(G.begin(),G.end(),comp);
int res = 0;
for (int i = 0; i < G.size(); i++)
{
edge e = G[i];
if(!same(e.u,e.v))
{
unite(e.u,e.v);
res+=e.cost;
}
}
cout<<res<<endl;
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
} | In file included from /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h:33,
from /usr/include/c++/14/bits/allocator.h:46,
from /usr/include/c++/14/string:43,
from /usr/include/c++/14/bits/locale_classes.h:40,
from /usr/include/c++/14/bits/ios_base.h:41,
from /usr/include/c++/14/ios:44,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/bits/new_allocator.h: In instantiation of 'void std::__new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = place; _Args = {long long int, long long int&, long long int&}; _Tp = place]':
/usr/include/c++/14/bits/alloc_traits.h:575:17: required from 'static void std::allocator_traits<std::allocator<_CharT> >::construct(allocator_type&, _Up*, _Args&& ...) [with _Up = place; _Args = {long long int, long long int&, long long int&}; _Tp = place; allocator_type = std::allocator<place>]'
575 | __a.construct(__p, std::forward<_Args>(__args)...);
| ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/vector.tcc:117:30: required from 'std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {long long int, long long int&, long long int&}; _Tp = place; _Alloc = std::allocator<place>; reference = place&]'
117 | _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
| ~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
118 | std::forward<_Args>(__args)...);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:109:19: required from here
109 | V.emplace_back((int)i,xx,yy);
| ~~~~~~~~~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/new_allocator.h:191:11: error: new initializer expression list treated as compound expression [-fpermissive]
191 | { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/new_allocator.h:191:11: error: no matching function for call to 'place::place(long long int&)'
a.cc:44:8: note: candidate: 'place::place()'
44 | struct place{int i,x,y;};
| ^~~~~
a.cc:44:8: note: candidate expects 0 arguments, 1 provided
a.cc:44:8: note: candidate: 'constexpr place::place(const place&)'
a.cc:44:8: note: no known conversion for argument 1 from 'long long int' to 'const place&'
a.cc:44:8: note: candidate: 'constexpr place::place(place&&)'
a.cc:44:8: note: no known conversion for argument 1 from 'long long int' to 'place&&'
|
s932973671 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long;
const int N = 200000+5;
struct Edge{
int x,y;
int dis;
Edge(int x,int y,int dis):x(x),y(y),dis(dis){}
bool operator <(const Edge &rhs)const{
return dis<rhs.dis;
}
}edge[N];
int tot;
struct Node{
int x,y;
}node[N];
int father[N];
bool cmpX(int a,int b){
return node[a].x<node[b].x;
}
bool cmpY(int a,int b){
return node[a].y<node[b].y;
}
int Find(int x){
if(father[x]!=x)
return father[x]=Find(father[x]);
return x;
}
int n;
int Kruskal(){
for(int i=1;i<=n;i++)
father[i]=i;
int mst=0;
sort(edge+1,edge+1+tot);
for(int i=1;i<=tot;i++){
int x=Find(edge[i].x);
int y=Find(edge[i].y);
if(x!=y){
mst+=edge[i].dis;
father[x]=y;
}
}
return mst;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d%d",&node[i].x,&node[i].y);
for(int i=1;i<=n;i++)
father[i]=i;
sort(father+1,father+1+n,cmpX);
for(int i=1;i<n;i++){
int x=father[i];
int y=father[i+1];
int dis=node[y].x-node[x].x;
edge[++tot]=Edge(x,y,dis);
}
for(int i=1;i<=n;i++)
father[i]=i;
sort(father+1,father+1+n,cmpY);
for(int i=1;i<n;i++){
int x=father[i];
int y=father[i+1];
int dis=node[y].y-node[x].y;
edge[++tot]=Edge(x,y,dis);
}
int mst=Kruskal();
printf("%d\n",mst);
return 0;
} | a.cc:3:14: error: declaration does not declare anything [-fpermissive]
3 | typedef long long;
| ^~~~
a.cc:12:8: error: no matching function for call to 'Edge::Edge()'
12 | }edge[N];
| ^
a.cc:8:5: note: candidate: 'Edge::Edge(int, int, int)'
8 | Edge(int x,int y,int dis):x(x),y(y),dis(dis){}
| ^~~~
a.cc:8:5: note: candidate expects 3 arguments, 0 provided
a.cc:5:8: note: candidate: 'constexpr Edge::Edge(const Edge&)'
5 | struct Edge{
| ^~~~
a.cc:5:8: note: candidate expects 1 argument, 0 provided
a.cc:5:8: note: candidate: 'constexpr Edge::Edge(Edge&&)'
a.cc:5:8: note: candidate expects 1 argument, 0 provided
|
s282808604 | p03682 | C++ | #include <bits/stdc++.h>
#define TYPE(c) remove_reference_t<decltype(c)>
#define REP(i, n) for(TYPE(n) i = 0; i < n; i++)
#define FOR(v, c) for(TYPE(c.begin()) v = c.begin(); v != c.end(); v++)
#define ALL(c) c.begin(), c.end()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(ALL(c), greater<TYPE(c)::value_type>())
#define UNIQUE(c) c.erase(unique(ALL(c)), c.end())
using namespace std;
using ll = long long;
constexpr int MOD = (int)1e9 + 7;
constexpr int INF = (int)1e9 + 1;
constexpr ll LINF = (ll)1e18 + 1;
template<typename S, typename T> ostream& operator<<(ostream &os, const pair<S, T>& p)
{ return os << "(" << p.first << "," << p.second << ")"; }
template<typename T> auto operator<<(ostream& os, const T& t)
-> typename conditional<true, ostream&, decltype(*t.begin())>::type
{ os << "["; FOR(v, t) { if(v != t.begin()) os << ","; os << *v; } os << "]"; return os; }
class Graph {
using ll = long long;
public:
enum class Type { Directed, Undirected };
struct Edge {
ll cost;
bool validity;
Edge(const ll& _cost = 1) :
cost(_cost), validity(true) { }
friend std::ostream& operator <<(std::ostream& os, const std::shared_ptr<Edge>& e) {
os << "cost : " << e->cost << ", " << "validity : " << e->validity;
return os;
}
};
struct Vertex {
ll cost;
Vertex(const ll& _cost = (ll)1e9 + 1) : cost(_cost) { }
friend std::ostream& operator <<(std::ostream& os, const Vertex& v) {
os << "cost : " << v.cost;
return os;
}
};
const Type edge_type;
std::vector<Vertex> vertices;
std::vector<std::map<ll, std::shared_ptr<Edge>>> edges;
Graph(const ll& nof_vertex, const Type& edge_type, const ll& vertices_initial_cost = (ll)1e9 + 1) :
edge_type(edge_type), vertices(nof_vertex, Vertex(vertices_initial_cost)), edges(nof_vertex) { }
void setCostToAllVertices(const ll& val) {
std::fill(vertices.begin(), vertices.end(), Vertex(val));
};
void addEdge(const ll& src, const ll& dst, const ll& cost = 1) {
auto edge = std::make_shared<Edge>(src, dst, cost);
edges[src].emplace(dst, edge);
if(edge_type == Type::Undirected) edges[dst].emplace(src, edge);
}
friend std::ostream& operator <<(std::ostream& os, const Graph& g) {
os << std::endl
<< "--- Vertex Information ---" << std::endl;
for(size_t i = 0; i < g.vertices.size(); i++)
os << "[[" << i << "] " << g.vertices[i] << "]" << std::endl;
os << "---- Edge Information ----" << std::endl;
for(size_t i = 0; i < g.vertices.size(); i++)
for(const auto& e : g.edges[i])
os << "[" << i << " -> " << e.first << "] " << "[" << e.second << "]" << std::endl;
os << "--------------------------";
return os;
}
};
class UnionFind {
using ll = long long;
public:
struct Node {
ll parent, weight, size, rank;
Node(const ll& _parent = 0,
const ll& _weight = 0,
const ll& _size = 1,
const ll& _rank = 0) :
parent(_parent),
weight(_weight),
size(_size),
rank(_rank) { }
};
explicit UnionFind(const ll& num_node) {
node_.reserve(num_node);
for(ll i = 0; i < num_node; i++) {
node_.emplace_back(i);
}
}
const std::vector<Node>& getNode() const {
return node_;
}
ll searchAndZipRoot(const ll& x) {
if(node_[x].parent == x) {
return x;
}
else {
node_[x].weight += node_[node_[x].parent].weight;
return node_[x].parent = searchAndZipRoot(node_[x].parent);
}
}
void unite(const ll& x,
const ll& y,
const ll& weight = 0) {
auto rx = searchAndZipRoot(x);
auto ry = searchAndZipRoot(y);
if(rx != ry) {
auto yw = weight + calcWeight(x) - calcWeight(y);
if(node_[rx].rank < node_[ry].rank) {
std::swap(rx, ry);
yw *= -1;
}
node_[ry].parent = rx;
node_[ry].weight = yw;
node_[rx].size += node_[ry].size;
if(node_[rx].rank == node_[ry].rank) {
node_[rx].rank++;
}
}
}
ll calcWeight(const ll& x) {
searchAndZipRoot(x);
return node_[x].weight;
}
ll calcDiff(const ll& x,
const ll& y) {
return std::abs(calcWeight(x) - calcWeight(y));
}
ll calcSize(const ll& x) {
return node_[searchAndZipRoot(x)].size;
}
template<class... A>
bool checkWhetherRootIsSame(const A&... nodes) {
auto node_list = std::initializer_list<ll>{nodes...};
if(node_list.size() < 2) return false;
auto v = searchAndZipRoot(*node_list.begin());
for(size_t i = 1; i < node_list.size(); i++) {
if(v != searchAndZipRoot(*(node_list.begin() + i))) return false;
}
return true;
}
private:
std::vector<Node> node_;
};
/**
* 最小全域木を求める(Kruskal法)
* NOTE: 計算量O(|E|log|V|), Dependencies: comp-Graph, comp-UnionFind
* @Return: 最小全域木を返す グラフが非連結の場合、連結成分ごとに最小全域木を構成する
*/
// 使用例
// auto mst = kruskal(g);
// std::cout << mst.getTotalCost() << std::endl;
Graph kruskal(const Graph& g) {
if(g.edge_type != Graph::Type::Undirected) throw std::logic_error("Graph type is invalid");
Graph mst(g.vertices.size(), Graph::Type::Undirected);
std::vector<std::pair<ll, std::pair<int, int>>> mst_e;
mst_e.reserve(g.edges.size());
for(size_t i = 0; i < g.edges.size(); i++)
for(const auto& e : g.edges[i])
mst_e.emplace_back(make_pair(i, e.first), e.second->cost);
sort(mst_e.begin(), mst_e.end());
UnionFind uf(g.vertices.size());
for(const auto& e : mst_e) {
if(!uf.checkWhetherRootIsSame(e.second.first, e.second.second)) {
mst.addEdge(e.second.first, e.second.second, e.first);
uf.unite(e.second.first, e.second.second);
}
}
return mst;
}
void DFS(Graph& g,
const int& index,
ll& ans) {
for(const auto& e : g.edges[index]) {
if(g.vertices[e.first].cost == 0) {
g.vertices[e.first].cost = 1;
ans += e.second->cost;
DFS(g, e.first, ans);
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
std::cin >> N;
vector<pair<pair<int, int>, int>> city_prior_x;
vector<pair<pair<int, int>, int>> city_prior_y;
REP(i, N) {
int x, y;
std::cin >> x >> y;
city_prior_x.emplace_back(make_pair(x, y), i);
city_prior_y.emplace_back(make_pair(y, x), i);
}
Graph g(N, Graph::Type::Undirected);
sort(ALL(city_prior_x));
sort(ALL(city_prior_y));
for(int i = 0; i < N - 1; i++) {
g.addEdge(city_prior_x[i].second,
city_prior_x[i + 1].second,
min(abs(city_prior_x[i].first.first - city_prior_x[i + 1].first.first),
abs(city_prior_x[i].first.second - city_prior_x[i + 1].first.second)));
g.addEdge(city_prior_y[i].second,
city_prior_y[i + 1].second,
min(abs(city_prior_y[i].first.first - city_prior_y[i + 1].first.first),
abs(city_prior_y[i].first.second - city_prior_y[i + 1].first.second)));
}
auto mst = kruskal(g);
mst.setCostToAllVertex(0);
mst.vertices[0].cost = 1;
ll ans = 0;
DFS(mst, 0, ans);
std::cout << ans << std::endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:229:9: error: 'class Graph' has no member named 'setCostToAllVertex'; did you mean 'setCostToAllVertices'?
229 | mst.setCostToAllVertex(0);
| ^~~~~~~~~~~~~~~~~~
| setCostToAllVertices
In file included from /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h:33,
from /usr/include/c++/14/bits/allocator.h:46,
from /usr/include/c++/14/string:43,
from /usr/include/c++/14/bitset:52,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52,
from a.cc:1:
/usr/include/c++/14/bits/new_allocator.h: In instantiation of 'void std::__new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = std::pair<long long int, std::pair<int, int> >; _Args = {std::pair<long unsigned int, long long int>, long long int&}; _Tp = std::pair<long long int, std::pair<int, int> >]':
/usr/include/c++/14/bits/alloc_traits.h:575:17: required from 'static void std::allocator_traits<std::allocator<_CharT> >::construct(allocator_type&, _Up*, _Args&& ...) [with _Up = std::pair<long long int, std::pair<int, int> >; _Args = {std::pair<long unsigned int, long long int>, long long int&}; _Tp = std::pair<long long int, std::pair<int, int> >; allocator_type = std::allocator<std::pair<long long int, std::pair<int, int> > >]'
575 | __a.construct(__p, std::forward<_Args>(__args)...);
| ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/vector.tcc:117:30: required from 'std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {std::pair<long unsigned int, long long int>, long long int&}; _Tp = std::pair<long long int, std::pair<int, int> >; _Alloc = std::allocator<std::pair<long long int, std::pair<int, int> > >; reference = std::pair<long long int, std::pair<int, int> >&]'
117 | _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
| ~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
118 | std::forward<_Args>(__args)...);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:172:31: required from here
172 | mst_e.emplace_back(make_pair(i, e.first), e.second->cost);
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/new_allocator.h:191:11: error: no matching function for call to 'std::pair<long long int, std::pair<int, int> >::pair(std::pair<long unsigned int, long long int>, long long int&)'
191 | { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51:
/usr/include/c++/14/bits/stl_pair.h:913:28: note: candidate: 'template<class _U1, class _U2, typename std::enable_if<(std::_PCC<((! std::is_same<long long int, _U1>::value) || (! std::is_same<std::pair<int, int>, _U2>::value)), long long int, std::pair<int, int> >::_MoveConstructiblePair<_U1, _U2>() && (! std::_PCC<((! std::is_same<long long int, _U1>::value) || (! std::is_same<std::pair<int, int>, _U2>::value)), long long int, std::pair<int, int> >::_ImplicitlyMoveConvertiblePair<_U1, _U2>())), bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(std::pair<_U1, _U2>&&) [with _U2 = _U1; typename std::enable_if<(std::_PCC<((! std::is_same<_T1, _U1>::value) || (! std::is_same<_T2, _U2>::value)), _T1, _T2>::_MoveConstructiblePair<_U1, _U2>() && (! std::_PCC<((! std::is_same<_T1, _U1>::value) || (! std::is_same<_T2, _U2>::value)), _T1, _T2>::_ImplicitlyMoveConvertiblePair<_U1, _U2>())), bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
913 | explicit constexpr pair(pair<_U1, _U2>&& __p)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:913:28: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_pair.h:902:19: note: candidate: 'template<class _U1, class _U2, typename std::enable_if<(std::_PCC<((! std::is_same<long long int, _U1>::value) || (! std::is_same<std::pair<int, int>, _U2>::value)), long long int, std::pair<int, int> >::_MoveConstructiblePair<_U1, _U2>() && std::_PCC<((! std::is_same<long long int, _U1>::value) || (! std::is_same<std::pair<int, int>, _U2>::value)), long long int, std::pair<int, int> >::_ImplicitlyMoveConvertiblePair<_U1, _U2>()), bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(std::pair<_U1, _U2>&&) [with _U2 = _U1; typename std::enable_if<(std::_PCC<((! std::is_same<_T1, _U1>::value) || (! std::is_same<_T2, _U2>::value)), _T1, _T2>::_MoveConstructiblePair<_U1, _U2>() && std::_PCC<((! std::is_same<_T1, _U1>::value) || (! std::is_same<_T2, _U2>::value)), _T1, _T2>::_ImplicitlyMoveConvertiblePair<_U1, _U2>()), bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
902 | constexpr pair(pair<_U1, _U2>&& __p)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:902:19: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_pair.h:891:28: note: candidate: 'template<class _U1, class _U2, typename std::enable_if<(_MoveConstructiblePair<_U1, _U2>() && (! _ImplicitlyMoveConvertiblePair<_U1, _U2>())), bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(_U1&&, _U2&&) [with _U2 = _U1; typename std::enable_if<(std::_PCC<true, _T1, _T2>::_MoveConstructiblePair<_U1, _U2>() && (! std::_PCC<true, _T1, _T2>::_ImplicitlyMoveConvertiblePair<_U1, _U2>())), bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
891 | explicit constexpr pair(_U1&& __x, _U2&& __y)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:891:28: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/stl_pair.h:890:38: error: no type named 'type' in 'struct std::enable_if<false, bool>'
890 | bool>::type=false>
| ^~~~~
/usr/include/c++/14/bits/stl_pair.h:881:19: note: candidate: 'template<class _U1, class _U2, typename std::enable_if<(_MoveConstructiblePair<_U1, _U2>() && _ImplicitlyMoveConvertiblePair<_U1, _U2>()), bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(_U1&&, _U2&&) [with _U2 = _U1; typename std::enable_if<(std::_PCC<true, _T1, _T2>::_MoveConstructiblePair<_U1, _U2>() && std::_PCC<true, _T1, _T2>::_ImplicitlyMoveConvertiblePair<_U1, _U2>()), bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
881 | constexpr pair(_U1&& __x, _U2&& __y)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:881:19: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/stl_pair.h:880:38: error: no type named 'type' in 'struct std::enable_if<false, bool>'
880 | bool>::type=true>
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:869:9: note: candidate: 'template<class _U2, typename std::enable_if<std::__and_<std::is_pointer<long long int>, std::__not_<std::is_reference<_Tp> >, std::is_constructible<std::pair<int, int>, _U2>, std::__not_<std::is_constructible<std::pair<int, int>, const _U1&> >, std::__not_<std::is_convertible<_U2, std::pair<int, int> > > >::value, bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(__zero_as_null_pointer_constant, _U2&&, ...) [with typename std::enable_if<std::__and_<std::is_pointer<_Tp>, std::__not_<std::is_reference<_U1> >, std::is_constructible<_T2, _U2>, std::__not_<std::is_constructible<_T1, const _U1&> >, std::__not_<std::is_convertible<_U2, _T2> > >::value, bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
869 | pair(__zero_as_null_pointer_constant, _U2&& __y, ...)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:869:9: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/stl_pair.h:866:38: error: no type named 'type' in 'struct std::enable_if<false, bool>'
866 | bool> = false>
| ^~~~~
/usr/include/c++/14/bits/stl_pair.h:856:9: note: candidate: 'template<class _U2, typename std::enable_if<std::__and_<std::is_pointer<long long int>, std::__not_<std::is_reference<_Tp> >, std::is_constructible<std::pair<int, int>, _U2>, std::__not_<std::is_constructible<std::pair<int, int>, const _U1&> >, std::is_convertible<_U2, std::pair<int, int> > >::value, bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(__zero_as_null_pointer_constant, _U2&&, ...) [with typename std::enable_if<std::__and_<std::is_pointer<_Tp>, std::__not_<std::is_reference<_U1> >, std::is_constructible<_T2, _U2>, std::__not_<std::is_constructible<_T1, const _U1&> >, std::is_convertible<_U2, _T2> >::value, bool>::type <anonymous> = _U2; _T1 = long long int; _T2 = std::pair<int, int>]'
856 | pair(__zero_as_null_pointer_constant, _U2&& __y, ...)
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:856:9: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/stl_pair.h:853:38: error: no type named 'type' in 'struct std::enable_if<false, bool>'
853 | bool> = true>
| ^~~~
/usr/include/c++/14/bits/stl_pair.h:843:9: note: candidate: 'template<class _U1, typename std::enable_if<std::__and_<std::__not_<std::is_reference<_Tp> >, std::is_pointer<std::pair<int, int> >, std::is_constructible<long long int, _U2>, std::__not_<std::is_constructible<long long int, const _U1&> >, std::__not_<std::is_convertible<_U2, long long int> > >::value, bool>::type <anonymous> > constexpr std::pair<_T1, _T2>::pair(_U1&&, __zero_as_null_pointer_constant, ...) [with typename std::enable_if<std::__and_<std::__not_<std::is_reference<_U1> >, std::is_pointer<_T2>, std::is_constructible<_T1, _U1>, std::__not_<std::is_ |
s592557171 | p03682 | C++ | ///....DH....///
#include <bits/stdc++.h>
#define task "Built"
#define fi(a) freopen(a, "r", stdin)
#define fo(a) freopen(a, "w", stdout)
#define pii pair<int, int>
#define ft first
#define sd second
#define mp make_pair
#define pb push_back
#define pf push_front
#define popb pop_back
#define popf pop_front
#define reset(a, x) memset(a, x, sizeof(a))
#define For(i, s, n, m) for(int i = s; i <= n; i += m)
#define Ford(i, s, n, m) for(int i = s; i >= n; i -= m)
using namespace std;
template <typename R, typename D> inline void Min(R &a, D b) {
if(a>b)
a=b;
}
template <typename D, typename R> inline void Max(D &a, R b) {
if(a<b)
a=b;
}
/** MOD **/ const long long mod = 1e9 + 7;
/** size of array **/ const int maxn = 200005;
/** PI **/ const double M_PI = 3.14159265358979323846;
struct edge {
int x, y, w;
bool operator < (const edge &P) {
return w < P.w;
}
} a[maxn], b[maxn];
int cnt, n, res, p[maxn];
bool cmpx (edge P, edge Q) {
return P.x < Q.x;
}
bool cmpy (edge P, edge Q) {
return P.y < Q.y;
}
int Find(int u) {
if(u == p[u])
return u;
return p[u] = Find(p[u]);
}
int dsu(edge e) {
int x = Find(e.x);
int y = Find(e.y);
if(x == y)
return 0;
p[x] = y;
return e.w;
}
main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
a[i].w = i;
}
sort(a + 1, a + n + 1, cmpx);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(a + 1, a + n + 1, cmpy);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(b + 1, b + cnt + 1);
for(int i = 1; i <= n; i++)
p[i] = i;
for(int i = 1; i <= cnt; i++) {
res += dsu(b[i]);
}
cout << res;
}
//6 8 3 4 9 12 19 18 1 13 5 7 6 -> 8
| In file included from /usr/include/c++/14/cmath:47,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:114,
from a.cc:2:
a.cc:34:42: error: expected unqualified-id before numeric constant
34 | /** PI **/ const double M_PI = 3.14159265358979323846;
| ^~~~
a.cc:67:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
67 | main() {
| ^~~~
|
s605947323 | p03682 | C++ | ///....DH....///
#include <bits/stdc++.h>
#define task "Built"
#define fi(a) freopen(a, "r", stdin)
#define fo(a) freopen(a, "w", stdout)
#define pii pair<int, int>
#define ft first
#define sd second
#define mp make_pair
#define pb push_back
#define pf push_front
#define popb pop_back
#define popf pop_front
#define reset(a, x) memset(a, x, sizeof(a))
#define For(i, s, n, m) for(int i = s; i <= n; i += m)
#define Ford(i, s, n, m) for(int i = s; i >= n; i -= m)
using namespace std;
template <typename R, typename D> inline void Min(R &a, D b) {
if(a>b)
a=b;
}
template <typename D, typename R> inline void Max(D &a, R b) {
if(a<b)
a=b;
}
/** MOD **/ const long long mod = 1e9 + 7;
/** size of array **/ const int maxn = 200005;
/** PI **/ const double M_PI = 3.14159265358979323846;
struct edge {
int x, y, w;
bool operator < (const edge &P) {
return w < P.w;
}
} a[maxn], b[maxn];
int cnt, n, res, p[maxn];
bool cmpx (edge P, edge Q) {
return P.x < Q.x;
}
bool cmpy (edge P, edge Q) {
return P.y < Q.y;
}
int Find(int u) {
if(u == p[u])
return u;
return p[u] = Find(p[u]);
}
int dsu(edge e) {
int x = Find(e.x);
int y = Find(e.y);
if(x == y)
return 0;
p[x] = y;
return e.w;
}
main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
a[i].w = i;
}
sort(a + 1, a + n + 1, cmpx);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(a + 1, a + n + 1, cmpy);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(b + 1, b + cnt + 1);
for(int i = 1; i <= n; i++)
p[i] = i;
for(int i = 1; i <= cnt; i++) {
res += dsu(b[i]);
}
cout << res;
}
//6 8 3 4 9 12 19 18 1 13 5 7 6 -> 8
| In file included from /usr/include/c++/14/cmath:47,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:114,
from a.cc:2:
a.cc:34:42: error: expected unqualified-id before numeric constant
34 | /** PI **/ const double M_PI = 3.14159265358979323846;
| ^~~~
a.cc:67:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
67 | main() {
| ^~~~
|
s550458613 | p03682 | C++ | ///....DH....///
#include <bits/stdc++.h>
#define task "Built"
#define fi(a) freopen(a, "r", stdin)
#define fo(a) freopen(a, "w", stdout)
#define pii pair<int, int>
#define ft first
#define sd second
#define mp make_pair
#define pb push_back
#define pf push_front
#define popb pop_back
#define popf pop_front
#define reset(a, x) memset(a, x, sizeof(a))
#define For(i, s, n, m) for(int i = s; i <= n; i += m)
#define Ford(i, s, n, m) for(int i = s; i >= n; i -= m)
using namespace std;
template <typename R, typename D> inline void Min(R &a, D b) {
if(a>b)
a=b;
}
template <typename D, typename R> inline void Max(D &a, R b) {
if(a<b)
a=b;
}
/** MOD **/ const long long mod = 1e9 + 7;
/** size of array **/ const int maxn = 200005;
/** PI **/ const double M_PI = 3.14159265358979323846;
struct edge {
int x, y, w;
bool operator < (const edge &P) {
return w < P.w;
}
} a[maxn], b[maxn];
int cnt, n, res, p[maxn];
bool cmpx (edge P, edge Q) {
return P.x < Q.x;
}
bool cmpy (edge P, edge Q) {
return P.y < Q.y;
}
int Find(int u) {
if(u == p[u])
return u;
return p[u] = Find(p[u]);
}
int dsu(edge e) {
int x = Find(e.x);
int y = Find(e.y);
if(x == y)
return 0;
p[x] = y;
return e.w;
}
main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
fi(task".inp");
fo(task".out");
#endif
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
a[i].w = i;
}
sort(a + 1, a + n + 1, cmpx);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(a + 1, a + n + 1, cmpy);
for(int i = 1; i < n; i++) {
b[++cnt].x = a[i].w;
b[cnt].y = a[i + 1].w;
b[cnt].w = min(abs(a[i].x - a[i + 1].x), abs(a[i].y - a[i + 1].y));
}
sort(b + 1, b + cnt + 1);
for(int i = 1; i <= n; i++)
p[i] = i;
for(int i = 1; i <= cnt; i++) {
res += dsu(b[i]);
}
cout << res;
}
//6 8 3 4 9 12 19 18 1 13 5 7 6 -> 8
| In file included from /usr/include/c++/14/cmath:47,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:114,
from a.cc:2:
a.cc:34:42: error: expected unqualified-id before numeric constant
34 | /** PI **/ const double M_PI = 3.14159265358979323846;
| ^~~~
a.cc:67:1: warning: ISO C++ forbids declaration of 'main' with no type [-Wreturn-type]
67 | main() {
| ^~~~
|
s532717668 | p03682 | C++ | use std::io::*;
use std::str::FromStr;
use std::clone::Clone;
fn read<T: FromStr>() -> T {
let stdin = stdin();
let stdin = stdin.lock();
let token: String = stdin
.bytes()
.map(|c| c.expect("failed to read char") as char)
.skip_while(|c| c.is_whitespace())
.take_while(|c| !c.is_whitespace())
.collect();
token.parse().ok().expect("failed to parse token")
}
struct UnionFind {
par: Vec<usize>,
rank: Vec<usize>,
size: Vec<usize>
}
impl UnionFind {
fn new(n: usize) -> UnionFind {
let mut vec = vec![0; n];
for i in 0..n {
vec[i] = i;
}
UnionFind {
par: vec,
rank: vec![0; n],
size: vec![1; n]
}
}
fn find(&mut self, x: usize) -> usize {
if self.par[x] == x {
x
} else {
let p = self.par[x];
let pp = self.find(p);
self.size[x] = self.size[pp];
self.par[x] = pp;
pp
}
}
fn unite(&mut self, x: usize, y: usize) {
let p_x = self.find(x);
let p_y = self.find(y);
if p_x != p_y {
self.size[p_x] += self.size[p_y];
self.size[p_y] = self.size[p_x];
if self.rank[p_x] < self.rank[p_y] {
self.par[p_x] = p_y;
} else {
self.par[p_y] = p_x;
if self.rank[p_x] == self.rank[p_y] {
self.rank[p_x] += 1;
}
}
}
}
fn are_same(&mut self, x: usize, y: usize) -> bool {
self.find(x) == self.find(y)
}
}
#[derive(Clone)]
struct Edge {
from: usize,
to: usize,
cost: u64
}
#[derive(Clone)]
struct Node {
pos: u64,
idx: usize
}
fn main() {
let N: usize = read();
let mut edges: Vec<Edge> = vec![
Edge{ from: 0, to: 0, cost: 0 }; N*2
];
let mut x: Vec<Node> = vec![Node{ pos: 0, idx: 0}; N];
let mut y: Vec<Node> = vec![Node{ pos: 0, idx: 0 }; N];
for i in 0..N {
x[i].pos = read();
x[i].idx = i;
y[i].pos = read();
y[i].idx = i;
}
x.sort_by(
|x1, x2| { x1.pos.cmp(&x2.pos) }
);
y.sort_by(
|y1, y2| { y1.pos.cmp(&y2.pos) }
);
for i in 0..N-1 {
edges[2*i].from = x[i].idx;
edges[2*i].to = x[i+1].idx;
edges[2*i].cost = x[i+1].pos - x[i].pos;
edges[2*i+1].from = y[i].idx;
edges[2*i+1].to = y[i+1].idx;
edges[2*i+1].cost = y[i+1].pos - y[i].pos;
}
edges.sort_by(
|e1, e2| { e1.cost.cmp(&e2.cost) }
);
let mut uf = UnionFind::new(N);
let mut ans = 0;
for edge in &edges {
if !uf.are_same(edge.from, edge.to) {
uf.unite(edge.from, edge.to);
ans += edge.cost;
}
}
println!("{}", ans);
} | a.cc:26:18: error: too many decimal points in number
26 | for i in 0..n {
| ^~~~
a.cc:70:2: error: invalid preprocessing directive #[
70 | #[derive(Clone)]
| ^
a.cc:77:2: error: invalid preprocessing directive #[
77 | #[derive(Clone)]
| ^
a.cc:91:14: error: too many decimal points in number
91 | for i in 0..N {
| ^~~~
a.cc:106:14: error: too many decimal points in number
106 | for i in 0..N-1 {
| ^~~~
a.cc:1:1: error: 'use' does not name a type
1 | use std::io::*;
| ^~~
a.cc:2:1: error: 'use' does not name a type
2 | use std::str::FromStr;
| ^~~
a.cc:3:1: error: 'use' does not name a type
3 | use std::clone::Clone;
| ^~~
a.cc:5:1: error: 'fn' does not name a type
5 | fn read<T: FromStr>() -> T {
| ^~
a.cc:18:5: error: 'par' does not name a type
18 | par: Vec<usize>,
| ^~~
a.cc:23:6: error: expected initializer before 'UnionFind'
23 | impl UnionFind {
| ^~~~~~~~~
a.cc:72:5: error: 'from' does not name a type
72 | from: usize,
| ^~~~
a.cc:75:2: error: expected ';' after struct definition
75 | }
| ^
| ;
a.cc:79:5: error: 'pos' does not name a type
79 | pos: u64,
| ^~~
a.cc:83:4: error: expected initializer before 'main'
83 | fn main() {
| ^~~~
|
s945132671 | p03682 | C++ | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
class UnionFind {
public:
vector<int> parent; //親ノード
vector<int> Siz; //集合の大きさ
// コンストラクタ
UnionFind(int n): parent(n), Siz(n, 1) {
rep(i, n) {
parent[i] = i;
}
}
// n要素で初期化
void init(int n) {
parent.resize(n);
Siz.assign(n, 1);
rep(i, n) {
parent[i] = i;
}
}
// xの属する集合の根を求める
int root(int x) {
if(parent[x] == x) {
return x;
}
else {
return parent[x] = root(parent[x]);
}
}
// xとyの属する集合を併合
void unite(int x, int y) {
x = root(x);
y = root(y);
if(x == y) {
return;
}
if(Siz[x] < Siz[y]) {
swap(x, y);
}
Siz[x] += Siz[y];
parent[y] = x;
}
// xとyが同じ集合に属するかどうか
bool same(int x, int y) {
return root(x) == root(y);
}
// xの属する集合の要素数を求める
int size(int x) {
return Siz[root(x)];
}
};
int main() {
int n;
cin >> n;
vector<ll> x(n), y(n);
rep(i, n) {
cin >> x[i] >> y[i];
}
// Kruskal法で使用する枝
using Edge = pair<ll, pair<int, int>>;
vector<Edge> edges;
// x軸方向にソートして隣接している部分のみ
vector<int> ids(n);
iota(ids.begin(), ids.end(), 0);
sort(ids.begin(), ids.end(), [&](int i, int j) { return x[i] < x[j]; });
for(int i = 0; i+1 < ids.size(), i++) {
int u = ids[i];
int v = ids[i+1];
edges.push_back(Edge(x[v] - x[u], make_pair(u, v)));
}
// y軸方向にソートして隣接している部分のみ
sort(ids.begin(), ids.end(), [&](int i, int j) { return y[i] < y[j]; });
for(int i = 0; i+1 < ids.size(), i++) {
int u = ids[i];
int v = ids[i+1];
edges.push_back(Edge(y[v] - y[u], make_pair(u, v)));
}
// Kruskal法
sort(edges.begin(), edges.end());
UnionFind Uni(n);
ll ans = 0;
for(auto e : edges) {
int u = e.second.first;
int v = e.second.second;
ll cost = e.first;
if(Uni.same(u, v)) {
continue;
}
Uni.unite(u, v);
ans += cost;
}
cout << ans << endl;
return 0;
} | a.cc: In function 'int main()':
a.cc:93:41: error: expected ';' before ')' token
93 | for(int i = 0; i+1 < ids.size(), i++) {
| ^
| ;
a.cc:101:41: error: expected ';' before ')' token
101 | for(int i = 0; i+1 < ids.size(), i++) {
| ^
| ;
|
s254091009 | p03682 | C++ | #include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<deque>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf=1e9+7;
const ll INF=1LL<<60 ;
const ll mod=1e9+7 ;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<int, int> P;
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
#define debug(x) cout << #x << " = " << (x) << endl;
using Graph = vector<vector<int> >;
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; }
//#define int long long
struct UnionFind {
vector<int> par, w;
UnionFind(int n) : par(n, -1), w(n, 0) { }
void init(int n) { par.assign(n, -1); w.assign(n, 0); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) {
++w[x];
return false;
}
if (par[x] > par[y]) swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
w[x] += w[y];
++w[x];
return true;
}
int size(int x) {
return -par[root(x)];
}
int wei(int x) {
return w[root(x)];
}
};
//密グラフのMSTは考えるべき辺の本数を減らす
//MST は O(ElogV)
void solve() {
int n; cin >> n;
vector<ll> x(n), y(n);
rep(i, n) cin >> x[i] >> y[i];
using edge = pair<ll, LP>;
vector<edge> edges;
vector<int> ids(n);
iota(all(ids), 0);
sort(all(ids), [&](int i, int j){ return x[i] > y[j];});
rep(i, n - 1) {
int u = ids[i], v = ids[i+1];
edges.push_back(edge(x[u] - x[v], LP(u, v)));
}
sort(all(ids), [&](int i, int j){ return y[i] > y[j];});
rep(i, n - 1) {
int u = ids[i], v = ids[i+1];
edges.push_back(edge(y[u] - y[v], LP(u, v)));
}
sort(all(edges));
UnionFind uf(n);
ll res = 0;
for(auto e: edges) {
int u = e.sc.fr, v = e.sc.sc;
ll cost = e.fr.fr;
if(uf.issame(u, v)) continue;
uf.merge(u, v);
res += cost;
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
//init();
solve();
//cout << "finish" << endl;
return 0;
} | a.cc: In function 'void solve()':
a.cc:43:12: error: request for member 'first' in 'e.std::pair<long long int, std::pair<long long int, long long int> >::first', which is of non-class type 'long long int'
43 | #define fr first
| ^~~~~
a.cc:121:24: note: in expansion of macro 'fr'
121 | ll cost = e.fr.fr;
| ^~
|
s098091066 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
template <typename T>
class Graph
{
public:
struct Edge
{
long long to;
T distance;
Edge(const long long t, const T d)
{
this->to = t;
this->distance = d;
}
bool operator<(const Edge &e) const
{
return this->distance < e.distance;
}
bool operator<=(const Edge &e) const
{
return this->distance <= e.distance;
}
bool operator>(const Edge &e) const
{
return this->distance > e.distance;
}
bool operator>=(const Edge &e) const
{
return this->distance >= e.distance;
}
bool operator==(const Edge &e) const
{
return this->distance == e.distance;
}
};
class SimpleUnionFind
{
public:
vector<long long> root;
UnionFind(long long N)
{
this->root = vector<long long>(N + 1, -1);
}
long long find_root(long long A)
{
if (this->root[A] < 0)
{
return A;
}
else
{
this->root[A] = find_root(this->root[A]);
}
return this->root[A];
}
bool unite(long long A, long long B)
{
A = find_root(A);
B = find_root(B);
if (A == B)
{
return false;
}
if (size(A) < size(B))
{
swap(A, B);
}
this->root[A] += this->root[B];
this->root[B] = A;
return true;
}
bool has_same_root(long long A, long long B)
{
return find_root(A) == find_root(B);
}
};
vector<vector<T>> adjacency_matrix;
long long node;
T initial_value;
vector<vector<Edge>> edge;
Graph(const long long N)
{
setNode(N);
initializeEdgeVector();
}
Graph(const long long N, const T init)
{
setNode(N);
initializeEdgeVector();
setInitialValue(init);
}
void setNode(const long long N)
{
this->node = N + 1;
}
void setInitialValue(const long long init)
{
this->initial_value = init;
}
void initializeAdjacencyMatrix()
{
this->adjacency_matrix = vector<vector<T>>(
this->node, vector<T>(this->node, this->initial_value));
}
void initializeAdjacencyMatrix(const T init)
{
setInitialValue(init);
initializeAdjacencyMatrix();
}
void initializeEdgeVector()
{
this->edge = vector<vector<Edge>>(this->node);
}
void updateAdjacencyMatrix(const long long from, const long long to, const T distance = 1)
{
this->adjacency_matrix[from][to] = distance;
}
void addEdge(const long long from, const long long to, const T distance = 1)
{
this->edge[from].push_back({to, distance});
}
// O(V^3)
// CAUTION: Use adjacency matrix
vector<vector<T>> runFloydWarshall() const
{
vector<vector<T>> ret(this->adjacency_matrix);
for (long long i = 0; i < this->node; i++)
{
for (long long j = 0; j < this->node; j++)
{
for (long long k = 0; k < this->node; k++)
{
ret[j][k] = min(ret[j][k], ret[j][i] + ret[i][k]);
}
}
}
return ret;
}
// O(E)
// CAUTION: Non-weighted only
// CAUTION: Use edge vector
T runBFS(const long long from, const long long to) const
{
vector<bool> visited(this->node, false);
queue<long long> q;
q.push(from);
for (long long i = 1; i <= this->node && !q.empty(); i++)
{
queue<long long> tmp;
while (!q.empty())
{
for (Edge e : this->edge[q.front()])
{
if (e.to == to)
{
return i;
}
if (visited[e.to])
{
continue;
}
visited[e.to] = true;
tmp.push(e.to);
}
q.pop();
}
q = tmp;
}
return this->initial_value;
}
// O(VE)
// CAUTION: Use edge vector
vector<T> runBellmanFord(const long long from) const
{
vector<T> distance(this->node, this->initial_value);
distance[from] = 0;
for (long long i = 0; i < this->node - 1; i++)
{
for (long long j = 1; j < this->node; j++)
{
for (Edge e : this->edge[j])
{
if (distance[e.to] > distance[j] + e.distance)
{
distance[e.to] = distance[j] + e.distance;
}
}
}
}
return distance;
}
// O(E + VlogV)
// CAUTION: Use edge vector
vector<T> runDijkstra(const long long from) const
{
vector<T> distance(this->node, this->initial_value);
priority_queue<Edge, vector<Edge>, greater<Edge>> queue;
queue.push(Edge(from, 0));
while (!queue.empty())
{
T d = queue.top().distance;
long long to = queue.top().to;
queue.pop();
if (distance[to] == this->initial_value)
{
distance[to] = d;
for (Edge e : this->edge[to])
{
if (distance[e.to] == this->initial_value)
{
queue.push({e.to, e.distance + d});
}
}
}
}
return distance;
}
// O(ElogV)
// CAUTION: Use edge vector
T runPrim() const
{
vector<bool> is_visited(this->node, false);
T cost = 0;
priority_queue<Edge, vector<Edge>, greater<Edge>> queue;
queue.push(Edge(1, 0));
while (!queue.empty())
{
T distance = queue.top().distance;
long long to = queue.top().to;
queue.pop();
if (!is_visited[to])
{
cost += distance;
is_visited[to] = true;
for (Edge e : this->edge[to])
{
queue.push({e.to, e.distance});
}
}
}
return cost;
}
T runKruskal() const
{
T cost = 0;
vector<pair<Edge, int>> edge_from;
for (int i = 0; i < this->node; i++)
{
for (auto e : this->edge[i];)
{
edge_from.push_back(make_pair(e, i)));
}
}
sort(edge_from.begin(), edge_from.end());
SimpleUnionFind uf(this->node);
for (pair<Edge, int> e_f : edge_from)
{
auto e = e_f.first;
int from = e_f.second;
if (!uf.has_same_root(from, e.to))
{
unite(from, e.to);
cost += e.distance;
}
}
return cost;
}
};
int main()
{
int N;
cin >> N;
Graph<long long> g(N);
vector<pair<long long, int>> X(N);
vector<pair<long long, int>> Y(N);
long long x, y;
for (int i = 0; i < N; i++)
{
cin >> x >> y;
X[i] = make_pair(x, i);
Y[i] = make_pair(y, i);
}
sort(X.begin(), X.end());
sort(Y.begin(), Y.end());
for (int i = 1; i < N; i++)
{
g.addEdge(X[i - 1].second, X[i].second, X[i].first - X[i - 1].first);
g.addEdge(X[i].second, X[i - 1].second, X[i].first - X[i - 1].first);
g.addEdge(Y[i - 1].second, Y[i].second, Y[i].first - Y[i - 1].first);
g.addEdge(Y[i].second, Y[i - 1].second, Y[i].first - Y[i - 1].first);
}
cout << g.runPrim() << endl;
}
| a.cc:43:9: error: ISO C++ forbids declaration of 'UnionFind' with no type [-fpermissive]
43 | UnionFind(long long N)
| ^~~~~~~~~
a.cc: In member function 'int Graph<T>::SimpleUnionFind::UnionFind(long long int)':
a.cc:46:9: warning: no return statement in function returning non-void [-Wreturn-type]
46 | }
| ^
a.cc: In member function 'bool Graph<T>::SimpleUnionFind::unite(long long int, long long int)':
a.cc:70:21: error: no matching function for call to 'size(long long int&)'
70 | if (size(A) < size(B))
| ~~~~^~~
In file included from /usr/include/c++/14/string:53,
from /usr/include/c++/14/bitset:52,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:52,
from a.cc:1:
/usr/include/c++/14/bits/range_access.h:262:5: note: candidate: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/range_access.h: In substitution of 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&) [with _Container = long long int]':
a.cc:70:21: required from here
70 | if (size(A) < size(B))
| ~~~~^~~
/usr/include/c++/14/bits/range_access.h:263:24: error: request for member 'size' in '__cont', which is of non-class type 'const long long int'
263 | -> decltype(__cont.size())
| ~~~~~~~^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidate: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: template argument deduction/substitution failed:
a.cc:70:21: note: mismatched types 'const _Tp [_Nm]' and 'long long int'
70 | if (size(A) < size(B))
| ~~~~^~~
a.cc:70:31: error: no matching function for call to 'size(long long int&)'
70 | if (size(A) < size(B))
| ~~~~^~~
/usr/include/c++/14/bits/range_access.h:262:5: note: candidate: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/range_access.h: In substitution of 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&) [with _Container = long long int]':
a.cc:70:31: required from here
70 | if (size(A) < size(B))
| ~~~~^~~
/usr/include/c++/14/bits/range_access.h:263:24: error: request for member 'size' in '__cont', which is of non-class type 'const long long int'
263 | -> decltype(__cont.size())
| ~~~~~~~^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidate: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: template argument deduction/substitution failed:
a.cc:70:31: note: mismatched types 'const _Tp [_Nm]' and 'long long int'
70 | if (size(A) < size(B))
| ~~~~^~~
a.cc: In member function 'T Graph<T>::runKruskal() const':
a.cc:274:40: error: expected ')' before ';' token
274 | for (auto e : this->edge[i];)
| ^
a.cc:274:17: note: to match this '('
274 | for (auto e : this->edge[i];)
| ^
a.cc:274:41: error: expected primary-expression before ')' token
274 | for (auto e : this->edge[i];)
| ^
|
s634592178 | p03682 | C++ | # include <iostream>
# include <vector>
typedef long long ll;
using namespace std;
struct UnionFind {
vector<int> parent;
UnionFind(int n) : parent(n) {
for (int i = 0; i < n; i++) parent[i] = i;
}
int root(int n) {
if (parent[n] == n) return n;
return parent[n] = root(parent[n]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
parent[rx] = ry;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<pair<int, int>> xBased(n), yBased(n);
for (int i = 0; i < n; i++) {
int x, y; cin >> x >> y;
xBased[i] = { x, i };
yBased[i] = { y, i };
}
sort(xBased.begin(), xBased.end());
sort(yBased.begin(), yBased.end());
vector<tuple<int, int, int>> costs;
for (int i = 1; i < n; i++) {
int xdiff = xBased[i].first - xBased[i-1].first;
int ydiff = yBased[i].first - yBased[i-1].first;
costs.push_back({ xdiff, xBased[i].second, xBased[i-1].second });
costs.push_back({ ydiff, yBased[i].second, yBased[i-1].second });
}
sort(costs.begin(), costs.end());
UnionFind tree(n);
ll ans = 0;
for (auto& cost : costs) {
int c = get<0>(cost);
int f = get<1>(cost);
int s = get<2>(cost);
if (tree.root(f) != tree.root(s)) {
tree.unite(f, s);
ans += c;
}
}
cout << ans << endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:36:5: error: 'sort' was not declared in this scope; did you mean 'short'?
36 | sort(xBased.begin(), xBased.end());
| ^~~~
| short
|
s676515736 | p03682 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
using pii = pair<int, int>;
#define rep(i,n) for(int i=0;i<(n);++i)
#define in(v) cin>>v;
#define out(v) cout<<v<<"\n"
// union-find
const int MAX_N = 1e5+1;
int parent[MAX_N];
int root(int x) {
if (parent[x] == x)
return x;
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
if (root(x) == root(y))
return;
x = root(x);
y = root(y);
parent[x] = y;
return;
}
bool same(int x, int y) {
return root(x) == root(y);
}
// end
int main() {
cin.tie(0); ios::sync_with_stdio(false);
int N; in(N);
pii x[N], y[N];
rep(i, N) {
in(x[i].first); in(y[i].first);
x[i].second = y[i].second = i;
parent[i] = i;
}
sort(x, x+N); sort(y, y+N);
pair<int, pii> diff_x[N-1], diff_y[N-1];
rep(i, N-1) {
diff_x[i].first = x[i+1].first - x[i].first;
diff_y[i].first = y[i+1].first - y[i].first;
diff_x[i].second = pii(x[i].second, x[i+1].second);
diff_y[i].second = pii(y[i].second, y[i+1].second);
}
sort(diff_x, diff_x+N-1); sort(diff_y, diff_y+N-1);
ll ans = 0;
rep(i, N-1) {
int cost1 = diff_x[i].first;
int cost2 = diff_y[i].first;
int x1 = diff_x[i].second.first,
x2 = diff_x[i].second.second;
int y1 = diff_y[i].second.first,
y2 = diff_y[i].second.second;
if (cost1 < cost2) {
if (!same(x1, x2)) {
unite(x1, x2);
ans += cost1;
}
} else {
if (!same(y1, y2)) {
unite(y1, y2);
ans += cost2;
}
}
if (!same(x1, x2)) {
unite(x1, x2);
ans += cost1;
}
if (!same(y1, y2)) {
unite(y1, y2);
ans += cost2;
}
}
out(ans);
return 0;
}
| a.cc: In function 'int main()':
a.cc:53:3: error: 'll' was not declared in this scope
53 | ll ans = 0;
| ^~
a.cc:64:9: error: 'ans' was not declared in this scope; did you mean 'abs'?
64 | ans += cost1;
| ^~~
| abs
a.cc:69:9: error: 'ans' was not declared in this scope; did you mean 'abs'?
69 | ans += cost2;
| ^~~
| abs
a.cc:74:7: error: 'ans' was not declared in this scope; did you mean 'abs'?
74 | ans += cost1;
| ^~~
| abs
a.cc:78:7: error: 'ans' was not declared in this scope; did you mean 'abs'?
78 | ans += cost2;
| ^~~
| abs
a.cc:81:7: error: 'ans' was not declared in this scope; did you mean 'abs'?
81 | out(ans);
| ^~~
a.cc:8:22: note: in definition of macro 'out'
8 | #define out(v) cout<<v<<"\n"
| ^
|
s150016667 | p03682 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const long long MAXN = 1e5+5;
vector<pair<pair<long long,long long>,long long>> polong longs;
vector<pair<pair<long long,long long>,long long>> polong longs2;
vector<pair<long long,pair<long long,long long>>> edges;
long long par[MAXN];
long long ans;
long long findpar(long long a){
if(par[a] == a){
return a;
}
return par[a] = findpar(par[a]);
}
void merge(long long a,long long b){
a = findpar(a);
b = findpar(b);
if(a==b){
return;
}
par[b] = a;
}
int main(){
long long n;
cin>>n;
for(long long i=1;i<=n;i++){
long long x,y;
cin>>x>>y;
polong longs.push_back(make_pair(make_pair(x,y),i));
polong longs2.push_back(make_pair(make_pair(y,x),i));
}
sort(polong longs.begin(),polong longs.end());
sort(polong longs2.begin(),polong longs2.end());
for(long long i=1;i<n;i++){
edges.push_back(make_pair(abs(polong longs[i].first.first-polong longs[i-1].first.first),make_pair(polong longs[i-1].second,polong longs[i].second)));
edges.push_back(make_pair(abs(polong longs2[i].first.first-polong longs2[i-1].first.first),make_pair(polong longs2[i-1].second,polong longs2[i].second)));
}
sort(edges.begin(),edges.end());
for(long long i=1;i<=n;i++){
par[i] = i;
}
for(auto i:edges){
long long w = i.first;
long long x = i.second.first;
long long y = i.second.second;
if(findpar(x)!=findpar(y)){
merge(x,y);
ans+=w;
}
}
cout<<ans<<endl;
}
| a.cc:6:58: error: expected initializer before 'longs'
6 | vector<pair<pair<long long,long long>,long long>> polong longs;
| ^~~~~
a.cc:7:58: error: expected initializer before 'longs2'
7 | vector<pair<pair<long long,long long>,long long>> polong longs2;
| ^~~~~~
a.cc: In function 'int main()':
a.cc:33:9: error: 'polong' was not declared in this scope; did you mean 'ulong'?
33 | polong longs.push_back(make_pair(make_pair(x,y),i));
| ^~~~~~
| ulong
a.cc:34:15: error: expected ';' before 'longs2'
34 | polong longs2.push_back(make_pair(make_pair(y,x),i));
| ^~~~~~~
| ;
a.cc:36:10: error: 'polong' was not declared in this scope; did you mean 'ulong'?
36 | sort(polong longs.begin(),polong longs.end());
| ^~~~~~
| ulong
a.cc:36:37: error: expected ')' before 'longs'
36 | sort(polong longs.begin(),polong longs.end());
| ~ ^~~~~~
| )
a.cc:37:16: error: expected ')' before 'longs2'
37 | sort(polong longs2.begin(),polong longs2.end());
| ~ ^~~~~~~
| )
a.cc:37:38: error: expected ')' before 'longs2'
37 | sort(polong longs2.begin(),polong longs2.end());
| ~ ^~~~~~~
| )
a.cc:39:45: error: expected ')' before 'longs'
39 | edges.push_back(make_pair(abs(polong longs[i].first.first-polong longs[i-1].first.first),make_pair(polong longs[i-1].second,polong longs[i].second)));
| ~ ^~~~~~
| )
a.cc:39:114: error: expected ')' before 'longs'
39 | edges.push_back(make_pair(abs(polong longs[i].first.first-polong longs[i-1].first.first),make_pair(polong longs[i-1].second,polong longs[i].second)));
| ~ ^~~~~~
| )
a.cc:39:139: error: expected ')' before 'longs'
39 | edges.push_back(make_pair(abs(polong longs[i].first.first-polong longs[i-1].first.first),make_pair(polong longs[i-1].second,polong longs[i].second)));
| ~ ^~~~~~
| )
a.cc:40:45: error: expected ')' before 'longs2'
40 | edges.push_back(make_pair(abs(polong longs2[i].first.first-polong longs2[i-1].first.first),make_pair(polong longs2[i-1].second,polong longs2[i].second)));
| ~ ^~~~~~~
| )
a.cc:40:116: error: expected ')' before 'longs2'
40 | edges.push_back(make_pair(abs(polong longs2[i].first.first-polong longs2[i-1].first.first),make_pair(polong longs2[i-1].second,polong longs2[i].second)));
| ~ ^~~~~~~
| )
a.cc:40:142: error: expected ')' before 'longs2'
40 | edges.push_back(make_pair(abs(polong longs2[i].first.first-polong longs2[i-1].first.first),make_pair(polong longs2[i-1].second,polong longs2[i].second)));
| ~ ^~~~~~~
| )
|
s003453484 | p03682 | C++ | #include <bits/stdc++.h>
#define REP(i, n) for(decltype(n) i = 0; i < n; i++)
#define ALL(c) c.begin(), c.end()
#define SORT(c) std::sort(ALL(c))
#define RSORT(c) std::sort(ALL(c), std::greater<decltype(c)::value_type>())
using namespace std;
using ll = long long;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9 + 1;
const ll LINF = (ll)1e18 + 1;
class CommonGraph {
using ll = long long;
public:
struct Edge {
enum class Type { Directed, Undirected };
int src, dst;
ll cost;
Edge() = default;
Edge(const int& _src,
const int& _dst,
const ll& _cost = 0) :
src(_src),
dst(_dst),
cost(_cost) { }
};
friend std::ostream& operator <<(std::ostream& os, const Edge& obj) {
os << "src : " << obj.src << ", "
<< "dst : " << obj.dst << ", "
<< "cost : " << obj.cost;
return os;
}
struct Vertex {
ll cost;
Vertex(const ll& _cost) : cost(_cost) { }
};
CommonGraph(const int& num_vertex,
const Edge::Type& edge_type) :
vertex_(num_vertex, 0),
edge_(num_vertex),
num_edge_(0),
total_cost_(0),
edge_type_(edge_type) { }
ll getTotalCost() const {
return total_cost_;
}
const std::vector<Vertex>& getVertex() const {
return vertex_;
}
const std::vector<std::vector<Edge>>& getEdge() const {
return edge_;
}
/**
* 辺を追加する
*/
void addEdge(const int& src,
const int& dst,
const ll& cost) {
switch(edge_type_) {
case Edge::Type::Directed:
edge_[src].emplace_back(src, dst, cost);
break;
case Edge::Type::Undirected:
edge_[src].emplace_back(src, dst, cost);
edge_[dst].emplace_back(dst, src, cost);
break;
}
num_edge_++; total_cost_ += cost;
}
/**
* 辺の情報を標準出力する
*/
void dumpEdgeInfo() const {
for(const auto& v : edge_) {
for(const auto& e : v) {
std::cout << "[" << e << "]" << std::endl;
}
std::cout << std::endl;
}
}
/**
* DFSテンプレート
* 例: 木における全ての頂点に対するある頂点からの最短距離
*/
void dfs(const int& index,
const ll& inf_val = (ll)1e18 + 1) {
std::fill(vertex_.begin(), vertex_.end(), inf_val);
for(const auto& edge : edge_[index]) {
if(vertex_[edge.dst].cost == inf_val) {
vertex_[edge.dst].cost = vertex_[edge.src].cost + edge.cost;
dfs(edge.dst);
}
}
}
/**
* 全ての頂点に対してある頂点からの最短経路を求める(Bellman-Ford法)
* NOTE: 計算量O(|V||E|), 始点と非連結の頂点はLINFとする
* @start_index: 始点
* @Return: 解が求まればtrueを返す
* 負の閉路が存在する場合falseを返す
*/
bool calcMinCostByBellmanFord(const int& start_index,
const ll& inf_val = (ll)1e18 + 1) {
std::fill(vertex_.begin(), vertex_.end(), inf_val);
vertex_[start_index].cost = 0; size_t cnt = 0;
while(true) {
bool update = false;
for(size_t i = 0; i < vertex_.size(); i++) {
for(const auto& edge : edge_[i]) {
if(vertex_[edge.src].cost != inf_val) {
auto cost = vertex_[edge.src].cost + edge.cost;
if(cost < vertex_[edge.dst].cost) {
vertex_[edge.dst].cost = cost; update = true;
}
}
}
}
if(!update) break;
if(cnt == vertex_.size() - 1) return false;
cnt++;
}
return true;
}
/**
* 全ての頂点に対してある頂点からの最短経路を求める(dijkstra法)
* NOTE: 計算量O(|E|log|V|), 始点と非連結の頂点はLINFとする
* @start_index: 始点
* @Return: void
*/
void calcMinCostByDijkstra(const int& start_index,
const ll& inf_val = (ll)1e18 + 1) {
using pll = std::pair<ll, ll>;
std::fill(vertex_.begin(), vertex_.end(), inf_val);
vertex_[start_index].cost = 0;
std::priority_queue<pll, std::vector<pll>, std::greater<pll>> pq;
pq.emplace(0, start_index);
while(!pq.empty()) {
auto top = pq.top(); pq.pop();
if(vertex_[top.second].cost < top.first) continue;
for(const auto& edge : edge_[top.second]) {
auto cost = vertex_[top.second].cost + edge.cost;
if(cost < vertex_[edge.dst].cost) {
vertex_[edge.dst].cost = cost;
pq.emplace(vertex_[edge.dst].cost, edge.dst);
}
}
}
}
/**
* 最小全域木を求める(Kruskal法)
* @Return: 最小全域木を返す
* グラフが非連結の場合、連結成分ごとに最小全域木を構成する
*/
CommonGraph generateMinimumSpanningTree() {
if(edge_type_ != Edge::Type::Undirected) {
throw std::logic_error("Graph type is invalid");
}
struct UF {
struct N{ll p,r;N(const ll&_p=0,const ll&_r=0):p(_p),r(_r){}};std::vector<N>n;
explicit UF(const ll&nn){n.reserve(nn);std::iota(n.begin(),n.end(),0);
ll root(const ll&x){return(n[x].p==x)?x:n[x].p=root(n[x].p);}
void unite(const ll&x,const ll&y){ll w=root(x);ll z=root(y);if(w!=z){if(n[w].r<n[z].r)std::swap(w,z);n[z].p=w;if(n[w].r==n[z].r)n[w].r++;}}
bool same(const ll&x,const ll&y){return root(x)==root(y);}
};
auto num_v = vertex_.size();
CommonGraph mst(num_v, Edge::Type::Undirected);
std::vector<Edge> mst_e;
mst_e.reserve(num_edge_ * 2);
for(const auto& v : edge_) for(const auto& e : v) mst_e.push_back(e);
auto sort_rule = [](const Edge& l, const Edge& r) { return l.cost < r.cost; };
sort(mst_e.begin(), mst_e.end(), sort_rule);
UF uf(num_v);
for(const auto& e : mst_e) {
if(!uf.same(e.src, e.dst)) {
mst.addEdge(e.src, e.dst, e.cost);
uf.unite(e.src, e.dst);
}
}
return mst;
}
/**
* 全頂点間の最短距離を求める(Warshall-Floyd法)
* @Return: array[i][j] :: 頂点iから頂点jまでの最短距離
*/
std::vector<std::vector<ll>> calcMinCostBetweenAllVertices() {
std::vector<std::vector<ll>> dp(vertex_.size(),
std::vector<ll>(vertex_.size(),
std::numeric_limits<uint>::max()));
for(const auto& v : edge_) for(const auto& e : v) dp[e.src][e.dst] = e.cost;
for(size_t i = 0; i < vertex_.size(); i++)
for(size_t j = 0; j < vertex_.size(); j++)
for(size_t k = 0; k < vertex_.size(); k++)
dp[j][k] = std::min(dp[j][k], dp[j][i] + dp[i][k]);
return dp;
}
private:
std::vector<Vertex> vertex_;
std::vector<std::vector<Edge>> edge_;
ll num_edge_;
ll total_cost_;
const Edge::Type edge_type_;
};
int main() {
try {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
std::cin >> N;
vector<pair<pair<int, int>, int>> city_prior_x;
vector<pair<pair<int, int>, int>> city_prior_y;
REP(i, N) {
int x, y;
std::cin >> x >> y;
city_prior_x.emplace_back(make_pair(x, y), i);
city_prior_y.emplace_back(make_pair(y, x), i);
}
CommonGraph g(N, CommonGraph::Edge::Type::Undirected);
sort(ALL(city_prior_x));
sort(ALL(city_prior_y));
for(int i = 0; i < N - 1; i++) {
g.addEdge(city_prior_x[i].second,
city_prior_x[i + 1].second,
min(abs(city_prior_x[i].first.first - city_prior_x[i + 1].first.first),
abs(city_prior_x[i].first.second - city_prior_x[i + 1].first.second)));
g.addEdge(city_prior_y[i].second,
city_prior_y[i + 1].second,
min(abs(city_prior_y[i].first.first - city_prior_y[i + 1].first.first),
abs(city_prior_y[i].first.second - city_prior_y[i + 1].first.second)));
}
auto mst = g.generateMinimumSpanningTree();
std::cout << mst.getTotalCost() << std::endl;
}
catch(const exception& e) {
std::cout << e.what() << std::endl;
exit(1);
}
return 0;
}
| a.cc:262:2: error: expected '}' at end of input
262 | }
| ^
a.cc:16:19: note: to match this '{'
16 | class CommonGraph {
| ^
a.cc: In constructor 'CommonGraph::CommonGraph(const int&, const Edge::Type&)':
a.cc:46:9: error: class 'CommonGraph' does not have any field named 'vertex_'
46 | vertex_(num_vertex, 0),
| ^~~~~~~
a.cc:47:9: error: class 'CommonGraph' does not have any field named 'edge_'
47 | edge_(num_vertex),
| ^~~~~
a.cc:48:9: error: class 'CommonGraph' does not have any field named 'num_edge_'
48 | num_edge_(0),
| ^~~~~~~~~
a.cc:49:9: error: class 'CommonGraph' does not have any field named 'total_cost_'
49 | total_cost_(0),
| ^~~~~~~~~~~
a.cc:50:9: error: class 'CommonGraph' does not have any field named 'edge_type_'
50 | edge_type_(edge_type) { }
| ^~~~~~~~~~
a.cc: In member function 'CommonGraph::ll CommonGraph::getTotalCost() const':
a.cc:53:16: error: 'total_cost_' was not declared in this scope
53 | return total_cost_;
| ^~~~~~~~~~~
a.cc: In member function 'const std::vector<CommonGraph::Vertex>& CommonGraph::getVertex() const':
a.cc:57:16: error: 'vertex_' was not declared in this scope; did you mean 'Vertex'?
57 | return vertex_;
| ^~~~~~~
| Vertex
a.cc: In member function 'const std::vector<std::vector<CommonGraph::Edge> >& CommonGraph::getEdge() const':
a.cc:61:16: error: 'edge_' was not declared in this scope
61 | return edge_;
| ^~~~~
a.cc: In member function 'void CommonGraph::addEdge(const int&, const int&, const ll&)':
a.cc:70:16: error: 'edge_type_' was not declared in this scope
70 | switch(edge_type_) {
| ^~~~~~~~~~
a.cc:72:17: error: 'edge_' was not declared in this scope
72 | edge_[src].emplace_back(src, dst, cost);
| ^~~~~
a.cc:79:9: error: 'num_edge_' was not declared in this scope
79 | num_edge_++; total_cost_ += cost;
| ^~~~~~~~~
a.cc:79:22: error: 'total_cost_' was not declared in this scope
79 | num_edge_++; total_cost_ += cost;
| ^~~~~~~~~~~
a.cc: In member function 'void CommonGraph::dumpEdgeInfo() const':
a.cc:86:29: error: 'edge_' was not declared in this scope
86 | for(const auto& v : edge_) {
| ^~~~~
a.cc: In member function 'void CommonGraph::dfs(const int&, const ll&)':
a.cc:100:19: error: 'vertex_' was not declared in this scope; did you mean 'Vertex'?
100 | std::fill(vertex_.begin(), vertex_.end(), inf_val);
| ^~~~~~~
| Vertex
a.cc:101:32: error: 'edge_' was not declared in this scope; did you mean 'edge'?
101 | for(const auto& edge : edge_[index]) {
| ^~~~~
| edge
a.cc: In member function 'bool CommonGraph::calcMinCostByBellmanFord(const int&, const ll&)':
a.cc:118:19: error: 'vertex_' was not declared in this scope; did you mean 'Vertex'?
118 | std::fill(vertex_.begin(), vertex_.end(), inf_val);
| ^~~~~~~
| Vertex
a.cc:123:40: error: 'edge_' was not declared in this scope; did you mean 'edge'?
123 | for(const auto& edge : edge_[i]) {
| ^~~~~
| edge
a.cc: In member function 'void CommonGraph::calcMinCostByDijkstra(const int&, const ll&)':
a.cc:148:19: error: 'vertex_' was not declared in this scope; did you mean 'Vertex'?
148 | std::fill(vertex_.begin(), vertex_.end(), inf_val);
| ^~~~~~~
| Vertex
a.cc:155:36: error: 'edge_' was not declared in this scope; did you mean 'edge'?
155 | for(const auto& edge : edge_[top.second]) {
| ^~~~~
| edge
a.cc: In member function 'CommonGraph CommonGraph::generateMinimumSpanningTree()':
a.cc:171:12: error: 'edge_type_' was not declared in this scope
171 | if(edge_type_ != Edge::Type::Undirected) {
| ^~~~~~~~~~
a.cc:181:9: error: non-static data member declared with placeholder 'auto'
181 | auto num_v = vertex_.size();
| ^~~~
a.cc:182:25: error: 'num_v' is not a type
182 | CommonGraph mst(num_v, Edge::Type::Undirected);
| ^~~~~
a.cc:182:32: error: 'CommonGraph::Edge::Type::Undirected' is not a type
182 | CommonGraph mst(num_v, Edge::Type::Undirected);
| ^~~~
a.cc:184:9: error: 'mst_e' does not name a type
184 | mst_e.reserve(num_edge_ * 2);
| ^~~~~
a.cc:185:9: error: expected unqualified-id before 'for'
185 | for(const auto& v : edge_) for(const auto& e : v) mst_e.push_back(e);
| ^~~
a.cc:186:9: error: non-static data member declared with placeholder 'auto'
186 | auto sort_rule = [](const Edge& l, const Edge& r) { return l.cost < r.cost; };
| ^~~~
a.cc:187:14: error: 'mst_e' is not a type
187 | sort(mst_e.begin(), mst_e.end(), sort_rule);
| ^~~~~
a.cc:187:19: error: expected ',' or '...' before '.' token
187 | sort(mst_e.begin(), mst_e.end(), sort_rule);
| ^
a.cc:187:9: error: ISO C++ forbids declaration of 'sort' with no type [-fpermissive]
187 | sort(mst_e.begin(), mst_e.end(), sort_rule);
| ^~~~
a.cc:188:15: error: 'num_v' is not a type
188 | UF uf(num_v);
| ^~~~~
a.cc:189:9: error: expected unqualified-id before 'for'
189 | for(const auto& e : mst_e) {
| ^~~
a.cc:195:9: error: expected unqualified-id before 'return'
195 | return mst;
| ^~~~~~
a.cc: In constructor 'CommonGraph::generateMinimumSpanningTree()::UF::UF(const CommonGraph::ll&)':
a.cc:177:32: error: a function-definition is not allowed here before '{' token
177 | ll root(const ll&x){return(n[x].p==x)?x:n[x].p=root(n[x].p);}
| ^
a.cc:178:46: error: a function-definition is not allowed here before '{' token
178 | void unite(const ll&x,const ll&y){ll w=root(x);ll z=root(y);if(w!=z){if(n[w].r<n[z].r)std::swap(w,z);n[z].p=w;if(n[w].r==n[z].r)n[w].r++;}}
| ^
a.cc:179:45: error: a function-definition is not allowed here before '{' token
179 | bool same(const ll&x,const ll&y){return root(x)==root(y);}
| ^
a.cc: In member function 'CommonGraph CommonGraph::generateMinimumSpanningTree()':
a.cc:202:34: error: invalid declarator before 'calcMinCostBetweenAllVertices'
202 | std::vector<std::vector<ll>> calcMinCostBetweenAllVertices() {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:214:1: error: expected primary-expression before 'private'
214 | private:
| ^~~~~~~
a.cc:219:36: error: uninitialized 'const edge_type_' [-fpermissive]
219 | const Edge::Type edge_type_;
| ^~~~~~~~~~
a.cc: At global scope:
a.cc:262:2: error: expected unqualified-id at end of input
262 | }
| ^
|
s776538566 | p03682 | C++ | #include<iostream>
using namespace std;
int main(
{
return 0;
} | a.cc:5:5: error: cannot declare '::main' to be a global variable
5 | int main(
| ^~~~
a.cc:7:1: error: expected primary-expression before 'return'
7 | return 0;
| ^~~~~~
a.cc:7:1: error: expected '}' before 'return'
a.cc:6:1: note: to match this '{'
6 | {
| ^
a.cc:6:2: error: expected ')' before 'return'
6 | {
| ^
| )
7 | return 0;
| ~~~~~~
a.cc:5:9: note: to match this '('
5 | int main(
| ^
a.cc:8:1: error: expected declaration before '}' token
8 | }
| ^
|
s174446663 | p03682 | C++ | //おまじない
#include <iostream>
#include<iomanip>
#include <algorithm>
#include <vector>
#include <string>
#include <utility>
#include <queue>
#define INF 1e9+7
#define rep(i,n) for(int i=0;i<n;i++)
#define NO cout<<"NO"<<endl;
#define YES cout << "YES"<<endl;
#define No cout << "No"<<endl;
#define Yes cout << "Yes"<<endl;
#define all(a) a.begin(),a.end()
#define P pair<int,int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
const int maxn=100000;
//UnionFind
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
UnionFind(int N) {
Parent = vector<int>(N, -1);
}
//Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0) return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)];
}
//AとBをくっ付ける
bool connect(int A, int B) {
A = root(A);
B = root(B);
if (A == B) {
return false;
}
if (size(A) < size(B)) swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
vector<ll,pair<ll,int>> edgh;
pair<ll,int> x[maxn];
pair<ll,int> y[maxn];
ll ans = 0;
int n;
int main(){
cin >> n;
rep(i,n){
ll px,py;
cin >> px >> py;
x[i]=make_pair(px,i);
y[i]=make_pair(py,i);
}
sort(x,x+n);
sort(y,y+n);
rep(i,n-1){
ll cost = x[i+1].first-x[i].first;
edgh.push_back(make_pair(cost,make_pair(x[i].second,x[i+1].second)));
}
rep(i,n-1){
ll cost = y[i+1].first-y[i].first;
edgh.push_back(make_pair(cost,make_pair(y[i].second,y[i+1].second)));
}
UnionFind Uni(n);
sort(all(edgh));
int cnt = 0;
int idx = 0;
while(cnt<n-1){
if(Uni.root(edgh[idx].second.first)!=Uni.root(edgh[idx].second.second)){
Uni.connect(edgh[idx].second.first,edgh[idx].second.second);
ans += edgh.first;
}
idx++;
}
cout << ans<<endl;
return 0;
}
| In file included from /usr/include/c++/14/vector:66,
from a.cc:5:
/usr/include/c++/14/bits/stl_vector.h: In instantiation of 'struct std::_Vector_base<long long int, std::pair<long long int, int> >':
/usr/include/c++/14/bits/stl_vector.h:428:11: required from 'class std::vector<long long int, std::pair<long long int, int> >'
428 | class vector : protected _Vector_base<_Tp, _Alloc>
| ^~~~~~
a.cc:64:25: required from here
64 | vector<ll,pair<ll,int>> edgh;
| ^~~~
/usr/include/c++/14/bits/stl_vector.h:87:28: error: no type named 'value_type' in 'struct std::pair<long long int, int>'
87 | rebind<_Tp>::other _Tp_alloc_type;
| ^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:89:9: error: no type named 'value_type' in 'struct std::pair<long long int, int>'
89 | pointer;
| ^~~~~~~
/usr/include/c++/14/bits/stl_vector.h: In instantiation of 'class std::vector<long long int, std::pair<long long int, int> >':
a.cc:64:25: required from here
64 | vector<ll,pair<ll,int>> edgh;
| ^~~~
/usr/include/c++/14/bits/stl_vector.h:518:20: error: '_M_allocate' has not been declared in 'std::vector<long long int, std::pair<long long int, int> >::_Base'
518 | using _Base::_M_allocate;
| ^~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:519:20: error: '_M_deallocate' has not been declared in 'std::vector<long long int, std::pair<long long int, int> >::_Base'
519 | using _Base::_M_deallocate;
| ^~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:521:20: error: '_M_get_Tp_allocator' has not been declared in 'std::vector<long long int, std::pair<long long int, int> >::_Base'
521 | using _Base::_M_get_Tp_allocator;
| ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/bits/requires_hosted.h:31,
from /usr/include/c++/14/iostream:38,
from a.cc:2:
/usr/include/c++/14/bits/stl_vector.h: In instantiation of 'std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl() [with _Tp = long long int; _Alloc = std::pair<long long int, int>]':
a.cc:64:25: required from here
64 | vector<ll,pair<ll,int>> edgh;
| ^~~~
/usr/include/c++/14/bits/stl_vector.h:136:24: error: no type named 'value_type' in 'struct std::pair<long long int, int>'
136 | _Vector_impl() _GLIBCXX_NOEXCEPT_IF(
| ^~~~~~~~~~~~~~~~~~~~
a.cc: In function 'int main()':
a.cc:85:23: error: no matching function for call to 'std::vector<long long int, std::pair<long long int, int> >::push_back(std::pair<long long int, std::pair<int, int> >)'
85 | edgh.push_back(make_pair(cost,make_pair(x[i].second,x[i+1].second)));
| ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1283:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = long long int; _Alloc = std::pair<long long int, int>; value_type = long long int]'
1283 | push_back(const value_type& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1283:35: note: no known conversion for argument 1 from 'std::pair<long long int, std::pair<int, int> >' to 'const std::vector<long long int, std::pair<long long int, int> >::value_type&' {aka 'const long long int&'}
1283 | push_back(const value_type& __x)
| ~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:1300:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(value_type&&) [with _Tp = long long int; _Alloc = std::pair<long long int, int>; value_type = long long int]'
1300 | push_back(value_type&& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1300:30: note: no known conversion for argument 1 from 'std::pair<long long int, std::pair<int, int> >' to 'std::vector<long long int, std::pair<long long int, int> >::value_type&&' {aka 'long long int&&'}
1300 | push_back(value_type&& __x)
| ~~~~~~~~~~~~~^~~
a.cc:90:23: error: no matching function for call to 'std::vector<long long int, std::pair<long long int, int> >::push_back(std::pair<long long int, std::pair<int, int> >)'
90 | edgh.push_back(make_pair(cost,make_pair(y[i].second,y[i+1].second)));
| ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1283:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = long long int; _Alloc = std::pair<long long int, int>; value_type = long long int]'
1283 | push_back(const value_type& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1283:35: note: no known conversion for argument 1 from 'std::pair<long long int, std::pair<int, int> >' to 'const std::vector<long long int, std::pair<long long int, int> >::value_type&' {aka 'const long long int&'}
1283 | push_back(const value_type& __x)
| ~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/stl_vector.h:1300:7: note: candidate: 'void std::vector<_Tp, _Alloc>::push_back(value_type&&) [with _Tp = long long int; _Alloc = std::pair<long long int, int>; value_type = long long int]'
1300 | push_back(value_type&& __x)
| ^~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:1300:30: note: no known conversion for argument 1 from 'std::pair<long long int, std::pair<int, int> >' to 'std::vector<long long int, std::pair<long long int, int> >::value_type&&' {aka 'long long int&&'}
1300 | push_back(value_type&& __x)
| ~~~~~~~~~~~~~^~~
a.cc:15:18: error: 'class std::vector<long long int, std::pair<long long int, int> >' has no member named 'begin'
15 | #define all(a) a.begin(),a.end()
| ^~~~~
a.cc:95:10: note: in expansion of macro 'all'
95 | sort(all(edgh));
| ^~~
a.cc:15:28: error: 'class std::vector<long long int, std::pair<long long int, int> >' has no member named 'end'
15 | #define all(a) a.begin(),a.end()
| ^~~
a.cc:95:10: note: in expansion of macro 'all'
95 | sort(all(edgh));
| ^~~
a.cc:100:25: error: no match for 'operator[]' (operand types are 'std::vector<long long int, std::pair<long long int, int> >' and 'int')
100 | if(Uni.root(edgh[idx].second.first)!=Uni.root(edgh[idx].second.second)){
| ^
a.cc:100:59: error: no match for 'operator[]' (operand types are 'std::vector<long long int, std::pair<long long int, int> >' and 'int')
100 | if(Uni.root(edgh[idx].second.first)!=Uni.root(edgh[idx].second.second)){
| ^
a.cc:101:29: error: no match for 'operator[]' (operand types are 'std::vector<long long int, std::pair<long long int, int> >' and 'int')
101 | Uni.connect(edgh[idx].second.first,edgh[idx].second.second);
| ^
a.cc:101:52: error: no match for 'operator[]' (operand types are 'std::vector<long long int, std::pair<long long int, int> >' and 'int')
101 | Uni.connect(edgh[idx].second.first,edgh[idx].second.second);
| ^
a.cc:102:25: error: 'class std::vector<long long int, std::pair<long long int, int> >' has no member named 'first'
102 | ans += edgh.first;
| ^~~~~
/usr/include/c++/14/bits/stl_vector.h: In instantiation of 'std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl() [with _Tp = long long int; _Alloc = std::pair<long long int, int>]':
/usr/include/c++/14/bits/stl_vector.h:314:7: required from here
314 | _Vector_base() = default;
| ^~~~~~~~~~~~
/usr/include/c++/14/bits/stl_vector.h:141:26: error: no type named 'value_type' in 'struct std::pair<long long int, int>'
141 | : _Tp_alloc_type()
| ^
|
s887584179 | p03682 | C++ | #include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define REPP(i,n) for(int i=1;i<=n;i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF=(long long)1E17;
#define i_7 (long long)(1E9+7)
long mod(long a){
long long c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
using namespace std;
int n;//頂点数
int parent[100010];//iの親parent[i]を格納する配列
int rank[100010];//iを根とする部分木の高さみたいな量?
void init(int n){
for(int i=0;i<n;i++){
parent[i]=i;
rank[i]=0;
}
}
int root(int x){
if(parent[x]==x)return x;
else return root(parent[x]);
}
void unite(int x,int y){
x=root(x);
y=root(y);
if(x==y)return ;
if(rank[x]<rank[y])parent[x]=y;
else{
parent[y]=x;
if(rank[x]==rank[y])rank[x]++;
}
}
bool same(int x,int y){
return root(x)==root(y);
}
struct edge {int u,v,cost;};
bool comp(const edge& e1,const edge& e2){
return e1.cost<e2.cost;
}
vector <edge> edges;
//vector <pair<int,int>>p1,p2;
int kruskal(){
sort(edges.begin(),edges.end(),comp);
init(n);
long long res=0;
rep(i,edges.size()){
edge e=edges[i];
if(!same(e.u,e.v)){
unite(e.u,e.v);
res += (long long)e.cost;
}
}
return res;
}
int main(){
cin>>n;
int x,y;
vector<pair<int,int>> xs,ys;
REP(i,n){
cin>>x>>y;
xs.push_back(make_pair(x,i));
ys.push_back(make_pair(y,i));
}
sort(xs.begin(),xs.end());
sort(ys.begin(),ys.end());
REP(i,n-1){
edge e;
e.u = xs[i].second;
e.v = xs[i+1].second;
e.cost = xs[i+1].first - xs[i].first;
edges.push_back(e);
}
REP(i,n-1){
edge e;
e.u = ys[i].second;
e.v = ys[i+1].second;
e.cost = ys[i+1].first - ys[i].first;
edges.push_back(e);
}
long long ans;
ans = kruskal();
cout<<ans<<endl;
return 0;
}
| a.cc: In function 'void init(int)':
a.cc:21:9: error: reference to 'rank' is ambiguous
21 | rank[i]=0;
| ^~~~
In file included from /usr/include/c++/14/bits/stl_pair.h:60,
from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:32:8: error: reference to 'rank' is ambiguous
32 | if(rank[x]<rank[y])parent[x]=y;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc:32:16: error: reference to 'rank' is ambiguous
32 | if(rank[x]<rank[y])parent[x]=y;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc:35:12: error: reference to 'rank' is ambiguous
35 | if(rank[x]==rank[y])rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc:35:21: error: reference to 'rank' is ambiguous
35 | if(rank[x]==rank[y])rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc:35:29: error: reference to 'rank' is ambiguous
35 | if(rank[x]==rank[y])rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:17:5: note: 'int rank [100010]'
17 | int rank[100010];//iを根とする部分木の高さみたいな量?
| ^~~~
a.cc: In function 'int kruskal()':
a.cc:52:9: error: 'i' was not declared in this scope
52 | rep(i,edges.size()){
| ^
a.cc:52:5: error: 'rep' was not declared in this scope; did you mean 'res'?
52 | rep(i,edges.size()){
| ^~~
| res
|
s901499326 | p03682 | C++ | #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
using namespace std;
#define REP(i,m,n) for(int i=(int)m ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
struct UnionFind{
vector<int> par;
UnionFind(int n):par(n,-1){}
int find(int x){
if(par[x]<0)return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y){
x=find(x);
y=find(y);
if(x==y)return false;
if(par[x]>par[y]){
par[y]+=par[x];
par[x]=y;
}
else{
par[x]+=par[y];
par[y]=x;
}
return true;
}
bool same(int x,int y){
return find(x)==find(y);
}
int size(int x){
return -par[find(x)];
}
};
struct edge{int u,v,cost;};
bool comp(const edge& e1, const edge& e2){
return e1.cost<e2.cost;
}
edge es[100010];
int V;
ll E;
int kruskal(){
sort(es, es+E, comp);
UnionFind uf(V);
int res=0;
for(int i=0;i<E;i++){
edge e=es[i];
if(!uf.same(e.u, e.v)){
uf.unite(e.u, e.v);
res+=e.cost;
}
}
return res;
}
int main(){
cin >> V;
E=2*(V-1);
pint x[V],y[V];
rep(i,V){
cin >> x[i].first >> y[i].first;
x[i].second=i;
y[i].second=i;
y[i].first--,x[i].first--;
}
sort(x,x+V);
sort(y,y+V);
rep(i,V-1){
es[2*i]={x[i].second,x[i+1].second,x[i+1].first-x[i].first};
es[2*i+1]={y[i].second,y[i+1].second,y[i+1].first-y[i].first};
}
int ans=0;
// ans=kruskal();
cout << ans << endl; | a.cc: In function 'int main()':
a.cc:94:23: error: expected '}' at end of input
94 | cout << ans << endl;
| ^
a.cc:76:11: note: to match this '{'
76 | int main(){
| ^
|
s960562051 | p03682 | C++ | #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
using namespace std;
#define REP(i,m,n) for(int i=(int)m ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
struct UnionFind{
vector<int> par;
UnionFind(int n):par(n,-1){}
int find(int x){
if(par[x]<0)return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y){
x=find(x);
y=find(y);
if(x==y)return false;
if(par[x]>par[y]){
par[y]+=par[x];
par[x]=y;
}
else{
par[x]+=par[y];
par[y]=x;
}
return true;
}
bool same(int x,int y){
return find(x)==find(y);
}
int size(int x){
return -par[find(x)];
}
};
struct edge{int u,v,cost;};
bool comp(const edge& e1, const edge& e2){
return e1.cost<e2.cost;
}
edge es[100010];
int V;
ll E;
int kruskal(){
sort(es, es+E, comp);
UnionFind uf(V);
int res=0;
for(int i=0;i<E;i++){
edge e=es[i];
if(!uf.same(e.u, e.v)){
uf.unite(e.u, e.v);
res+=e.cost;
}
}
return res;
}
int main(){
cin >> V;
E=2*(V-1);
pint x[V],y[V];
rep(i,V){
cin >> x[i].first >> y[i].first;
x[i].second=i;
y[i].second=i;
y[i].first--,x[i].first--;
}
sort(x,x+V);
sort(y,y+V);
rep(i,V-1){
es[2*i]={x[i].second,x[i+1].second,x[i+1].first-x[i].first};
es[2*i+1]={y[i].second,y[i+1].second,y[i+1].first-y[i].first};
}
// int ans=kruskal();
cout << ans << endl;
return 0;} | a.cc: In function 'int main()':
a.cc:93:11: error: 'ans' was not declared in this scope; did you mean 'abs'?
93 | cout << ans << endl;
| ^~~
| abs
|
s180704595 | p03682 | C++ | #include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
struct UnionFind() {
vector<int> par;
UnionFind(itn n) : par(n, -1) {}
int root(int x) {
if(par[x] < 0)
return 0;
else
return par[x] = root(par[x]);
}
int issame(int x, int y) { return root(x) == root(y); }
void merge(int x, int y) {
x = root(x);
y = root(y);
if(x == y)
return;
if(-par[x] < -par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
}
};
// http://drken1215.hatenablog.com/entry/2019/02/14/124300
int main() {
int N;
cin >> N;
vector<long long> x(N), y(N);
for(int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
}
using pint = pair<int, int>;
using Edge = pair<long long, pint>;
vecto<Edge> edges;
// x軸にソートして隣接している部分のみ
vector<int> ids(N);
iota(ids.begin(), ids.end(), 0);
sort(ids.begin(), ids.end(), [&](int i, int j) { return x[i] < x[k]; });
for(int i = 0; i < ids.size() - 1; i++) {
int u = ids[i];
int v = ids[i + 1];
edges.push_back(Edge(x[v] - x[u], pint(u, v)));
}
sort(ids.begin(), ids.end(), [&](int i, int j) { return y[i] < y[j]; });
for(int i = 0; i + 1 < ids.size(); ++i) {
int u = ids[i], v = ids[i + 1];
edges.push_back(Edge(y[v] - y[u], pint(u, v)));
}
//ここまでで辺を作る
sort(edges.begin(), edge.end());
UnionFind uf(N);
long long res = 0;
for(auto e : edges) {
int u = e.second.first;
int v = e.second.second;
long long cost = e.first;
if(uf.issame(u, v))
continue;
uf.merge(u, v);
res += cost;
}
cout << res << endl;
} | a.cc:7:18: error: expected unqualified-id before ')' token
7 | struct UnionFind() {
| ^
a.cc: In function 'int main()':
a.cc:38:5: error: 'vecto' was not declared in this scope
38 | vecto<Edge> edges;
| ^~~~~
a.cc:38:15: error: expected primary-expression before '>' token
38 | vecto<Edge> edges;
| ^
a.cc:38:17: error: 'edges' was not declared in this scope
38 | vecto<Edge> edges;
| ^~~~~
a.cc: In lambda function:
a.cc:42:70: error: 'k' was not declared in this scope
42 | sort(ids.begin(), ids.end(), [&](int i, int j) { return x[i] < x[k]; });
| ^
a.cc: In function 'int main()':
a.cc:54:25: error: 'edge' was not declared in this scope; did you mean 'Edge'?
54 | sort(edges.begin(), edge.end());
| ^~~~
| Edge
a.cc:55:19: error: variable 'UnionFind uf' has initializer but incomplete type
55 | UnionFind uf(N);
| ^
|
s010943646 | p03682 | C++ | #include <bits/stdc++.h>
#define REP(i, n) for(ll i = 0; i < (ll)n; i++)
#define FOR(i, a, b) for(ll i = (a); i < (ll)b; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1000000000000000
using namespace std;
typedef long long ll;
typedef double db;
typedef string str;
typedef pair<ll, ll> p;
constexpr int MOD = 1000000007;
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
void print(const std::vector<int> &v) {
std::for_each(v.begin(), v.end(), [](int x) { std::cout << x << " "; });
std::cout << std::endl;
}
#define MAX_V 100010
long long cost[MAX_V][MAX_V]; // e=(u,v)のコスト
long long mincost[MAX_V]; //集合Xからの辺の最小コスト
bool used[MAX_V]; //頂点iがXに含まれているか
int V; //頂点数
int prim() {
for(int i = 0; i < V; i++) {
mincost[i] = INF;
used[i] = false;
}
mincost[0] = 0;
int res = 0;
while(true) {
int v = -1;
for(int u = 0; u < V; u++) {
if(!used[u] and (v == -1 || mincost[u] < mincost[v])) {
v = u;
}
}
if(v == -1) {
break;
}
used[v] = true;
res += mincost[v];
for(int u = 0; u < V; u++) {
mincost[u] = min(mincost[u], cost[v][u]);
}
}
return res;
}
int main() {
cin >> V;
int N = V;
vector<long long> x(N), y(N);
REP(i, N) { cin >> x[i] >> y[i]; }
for(int i = 0; i < N; i++) {
for(int j = i + 1; j < N; j++) {
long long tmp = abs(x[i] - x[j]) + abs(y[i] - y[j]);
cost[i][j] = tmp;
cost[j][i] = tmp;
}
cost[i][i] = 0;
}
cout << prim() << endl;
} | /tmp/cc134FFr.o: in function `prim()':
a.cc:(.text+0xaf): relocation truncated to fit: R_X86_64_PC32 against symbol `mincost' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0xc9): relocation truncated to fit: R_X86_64_PC32 against symbol `used' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0xd7): relocation truncated to fit: R_X86_64_PC32 against symbol `V' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0xe3): relocation truncated to fit: R_X86_64_PC32 against symbol `mincost' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x10a): relocation truncated to fit: R_X86_64_PC32 against symbol `used' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x12f): relocation truncated to fit: R_X86_64_PC32 against symbol `mincost' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x147): relocation truncated to fit: R_X86_64_PC32 against symbol `mincost' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x160): relocation truncated to fit: R_X86_64_PC32 against symbol `V' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x17b): relocation truncated to fit: R_X86_64_PC32 against symbol `used' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x193): relocation truncated to fit: R_X86_64_PC32 against symbol `mincost' defined in .bss section in /tmp/cc134FFr.o
a.cc:(.text+0x1e5): additional relocation overflows omitted from the output
collect2: error: ld returned 1 exit status
|
s763388602 | p03682 | C++ | #include <iostream>
#include <algorithm>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n; // 要素数
cin >> n;
int* x = new int[n];
int* y = new int[n];
int* q = new int[n] {0}; // 道が出来たか
for (int i = 0; i < n; i++)
{
cin >> x[i] >> y[i];
}
int money = 0;
int index = 0;
for (int i = 0; i < n; i++)
{
if (q[i] <= 0)
{
long min = -1;
int another;
for (int j = 0; j < n; j++)
{
if (i != j)
{
long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
if (min < 0 || min > road)
{
min = road;
another = j;
if (min == 0)
break;
}
}
}
if (q[another] > 0)
{
q[i] = q[another];
}
else
{
index++;
q[i] = index;
q[another] = index;
}
money += min;
}
}
while (index > 1)
{
index = 1;
int one = q[0];
long min = -1;
int another;
for (int i = 0; i < n; i++)
{
if (q[i] != one) continue;
for (int j = 0; j < n; j++)
{
if (one == q[j]) continue;
long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
if (min < 0 || min > road)
{
min = road;
another = j;
if (min == 0)
break;
}
}
if (min == 0)
break;
}
if (min >= 0)
{
index = q[another];
int index2 = 1;
for (int j = 0; j < n; j++)
{
if (q[j] == index)
q[j] = one;
else if (q[j] != one)
index2 = q[j];
}
index = index2;
money += min;
}
}
cout << money << '\n';
delete[] x;
delete[] y;
return 0;
}
/*
6
1 8 3
1 4 9
2 12 19
1 18 1
2 13 5
1 7 6
N 3
x y
1 5
3 9
7 8
*/ | a.cc: In function 'int main()':
a.cc:33:59: error: 'fabsl' was not declared in this scope
33 | long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
| ^~~~~
a.cc:33:53: error: 'fminl' was not declared in this scope; did you mean 'min'?
33 | long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
| ^~~~~
| min
a.cc:69:51: error: 'fabsl' was not declared in this scope
69 | long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
| ^~~~~
a.cc:69:45: error: 'fminl' was not declared in this scope; did you mean 'min'?
69 | long road = fminl(fabsl(x[i] - x[j]), fabsl(y[i] - y[j]));
| ^~~~~
| min
|
s565997787 | p03682 | C++ | #include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
typedef long long ll;
const ll INF=1E9+10;
const ll MAXN=1e5+10;
using namespace std;
int par[2*MAXN];
struct NODE{
ll len,a,b;
}node[2*MAXN];
struct NO{
ll sit,order;
}x[MAXN],y[MAXN];
ll rank[MAXN];
bool cmp1(NO i,NO j){
return i.sit<j.sit;
}
bool cmp2(NODE h,NODE k){
return h.len<k.len;
}
void init(int v){//初始化集合
for(int i=1;i<=v;i++){
rank[i]=i;//最开始第i个顶点的集合是他自己
}
}
void unit(ll a,ll b){//合并集合
rank[a]=b;//a的前驱改为b
}
ll find(ll a){//寻找根节点
if(rank[a]==a) return a;
else return find(rank[a]);
}
ll Kruskal(ll ver,ll edge){//顶点数量、边数
ll tot=0,e=0;//目前的权值和已加入的边数
for(int i=1;i<=edge&&e<ver-1;i++){
ll h=find(node[i].a);
ll k=find(node[i].b);
if(h!=k){//如果这两个点不在同一个集合中，说明可以加入这条边
tot+=node[i].len;//增加权值
e++;//增加边数
unit(h,k); //合并这两个点到同一个集合
}
}
return tot;
}
int main() {
ll n;
scanf("%lld",&n);
for(int i=1;i<=n;i++){
cin>>x[i].sit>>y[i].sit;
x[i].order=i;
y[i].order=i;
}
sort(x+1,x+n+1,cmp1);
sort(y+1,y+n+1,cmp1);
//一共有2*n-2条边从 1到2*n-2
for(int i=1;i<n;i++){
node[i].len=x[i+1].sit-x[i].sit;
node[i].a=x[i+1].order;node[i].b=x[i].order;
node[i+n-1].len=y[i+1].sit-y[i].sit;
node[i+n-1].a=y[i+1].order;node[i+n-1].b=y[i].order;
}
sort(node+1,node+2*n-1,cmp2);
//克鲁斯卡尔算法
init(n);
ll ans=Kruskal(n,2*n-2);//顶点数量、边数
cout<<ans<<endl;
return 0;
} | a.cc: In function 'void init(int)':
a.cc:33:17: error: reference to 'rank' is ambiguous
33 | rank[i]=i;//最开始第i个顶点的集合是他自己
| ^~~~
In file included from /usr/include/c++/14/bits/move.h:37,
from /usr/include/c++/14/bits/exception_ptr.h:41,
from /usr/include/c++/14/exception:166,
from /usr/include/c++/14/ios:41,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:2:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:22:4: note: 'll rank [100010]'
22 | ll rank[MAXN];
| ^~~~
a.cc: In function 'void unit(ll, ll)':
a.cc:37:9: error: reference to 'rank' is ambiguous
37 | rank[a]=b;//a的前驱改为b
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:22:4: note: 'll rank [100010]'
22 | ll rank[MAXN];
| ^~~~
a.cc: In function 'll find(ll)':
a.cc:41:12: error: reference to 'rank' is ambiguous
41 | if(rank[a]==a) return a;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:22:4: note: 'll rank [100010]'
22 | ll rank[MAXN];
| ^~~~
a.cc:42:26: error: reference to 'rank' is ambiguous
42 | else return find(rank[a]);
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:22:4: note: 'll rank [100010]'
22 | ll rank[MAXN];
| ^~~~
|
s400530149 | p03682 | C++ | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int MAXN = 100010;
int n;
struct location {
ll x, y;
int pos;
};
struct edge {
int from, to;
ll cost;
};
location loc[MAXN];
bool xcompare(location a, location b) {
return a.x < b.x;
}
bool ycompare(location a, location b) {
return a.y < b.y;
}
bool edgecompare(edge a, edge b) {
return a.cost < b.cost;
}
int par[MAXN];
int rank_[MAXN];
int size[MAXN];
void init() {
for (int i=0;i<n;i++) {
par[i] = i;
rank_[i] = 0;
size[i] = 1;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rank_[x] < rank_[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
if (rank_[x] == rank_[y]) {
rank_[x]++;
}
size[x] += size[y];
}
}
void solve() {
vector<edge> edges;
init();
sort(loc, loc + n, xcompare);
for (int i=0;i<n-1;i++) {
edges.push_back((edge){loc[i].pos, loc[i+1].pos, min(abs(loc[i].x - loc[i+1].x), abs(loc[i].y - loc[i+1].y))});
}
sort(loc, loc + n, ycompare);
for (int i=0;i<n-1;i++) {
edges.push_back((edge){loc[i].pos, loc[i+1].pos, min(abs(loc[i].x - loc[i+1].x), abs(loc[i].y - loc[i+1].y))});
}
sort(edges.begin(), edges.end(), edgecompare);
int remain = n;
ll cost = 0;
for (int i=0;i<edges.size();i++) {
if (!same(edges[i].from, edges[i].to)) {
cost += edges[i].cost;
unite(edges[i].from, edges[i].to);
}
}
cout << cost << endl;
}
int main() {
cin >> n;
ll x, y;
for (int i=0;i<n;i++) {
cin >> x >> y;
loc[i].x = x;
loc[i].y = y;
loc[i].pos = i;
}
solve();
}
| a.cc: In function 'void init()':
a.cc:40:7: error: reference to 'size' is ambiguous
40 | size[i] = 1;
| ^~~~
In file included from /usr/include/c++/14/string:53,
from /usr/include/c++/14/bits/locale_classes.h:40,
from /usr/include/c++/14/bits/ios_base.h:41,
from /usr/include/c++/14/ios:44,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:34:5: note: 'int size [100010]'
34 | int size[MAXN];
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:65:5: error: reference to 'size' is ambiguous
65 | size[y] += size[x];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:34:5: note: 'int size [100010]'
34 | int size[MAXN];
| ^~~~
a.cc:65:16: error: reference to 'size' is ambiguous
65 | size[y] += size[x];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:34:5: note: 'int size [100010]'
34 | int size[MAXN];
| ^~~~
a.cc:71:5: error: reference to 'size' is ambiguous
71 | size[x] += size[y];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:34:5: note: 'int size [100010]'
34 | int size[MAXN];
| ^~~~
a.cc:71:16: error: reference to 'size' is ambiguous
71 | size[x] += size[y];
| ^~~~
/usr/include/c++/14/bits/range_access.h:272:5: note: candidates are: 'template<class _Tp, long unsigned int _Nm> constexpr std::size_t std::size(const _Tp (&)[_Nm])'
272 | size(const _Tp (&)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:262:5: note: 'template<class _Container> constexpr decltype (__cont.size()) std::size(const _Container&)'
262 | size(const _Container& __cont) noexcept(noexcept(__cont.size()))
| ^~~~
a.cc:34:5: note: 'int size [100010]'
34 | int size[MAXN];
| ^~~~
a.cc: In function 'void solve()':
a.cc:79:3: error: 'sort' was not declared in this scope; did you mean 'short'?
79 | sort(loc, loc + n, xcompare);
| ^~~~
| short
|
s079274367 | p03682 | C++ | #include <bits/stdc++.h>
#define FOR(i, a, b) for(int i=(a); i<(b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define bit(x) (1L << (x))
using ll = long long;
using namespace std;
template<typename T>
vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
template<typename... Ts>
auto make_v(size_t a,Ts... ts){
return vector<decltype(make_v(ts...))>(a,make_v(ts...));
}
class union_find{
int n_;
vector<int> par, rank, size;
public:
union_find(int n): n_{n} {
par.resize(n_);
rank.resize(n_);
size.resize(n_);
REP(i, n_){
par[i] = i;
rank[i] = 1;
size[i] = 1;
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] > rank[y]){
par[y] = x;
size[x] += size[y];
} else {
par[x] = y;
size[y] += size[x];
if(rank[x] == rank[y]) rank[y]++;
}
}
int find(int x) {
if(par[x] == x) return x;
else return par[x] = find(par[x]);
}
vector<int> get_par(){ return par; }
};
struct edge{ int u, v; ll w; };
ll kruskal(int n, vector<edge> edges) {
sort(edges.begin(), edges.end(), [](const edge& e1, const edge& e2){
return e1.w < e2.w;
});
union_find uf(n);
ll ret = 0;
for(const auto& edge: edges){
if(!uf.same(edge.u, edge.v)){
uf.unite(edge.u, edge.v);
ret += edge.w;
}
}
return ret;
}
struct node{ int v; ll x, y; };
int main() {
int n; cin >> n vector<node> p(n), q(n);
REP(i, n){
ll x, y; cin >> x >> y;
p[i] = {i, x, y};
q[i] = {i, y, x};
}
vector<edge> edges;
function<void(vector<node>&)> addEdge = [&](vector<node>& v){
sort(v.begin(), v.end(), [](node& a, node& b){
return a.x < b.x;
});
REP(i, n-1){
ll dx = abs(v[i].x - v[i+1].x), dy = abs(v[i].y - v[i+1].y);
edges.push_back({v[i].v, v[i+1].v, min(dx, dy)});
}
};
addEdge(p);
addEdge(q);
cout << kruskal(n, edges) << endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:84:18: error: expected ';' before 'vector'
84 | int n; cin >> n vector<node> p(n), q(n);
| ^ ~~~~~~
| ;
a.cc:87:5: error: 'p' was not declared in this scope
87 | p[i] = {i, x, y};
| ^
a.cc:88:5: error: 'q' was not declared in this scope
88 | q[i] = {i, y, x};
| ^
a.cc:104:11: error: 'p' was not declared in this scope
104 | addEdge(p);
| ^
a.cc:105:11: error: 'q' was not declared in this scope
105 | addEdge(q);
| ^
|
s161620103 | p03682 | C++ | #include <iostream>
#include <vector>
#include <numeric>
using namespace std;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
void merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return;
if (-par[x] < -par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
}
};
int main() {
int N; cin >> N;
vector<long long> x(N), y(N);
for (int i = 0; i < N; ++i) cin >> x[i] >> y[i];
// Kruskal 法に使う枝 (絞られたもの)
using pint = pair<int,int>;
using Edge = pair<long long, pint>;
vector<Edge> edges;
// x 軸方向について隣接二点のみ
vector<int> ids(N);
iota(ids.begin(), ids.end(), 0);
sort(ids.begin(), ids.end(), [&](int i, int j) { return x[i] < x[j]; });
for (int i = 0; i+1 < ids.size(); ++i) {
int u = ids[i], v = ids[i+1];
edges.push_back(Edge(x[v] - x[u], pint(u, v)));
}
// y 軸方向について隣接二点のみ
sort(ids.begin(), ids.end(), [&](int i, int j) { return y[i] < y[j]; });
for (int i = 0; i+1 < ids.size(); ++i) {
int u = ids[i], v = ids[i+1];
edges.push_back(Edge(y[v] - y[u], pint(u, v)));
}
// Kruskal 法
sort(edges.begin(), edges.end());
UnionFind uf(N);
long long res = 0;
for (auto e : edges) {
int u = e.second.first, v = e.second.second;
long long cost = e.first;
if (uf.issame(u, v)) continue;
uf.merge(u, v);
res += cost;
}
cout << res << endl;
}
| a.cc: In function 'int main()':
a.cc:38:5: error: 'sort' was not declared in this scope; did you mean 'short'?
38 | sort(ids.begin(), ids.end(), [&](int i, int j) { return x[i] < x[j]; });
| ^~~~
| short
|
s261099675 | p03682 | C | N = input()
data = [map(int,raw_input().split()) for i in range(N)]
def hoge(x,y):
return x[1]-y[1]
data.sort()
for i in range(1,N-1):
data[i].append(min(data[i+1][0]-data[i][0],data[i][0]-data[i-1][0]))
data[0].append(data[1][0]-data[0][0])
data[N-1].append(data[N-1][0]-data[N-2][0])
data.sort(hoge)
for i in range(1,N-1):
data[i].append(min(data[i+1][1]-data[i][1],data[i][1]-data[i-1][1]))
data[0].append(data[1][1]-data[0][1])
data[N-1].append(data[N-1][1]-data[N-2][1])
ans = 0
minimam = 10000000000
for i in range(N):
ans += min(data[i][2],data[i][3])
minimam = min(minimam,min(data[i][2],data[i][3]))
print ans-minimam | main.c:1:1: warning: data definition has no type or storage class
1 | N = input()
| ^
main.c:1:1: error: type defaults to 'int' in declaration of 'N' [-Wimplicit-int]
main.c:1:5: error: implicit declaration of function 'input' [-Wimplicit-function-declaration]
1 | N = input()
| ^~~~~
main.c:1:5: error: initializer element is not constant
main.c:3:1: error: expected ',' or ';' before 'data'
3 | data = [map(int,raw_input().split()) for i in range(N)]
| ^~~~
|
s144695254 | p03682 | C++ | #pragma GCC optimize ("O3")
#include <iostream>
#include <cstddef>
#include <numeric>
#include <algorithm>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <queue>
using namespace std;
using QWORD = unsigned long long;
using SQWORD = long long;
using DWORD = unsigned int;
using SDWORD = int;
using WORD = unsigned short;
using SWORD = short;
using BYTE = unsigned char;
using SBYTE = char;
using DOUBLE = double;
using FLOAT = float;
#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)
#define MAX_QWORD (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD (0xFFFFFFFF)
#define MAX_WORD (0xFFFF)
#define MAX_BYTE (0xFF)
#define ArrayLength(a) (sizeof(a) / sizeof(a[0]))
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
#define BYTE_BITS (8)
#define WORD_BITS (16)
#define DWORD_BITS (32)
#define QWORD_BITS (64)
using M_BOOL = bool;
#define M_TRUE (true)
#define M_FALSE (false)
#define DIVISOR (1000000007)
static inline void inputString(char *pcStr)
{
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline SDWORD inputSDWORD(void)
{
SDWORD lNumber = 0;
M_BOOL bRead = M_FALSE;
for (;;) {
char c = getchar();
if (('0' <= c) && (c <= '9')) {
lNumber *= 10;
lNumber += (c - '0');
bRead = M_TRUE;
} else {
if (bRead) {
return lNumber;
}
}
}
}
#define MAX_CITY_NUM (100000)
#define CITY_ARY_LEN (MAX_CITY_NUM)
static DWORD s_adwCityPosX[CITY_ARY_LEN];
static DWORD s_adwCityPosY[CITY_ARY_LEN];
/* インデックス付きソート */
typedef std::pair<DWORD,DWORD> ipair;
bool lessPair(const ipair& l, const ipair& r){return l.second < r.second;}
bool greaterPair(const ipair& l, const ipair& r){return l.second > r.second;}
static void sort_with_idx(vector<ipair> &y)
{
sort(y.begin(), y.end(), lessPair);
}
#define DIST_INF (MAX_DWORD)
// ">" のオーバーロード numを基準に大小比較を行う
class dist_info {
public:
DWORD dwDist;
DWORD dwIdx;
dist_info(DWORD dwDist, DWORD dwIdx) {
this->dwDist = dwDist;
this->dwIdx = dwIdx;
}
};
bool operator> (const dist_info &dist1, const dist_info &dist2){
return dist1.dwDist > dist2.dwDist;
};
typedef priority_queue<dist_info, vector<dist_info>,
std::greater<dist_info> > pqDistInfo;
static DWORD add_neighbor_dist(
vector<ipair> poslist,
DWORD *pdwIdxList,
DWORD dwIdx,
pqDistInfo &mincost)
{
DWORD dwVectorIdx = *(pdwIdxList + dwIdx);
// printf("vector idx : %d\n", dwVectorIdx);
if (0 == dwVectorIdx) {
DWORD dwDist = poslist[dwVectorIdx + 1].second - poslist[dwVectorIdx].second;
// printf("add to cost[0] > %d %d\n", dwDist, poslist[dwVectorIdx + 1].first);
mincost.push(dist_info(dwDist, poslist[dwVectorIdx + 1].first));
} else if (poslist.size() - 1 == dwVectorIdx) {
DWORD dwDist = poslist[dwVectorIdx].second - poslist[dwVectorIdx - 1].second;
// printf("add to cost[1] > %d %d\n", dwDist, poslist[dwVectorIdx - 1].first);
mincost.push(dist_info(dwDist, poslist[dwVectorIdx - 1].first));
} else {
DWORD dwDist1 = poslist[dwVectorIdx + 1].second - poslist[dwVectorIdx].second;
DWORD dwDist2 = poslist[dwVectorIdx].second - poslist[dwVectorIdx - 1].second;
// printf("add to cost[2] > %d %d\n", dwDist1, poslist[dwVectorIdx + 1].first);
// printf("add to cost[2] > %d %d\n", dwDist2, poslist[dwVectorIdx - 1].first);
mincost.push(dist_info(dwDist1, poslist[dwVectorIdx + 1].first));
mincost.push(dist_info(dwDist2, poslist[dwVectorIdx - 1].first));
}
}
static void add_node_to_network(
DWORD dwNodeIdx,
vector<ipair> &xpos,
vector<ipair> &ypos,
M_BOOL *pbIsUsed,
DWORD *pdwIdxListX,
DWORD *pdwIdxListY,
pqDistInfo &mincost)
{
*(pbIsUsed + dwNodeIdx) = M_TRUE;
DWORD dwDistX = add_neighbor_dist(xpos, pdwIdxListX, dwNodeIdx, mincost);
DWORD dwDistY = add_neighbor_dist(ypos, pdwIdxListY, dwNodeIdx, mincost);
}
int main()
{
DWORD dwInput_N;
dwInput_N = inputSDWORD();
//インデックスと共にペアに突っ込む
vector<ipair> xpos;
vector<ipair> ypos;
DWORD adwIdxListX[MAX_CITY_NUM];
DWORD adwIdxListY[MAX_CITY_NUM];
for (DWORD dwIdx = 0; dwIdx < dwInput_N; dwIdx++) {
DWORD dwInput_x = inputSDWORD();
DWORD dwInput_y = inputSDWORD();
xpos.push_back(ipair(dwIdx, dwInput_x));
ypos.push_back(ipair(dwIdx, dwInput_y));
}
sort_with_idx(xpos);
sort_with_idx(ypos);
for (DWORD dwIdx = 0; dwIdx < dwInput_N; dwIdx++) {
// printf("idx list x : [%d] > val[%d]\n", xpos[dwIdx].first, dwIdx);
// printf("idx list y : [%d] > val[%d]\n", ypos[dwIdx].first, dwIdx);
adwIdxListX[xpos[dwIdx].first] = dwIdx;
adwIdxListY[ypos[dwIdx].first] = dwIdx;
}
/* Initialize */
M_BOOL abIsUsed[MAX_CITY_NUM];
for (DWORD dwIdx = 0; dwIdx < ArrayLength(abIsUsed); dwIdx++) {
abIsUsed[dwIdx] = M_FALSE;
}
#if 0
pqDistInfo mincost;
/* 頂点0だけを登録 */
add_node_to_network(0, xpos, ypos, abIsUsed, adwIdxListX, adwIdxListY, mincost);
DWORD dwTotalCost = 0;
DWORD dwTotalNodeNum = 1;
while (1) {
dist_info new_node = mincost.top();
mincost.pop();
if (!abIsUsed[new_node.dwIdx]) {
add_node_to_network(new_node.dwIdx, xpos, ypos, abIsUsed, adwIdxListX, adwIdxListY, mincost);
dwTotalCost += new_node.dwDist;
dwTotalNodeNum++;
if (dwTotalNodeNum == dwInput_N) {
break;
}
}
}
#endif
printf("%d\n", dwTotalCost);
}
| a.cc: In function 'DWORD add_neighbor_dist(std::vector<std::pair<unsigned int, unsigned int> >, DWORD*, DWORD, pqDistInfo&)':
a.cc:157:1: warning: no return statement in function returning non-void [-Wreturn-type]
157 | }
| ^
a.cc: In function 'int main()':
a.cc:229:20: error: 'dwTotalCost' was not declared in this scope
229 | printf("%d\n", dwTotalCost);
| ^~~~~~~~~~~
|
s597839202 | p03682 | C++ | #pragma GCC optimize ("O3")
#include <iostream>
#include <cstddef>
#include <numeric>
#include <algorithm>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <queue>
using namespace std;
using QWORD = unsigned long long;
using SQWORD = long long;
using DWORD = unsigned int;
using SDWORD = int;
using WORD = unsigned short;
using SWORD = short;
using BYTE = unsigned char;
using SBYTE = char;
using DOUBLE = double;
using FLOAT = float;
#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)
#define MAX_QWORD (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD (0xFFFFFFFF)
#define MAX_WORD (0xFFFF)
#define MAX_BYTE (0xFF)
#define ArrayLength(a) (sizeof(a) / sizeof(a[0]))
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
#define BYTE_BITS (8)
#define WORD_BITS (16)
#define DWORD_BITS (32)
#define QWORD_BITS (64)
using M_BOOL = bool;
#define M_TRUE (true)
#define M_FALSE (false)
#define DIVISOR (1000000007)
static inline void inputString(char *pcStr)
{
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline SDWORD inputSDWORD(void)
{
SDWORD lNumber = 0;
M_BOOL bRead = M_FALSE;
for (;;) {
char c = getchar();
if (('0' <= c) && (c <= '9')) {
lNumber *= 10;
lNumber += (c - '0');
bRead = M_TRUE;
} else {
if (bRead) {
return lNumber;
}
}
}
}
#define MAX_CITY_NUM (100000)
#define CITY_ARY_LEN (MAX_CITY_NUM)
static DWORD s_adwCityPosX[CITY_ARY_LEN];
static DWORD s_adwCityPosY[CITY_ARY_LEN];
/* インデックス付きソート */
typedef std::pair<DWORD,DWORD> ipair;
bool lessPair(const ipair& l, const ipair& r){return l.second < r.second;}
bool greaterPair(const ipair& l, const ipair& r){return l.second > r.second;}
static void sort_with_idx(vector<ipair> &y)
{
sort(y.begin(), y.end(), lessPair);
}
#define DIST_INF (MAX_DWORD)
// ">" のオーバーロード numを基準に大小比較を行う
class dist_info {
public:
DWORD dwDist;
DWORD dwIdx;
dist_info(DWORD dwDist, DWORD dwIdx) {
this->dwDist = dwDist;
this->dwIdx = dwIdx;
}
};
bool operator> (const dist_info &dist1, const dist_info &dist2){
return dist1.dwDist > dist2.dwDist;
};
typedef priority_queue<dist_info, vector<dist_info>,
std::greater<dist_info> > pqDistInfo;
static DWORD add_neighbor_dist(
vector<ipair> poslist,
DWORD *pdwIdxList,
DWORD dwIdx,
pqDistInfo &mincost)
{
DWORD dwVectorIdx = *(pdwIdxList + dwIdx);
// printf("vector idx : %d\n", dwVectorIdx);
if (0 == dwVectorIdx) {
DWORD dwDist = poslist[dwVectorIdx + 1].second - poslist[dwVectorIdx].second;
// printf("add to cost[0] > %d %d\n", dwDist, poslist[dwVectorIdx + 1].first);
mincost.push(dist_info(dwDist, poslist[dwVectorIdx + 1].first));
} else if (poslist.size() - 1 == dwVectorIdx) {
DWORD dwDist = poslist[dwVectorIdx].second - poslist[dwVectorIdx - 1].second;
// printf("add to cost[1] > %d %d\n", dwDist, poslist[dwVectorIdx - 1].first);
mincost.push(dist_info(dwDist, poslist[dwVectorIdx - 1].first));
} else {
DWORD dwDist1 = poslist[dwVectorIdx + 1].second - poslist[dwVectorIdx].second;
DWORD dwDist2 = poslist[dwVectorIdx].second - poslist[dwVectorIdx - 1].second;
// printf("add to cost[2] > %d %d\n", dwDist1, poslist[dwVectorIdx + 1].first);
// printf("add to cost[2] > %d %d\n", dwDist2, poslist[dwVectorIdx - 1].first);
mincost.push(dist_info(dwDist1, poslist[dwVectorIdx + 1].first));
mincost.push(dist_info(dwDist2, poslist[dwVectorIdx - 1].first));
}
}
static void add_node_to_network(
DWORD dwNodeIdx,
vector<ipair> &xpos,
vector<ipair> &ypos,
M_BOOL *pbIsUsed,
DWORD *pdwIdxListX,
DWORD *pdwIdxListY,
pqDistInfo &mincost)
{
*(pbIsUsed + dwNodeIdx) = M_TRUE;
DWORD dwDistX = add_neighbor_dist(xpos, pdwIdxListX, dwNodeIdx, mincost);
DWORD dwDistY = add_neighbor_dist(ypos, pdwIdxListY, dwNodeIdx, mincost);
}
int main()
{
DWORD dwInput_N;
dwInput_N = inputSDWORD();
//インデックスと共にペアに突っ込む
vector<ipair> xpos;
vector<ipair> ypos;
DWORD adwIdxListX[MAX_CITY_NUM];
DWORD adwIdxListY[MAX_CITY_NUM];
for (DWORD dwIdx = 0; dwIdx < dwInput_N; dwIdx++) {
DWORD dwInput_x = inputSDWORD();
DWORD dwInput_y = inputSDWORD();
xpos.push_back(ipair(dwIdx, dwInput_x));
ypos.push_back(ipair(dwIdx, dwInput_y));
}
sort_with_idx(xpos);
sort_with_idx(ypos);
for (DWORD dwIdx = 0; dwIdx < dwInput_N; dwIdx++) {
// printf("idx list x : [%d] > val[%d]\n", xpos[dwIdx].first, dwIdx);
// printf("idx list y : [%d] > val[%d]\n", ypos[dwIdx].first, dwIdx);
adwIdxListX[xpos[dwIdx].first] = dwIdx;
adwIdxListY[ypos[dwIdx].first] = dwIdx;
}
/* Initialize */
M_BOOL abIsUsed[MAX_CITY_NUM];
for (DWORD dwIdx = 0; dwIdx < ArrayLength(abIsUsed); dwIdx++) {
abIsUsed[dwIdx] = M_FALSE;
}
#if 0
pqDistInfo mincost;
/* 頂点0だけを登録 */
add_node_to_network(0, xpos, ypos, abIsUsed, adwIdxListX, adwIdxListY, mincost);
DWORD dwTotalCost = 0;
DWORD dwTotalNodeNum = 1;
while (1) {
dist_info new_node = mincost.top();
mincost.pop();
if (!abIsUsed[new_node.dwIdx]) {
add_node_to_network(new_node.dwIdx, xpos, ypos, abIsUsed, adwIdxListX, adwIdxListY, mincost);
dwTotalCost += new_node.dwDist;
dwTotalNodeNum++;
if (dwTotalNodeNum == dwInput_N) {
break;
}
}
}
#endif
printf("%d\n", dwTotalCost);
}
| a.cc: In function 'DWORD add_neighbor_dist(std::vector<std::pair<unsigned int, unsigned int> >, DWORD*, DWORD, pqDistInfo&)':
a.cc:157:1: warning: no return statement in function returning non-void [-Wreturn-type]
157 | }
| ^
a.cc: In function 'int main()':
a.cc:229:20: error: 'dwTotalCost' was not declared in this scope
229 | printf("%d\n", dwTotalCost);
| ^~~~~~~~~~~
|
s136168899 | p03682 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <map>
#include <stack>
#include <queue>
#include <set>
#include <cstring>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for(int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for(int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int> >
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
const int MAX_V = 1e5;
const int MAX_N = 1e5;
const int MAX_E = 1e5 * (1e5 - 1) / 2;
struct edge {int u, v, cost; };
vector<pair<int, int> > coo;
bool comp(const edge& e1, const edge& e2) {
return e1.cost < e2.cost;
}
edge es[MAX_E];
int V, E;
int par[MAX_N]; // 親
int depth[MAX_N]; // 木の深さ
// n要素で初期化
void init(int n) {
rep(i, 0, n) {
par[i] = i;
depth[i] = 0;
}
}
// 木の根を求める
int find(int x) {
if(par[x] == x) return x;
else return par[x] = find(par[x]);
}
// xとyの属する集合を併合
void unite(int x, int y) {
x = find(x);
y = find(y);
if(x == y) return;
if(depth[x] < depth[y]) {
par[x] = y;
} else {
par[y] = x;
if(depth[x] == depth[y]) depth[x]++;
}
}
// xとyが同じ集合に属するか否か
bool same(int x, int y) {
return find(x) == find(y);
}
int kruskal() {
sort(es, es + E, comp);
init(V);
int res = 0;
rep(i, 0, E) {
edge e = es[i];
if(!same(e.u, e.v)) {
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> V;
E = V * (V - 1) / 2;
rep(i, 0, V) {
int x, y;
cin >> x >> y;
coo.push_back(make_pair(x, y));
}
int cnt = 0;
rep(i, 0, V) {
rep(j, i + 1, V) {
int a, b, c, d;
a = coo[i].first;
b = coo[i].second;
c = coo[j].first;
d = coo[j].second;
edge e;
e.u = i;
e.v = j;
e.cost = min(abs(a - c), abs(b - d));
es[cnt++] = e;
}
}
cout << kruskal() << endl;
}
| a.cc:32:35: warning: overflow in conversion from 'double' to 'int' changes value from '4.99995e+9' to '2147483647' [-Woverflow]
32 | const int MAX_E = 1e5 * (1e5 - 1) / 2;
| ~~~~~~~~~~~~~~~~^~~
a.cc:40:9: error: size of array 'es' exceeds maximum object size '9223372036854775807'
40 | edge es[MAX_E];
| ^~~~~
|
s868689327 | p03682 | C++ | //
// abc065d.cpp
//
//
// Created by Yoshida Satoshi on 2018/11/09.
//
#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#define MAX 100005
using namespace std;
typedef long long ll;
struct Path
{
int from,to,cost;
bool operator<(const Path& rhs)const
{
return cost<rhs.cost;
}
};
struct UF
{
vector<int> par;
UF(int n):par(n)
{
for(int i=0;i<n;i++) par[i]=i;
}
int root(int x)
{
if(par[x]==x) return x;
else return par[x]=root(par[x]);
}
void unite(int x,int y)
{
int rx=root(x);
int ry=root(y);
par[rx]=ry;
}
bool same(int x,int y)
{
int rx=root(x);
int ry=root(y);
return rx==ry;
}
};
struct V
{
int pos,index;
bool operator<(const V& rhs)const
{
return pos<rhs.pos;
}
}
int main()
{
int n;
cin>>n;
vector<Path> p;
int x[MAX],y[MAX];
V vx[MAX],vy[MAX];
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
vx[i]={x[i],i};
vy[i]={y[i],i};
}
sort(vx,vx+n);
sort(vy,vy+n);
for(int i=0;i<n-1;i++)
{
p.push_back({vx[i].index,vx[i+1].index,vx[i+1].pos-vx[i].pos});
p.push_back({vy[i].index,vy[i+1].index,vy[i+1].pos-vy[i].pos});
}
UF uf(n);
ll ans=0;
for(int i=0;i<p.size();i++)
{
int from=p[i].from;
int to=p[i].to;
int cost=p[i].cost;
if(!uf.same(from,to))
{
uf.unite(from,to);
ans+=cost;
}
}
cout<<ans<<endl;
return 0;
}
| a.cc:70:2: error: expected ';' after struct definition
70 | }
| ^
| ;
|
s767033355 | p03682 | C++ | //
// abc065d.cpp
//
//
// Created by Yoshida Satoshi on 2018/11/09.
//
#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#define MAX 100005
using namespace std;
typedef long long ll;
struct Path
{
int from,to,cost;
bool operator<(const Path& rhs)const
{
return cost<rhs.cost;
}
};
struct UF
{
vector<int> par;
UF(int n):par(n)
{
for(int i=0;i<n;i++) par[i]=i;
}
int root(int x)
{
if(par[x]==x) return x;
else return par[x]=root(par[x]);
}
void unite(int x,int y)
{
int rx=root(x);
int ry=root(y);
par[rx]=ry;
}
bool same(int x,int y)
{
int rx=root(x);
int ry=root(y);
return rx==ry;
}
};
struct V
{
int pos,index;
bool operator<(const V& rhs)const
{
return pos<rhs.pos;
}
}
int main()
{
int n;
cin>>n;
vector<Path> p;
int x[MAX],y[MAX];
V vx[MAX],vy[MAX];
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
vx[i]={x[i],i};
vy[i]={y[i],i};
}
sort(vx,vx+n);
sort(vy,vy+n);
for(int i=0;i<n-1;i++)
{
p.push_back({vx[i].index,vx[i+1].index,vx[i+1].pos-vx[i].pos});
p.push_back({vy[i].index,vy[i+1].index,vy[i+1].pos-vy[i].pos});
}
UF uf(n);
ll ans=0;
for(int i=0;i<p.size();i++)
{
int from=p[i].from;
int to=p[i].to;
int cost=p[i].cost;
if(!uf.same(from,to))
{
cnt++;
uf.unite(from,to);
ans+=cost;
}
}
cout<<ans<<endl;
return 0;
}
| a.cc:70:2: error: expected ';' after struct definition
70 | }
| ^
| ;
a.cc: In function 'int main()':
a.cc:103:13: error: 'cnt' was not declared in this scope; did you mean 'int'?
103 | cnt++;
| ^~~
| int
|
s686600576 | p03682 | C++ | //
// abc065d.cpp
//
//
// Created by Yoshida Satoshi on 2018/11/09.
//
#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <cmath>
#include <vector>
#define MAX 100005
using namespace std;
typedef long long ll;
struct Path
{
int from,to,cost;
bool operator<(const Path& rhs)const
{
return cost<rhs.cost;
}
};
struct UF
{
vector<int> par;
UF(int n):par(n)
{
for(int i=0;i<n;i++) par[i]=i;
}
int root(int x)
{
if(par[x]==x) return x;
else return par[x]=root(par[x]);
}
void unite(int x,int y)
{
int rx=root(x);
int ry=root(y);
par[rx]=ry;
}
bool same(int x,int y)
{
int rx=root(x);
int ry=root(y);
return rx==ry;
}
};
int main()
{
int n;
cin>>n;
vector<Path> p;
int x[MAX],y[MAX];
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
for(int j=0;j<i;j++)
{
p.push_back({j,i,min(abs(x[i]-x[j]),abs(y[i]-y[j]))});
}
}
sort(p.begin(),p.end());
UF uf(n);
ll ans=0;
int cnt=0;
for(int i=0;i<p.size();i++)
{
if(cnt==v-1) break;
int from=p[i].from;
int to=p[i].to;
int cost=p[i].cost;
if(!uf.same(from,to))
{
cnt++;
uf.unite(from,to);
ans+=cost;
}
}
cout<<ans<<endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:84:17: error: 'v' was not declared in this scope
84 | if(cnt==v-1) break;
| ^
|
s279814593 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
pair<int, int> X[100001], Y[100001];
rep1(i, N) {
int x, y;
cin >> x >> y;
X[i] = make_pair(x, i);
Y[i] = make_pair(y, i);
}
sort(X + 1, X + N + 1);
sort(Y + 1, Y + N + 1);
vector<pair<int, int>> eda[100001];
rep1(i, N - 1) {
eda[X[i].second].push_back(make_pair(X[i + 1].second, abs(X[i + 1].first - X[i].first)));
eda[X[i + 1].second].push_back(make_pair(X[i].second, abs(X[i + 1].first - X[i].first)));
eda[Y[i].second].push_back(make_pair(Y[i + 1].second, abs(Y[i + 1].first - Y[i].first)));
eda[Y[i + 1].second].push_back(make_pair(Y[i].second, abs(Y[i + 1].first - Y[i].first)));
}
ll kyori[100001] = {};
ll edanagasa[100001] = {};
rep1(i, N) kyori[i] = 1e18;
vector<pair<int, pair<ll, int>>> que;
que.push_back(make_pair(1, make_pair(1, 1)));
while (que.size()) {
vector<pair<int, pair<ll, int>>> que2;
for (auto itr : que) {
if (kyori[itr.first] > itr.second.first) {
kyori[itr.first] = itr.second.first;
edanagasa[itr.first] = itr.second.second;
for (auto itr2 : eda[itr.first]) {
que2.push_back(make_pair(itr2.first, make_pair(itr2.second + itr.second.first, itr2.second)));
}
}
else if (kyori[itr.first] == itr.second.first) {
edanagasa[itr.first] = min(edanagasa[itr.first], itr.second.second);
}
}
que = que2;
}
ll kotae = 0;
rep1(i, N - 1) {
kotae += edanagasa[i + 1];
}
co(kotae);
Would you please return 0;
} | a.cc: In function 'int main()':
a.cc:59:59: error: no matching function for call to 'min(ll&, int&)'
59 | edanagasa[itr.first] = min(edanagasa[itr.first], itr.second.second);
| ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
233 | min(const _Tp& __a, const _Tp& __b)
| ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: template argument deduction/substitution failed:
a.cc:59:59: note: deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
59 | edanagasa[itr.first] = min(edanagasa[itr.first], itr.second.second);
| ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
281 | min(const _Tp& __a, const _Tp& __b, _Compare __comp)
| ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
5686 | min(initializer_list<_Tp> __l)
| ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
5696 | min(initializer_list<_Tp> __l, _Compare __comp)
| ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: template argument deduction/substitution failed:
a.cc:59:59: note: mismatched types 'std::initializer_list<_Tp>' and 'long long int'
59 | edanagasa[itr.first] = min(edanagasa[itr.first], itr.second.second);
| ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
s008616229 | p03682 | C++ | #include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>
#include<cmath>
#include <numeric>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef long long int ll;
#define ARRAY_MAX 100005
vector<int> par(ARRAY_MAX);//親
vector<int> rank(ARRAY_MAX);//木の深さ
typedef struct edge{
int u;
int v;
int cost;
}EDGE;
bool comp(const EDGE& e1,const EDGE& e2){
return e1.cost < e2.cost;
}
//n要素で初期化
void init(int n){
for(int i = 0;i < n;i++){
par[i] = i;/*各ノードに番号を振る,この時par[x]=xとなる時は木の根となる*/
rank[i] = 0;/*各ノード自体の高さは0*/
}
}
//木の根を求める
int find(int x){
if(par[x] == x){
return x;/*根ならそのノードの番号を返す*/
}else{
return par[x] = find(par[x]);/*根でないならさらにノードの根を探す*/
}
}
//xとyの属する集合を併合する
void unite(int x,int y){
x = find(x);//xの根の番号を探す
y = find(y);//yの根の番号を探す
if(x == y){//一致すればつながっている
return;
}
if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
par[x] = y;
}else{
par[y] = x;//yの高さが低いなら高いほうにつなぐ、そして高さは大きいほう(x)になる
if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
rank[x]++;
}
}
}
//xとyが同じ集合に属するか判定
bool same(int x,int y){
return find(x) == find(y);//同じ集合なら1、違うなら0が返る
}
int kruskal(int n,int count,vector<EDGE>& es){
sort(es.begin(),es.end(),comp);
init(n);
int res = 0;
for(int i = 0;i < count;i++){
EDGE e = es[i];
if(!same(e.u,e.v)){
unite(e.u,e.v);
res += e.cost;
}
}
return res;
}
int main(){
int n;
cin >> n;
vector<EDGE> es;
vector<int> x(n),y(n);
int count = 0;
REP(i,n){
cin >> x[i] >> y[i];
}
for(int i = 0;i < n-1;i++){
for(int j = i+1;j < n;j++){
EDGE e;
e.u = i;
e.v = j;
e.cost = min(abs(x[j]-x[i]),abs(y[j]-y[i]));
es.push_back(e);
count++;
}
}
int ans = kruskal(n,count,es);
cout << ans << endl;
return 0;
} | a.cc: In function 'void init(int)':
a.cc:48:9: error: reference to 'rank' is ambiguous
48 | rank[i] = 0;/*各ノード自体の高さは0*/
| ^~~~
In file included from /usr/include/c++/14/bits/move.h:37,
from /usr/include/c++/14/bits/exception_ptr.h:41,
from /usr/include/c++/14/exception:166,
from /usr/include/c++/14/ios:41,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:67:8: error: reference to 'rank' is ambiguous
67 | if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:67:18: error: reference to 'rank' is ambiguous
67 | if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:71:12: error: reference to 'rank' is ambiguous
71 | if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:71:23: error: reference to 'rank' is ambiguous
71 | if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:72:13: error: reference to 'rank' is ambiguous
72 | rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:13: note: 'std::vector<int> rank'
30 | vector<int> rank(ARRAY_MAX);//木の深さ
| ^~~~
|
s711619603 | p03682 | C++ | #include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>
#include<cmath>
#include <numeric>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef long long int ll;
#define ARRAY_MAX 100005
vector<ll> par(ARRAY_MAX);//親
vector<ll> rank(ARRAY_MAX);//木の深さ
typedef struct edge{
ll u;
ll v;
ll cost;
}EDGE;
bool comp(const EDGE& e1,const EDGE& e2){
return e1.cost < e2.cost;
}
//n要素で初期化
void init(ll n){
for(ll i = 0;i < n;i++){
par[i] = i;/*各ノードに番号を振る,この時par[x]=xとなる時は木の根となる*/
rank[i] = 0;/*各ノード自体の高さは0*/
}
}
//木の根を求める
ll find(ll x){
if(par[x] == x){
return x;/*根ならそのノードの番号を返す*/
}else{
return par[x] = find(par[x]);/*根でないならさらにノードの根を探す*/
}
}
//xとyの属する集合を併合する
void unite(ll x,ll y){
x = find(x);//xの根の番号を探す
y = find(y);//yの根の番号を探す
if(x == y){//一致すればつながっている
return;
}
if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
par[x] = y;
}else{
par[y] = x;//yの高さが低いなら高いほうにつなぐ、そして高さは大きいほう(x)になる
if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
rank[x]++;
}
}
}
//xとyが同じ集合に属するか判定
bool same(ll x,ll y){
return find(x) == find(y);//同じ集合なら1、違うなら0が返る
}
ll kruskal(ll n,ll count,vector<EDGE>& es){
sort(es.begin(),es.end(),comp);
init(n);
ll res = 0;
for(ll i = 0;i < count;i++){
EDGE e = es[i];
if(!same(e.u,e.v)){
unite(e.u,e.v);
res += e.cost;
}
}
return res;
}
int main(){
ll n;
cin >> n;
vector<EDGE> es;
vector<ll> x(n),y(n);
ll count = 0;
REP(i,n){
cin >> x[i] >> y[i];
}
for(ll i = 0;i < n-1;i++){
for(ll j = i+1;j < n;j++){
EDGE e;
e.u = i;
e.v = j;
e.cost = min(abs(x[j]-x[i]),abs(y[j]-y[i]));
es.push_back(e);
count++;
}
}
ll ans = kruskal(n,count,es);
cout << ans << endl;
return 0;
} | a.cc: In function 'void init(ll)':
a.cc:48:9: error: reference to 'rank' is ambiguous
48 | rank[i] = 0;/*各ノード自体の高さは0*/
| ^~~~
In file included from /usr/include/c++/14/bits/move.h:37,
from /usr/include/c++/14/bits/exception_ptr.h:41,
from /usr/include/c++/14/exception:166,
from /usr/include/c++/14/ios:41,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc: In function 'void unite(ll, ll)':
a.cc:67:8: error: reference to 'rank' is ambiguous
67 | if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:67:18: error: reference to 'rank' is ambiguous
67 | if(rank[x] < rank[y]){//xの高さが低いなら高いほうにつなぐ、そして高さは大きい方(y)になる
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:71:12: error: reference to 'rank' is ambiguous
71 | if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:71:23: error: reference to 'rank' is ambiguous
71 | if(rank[x] == rank[y]){//高さが一致しているなら併合の高さは1増える
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
a.cc:72:13: error: reference to 'rank' is ambiguous
72 | rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:30:12: note: 'std::vector<long long int> rank'
30 | vector<ll> rank(ARRAY_MAX);//木の深さ
| ^~~~
|
s159274764 | p03682 | C++ | #include <bits/stdc++.h>
// statics
using namespace std;
using int64 = int_fast64_t;
using PAIR = pair<int, int>;
constexpr int INF = 1 << 30;
constexpr int64 LINF = 1LL << 60;
constexpr int MOD = 1e9 + 7;
constexpr int MAX_N = 1e5 + 1;
// init/input
#define int int64
#define INIT ios::sync_with_stdio(false);cin.tie(0);
#define VAR(type, ...) type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T &t) {cin>>t;}
template<typename First, typename...Rest> void MACRO_VAR_Scan(First &first, Rest&...rest) {cin>>first;MACRO_VAR_Scan(rest...);}
#define VEC(type, c, n) vector<type> c(n);for(auto &&i:c)cin>>i;
// out
#define OUT(dist) cout<<(dist);
#define FOUT(n, dist) cout<<fixed<<setprecision(n)<<(dist);
#define SP cout<<" ";
#define BR cout<<"\n";
#define debug(x) cerr<<#x<<":"<< (x);BR;
// utility
#define ALL(a) (a).begin(), (a).end()
#define EACH(i, a) for(auto &&i:(a))
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=0;--i)
#define REP(i, n) for(int i=0;i<(n);++i)
#define RREP(i, n) for(int i=(n)-1;i>=0;--i)
struct Edge {
Edge(int _from, int _to, int _cost)
: from(_from), to(_to), cost(_cost){}
int from, to, cost;
};
vector< Edge > e;
struct UnionFind {
vector< int > par;
UnionFind(int n = 1) {
init(n);
}
void init(int n = 1) {
par.resize(n);
for(int i = 0; i < n; i++)
par[i] = -1;
}
int root(int n) {
if (par[n] < 0) return n;
return par[n] = root(par[n]);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
bool issame(int x, int y) {
return root(x) == root(y);
}
};
signed main() {
INIT;
VAR(int, n);
vector< tuple< int, int, int > > x(n), y(n);
REP(i, n) {
VAR(int, p, q);
x[i] = make_tuple(p, q, i);
y[i] = make_tuple(q, p, i);
}
sort(ALL(x));
sort(ALL(y));
REP(i, n - 1) {
int p, q, from, to, cost, tmp;
tie(p, tmp, from) = x[i];
tie(q, cost, to) = x[i + 1];
e.push_back(Edge(from, to, abs(p - q)));
}
REP(i, n - 1) {
tie(p, tmp, from) = y[i];
tie(q, cost, to) = y[i + 1];
e.push_back(Edge(from, to, abs(p - q)));
}
auto kruscal = [=](){
sort(ALL(e), [](Edge x, Edge y) {
return x.cost < y.cost;
});
UnionFind uf(n + 1);
int res = 0;
EACH(ei, e) {
if (uf.root(ei.from) != uf.root(ei.to)){
uf.merge(ei.from, ei.to);
res += ei.cost;
}
}
return res;
};
int ans = kruscal();
OUT(ans)BR;
return 0;
}
| a.cc: In function 'int main()':
a.cc:97:21: error: 'p' was not declared in this scope
97 | tie(p, tmp, from) = y[i];
| ^
a.cc:97:24: error: 'tmp' was not declared in this scope; did you mean 'tm'?
97 | tie(p, tmp, from) = y[i];
| ^~~
| tm
a.cc:97:29: error: 'from' was not declared in this scope; did you mean 'fromfp'?
97 | tie(p, tmp, from) = y[i];
| ^~~~
| fromfp
a.cc:98:21: error: 'q' was not declared in this scope
98 | tie(q, cost, to) = y[i + 1];
| ^
a.cc:98:24: error: 'cost' was not declared in this scope; did you mean 'cosl'?
98 | tie(q, cost, to) = y[i + 1];
| ^~~~
| cosl
a.cc:98:30: error: 'to' was not declared in this scope; did you mean 'tm'?
98 | tie(q, cost, to) = y[i + 1];
| ^~
| tm
|
s247978935 | p03682 | C++ | #include <iostream>
#include <vector>
using namespace std;
int *par, *ranks;
int N;
struct P {int n, x, y;};
struct PATH {int v1, v2, cost;};
void init()
{
for (int i = 0; i < N; i++) {
par[i] = i;
ranks[i] = 0;
}
}
int find(int x)
{
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y)
{
x = find(x); y = find(y);
if (x == y) return;
if (ranks[x] < ranks[y]) par[x] = par[y];
else {
par[y] = par[x];
if (ranks[x] == ranks[y]) ranks[x]++;
}
}
bool same(int x, int y)
{
return find(x) == find(y);
}
bool comp_x(P p1, P p2)
{
return p1.x < p2.x;
}
bool comp_y(P p1, P p2)
{
return p1.y < p2.y;
}
bool comp_cost(PATH path1, PATH path2)
{
return path1.cost < path2.cost;
}
int main()
{
cin >> N;
P p[N];
par = new int[N];
ranks = new int[N];
for (int i = 0; i < N; i++) {
p[i].n = i;
cin >> p[i].x >> p[i].y;
}
init();
vector<PATH> pathes;
sort(p, p + N, comp_x);
for (int i = 0; i < N-1; i++) {
PATH tmp;
tmp.v1 = p[i].n; tmp.v2 = p[i+1].n;
tmp.cost = p[i+1].x - p[i].x;
pathes.push_back(tmp);
}
sort(p, p + N, comp_y);
for (int i = 0; i < N-1; i++) {
PATH tmp;
tmp.v1 = p[i].n; tmp.v2 = p[i+1].n;
tmp.cost = p[i+1].y - p[i].y;
pathes.push_back(tmp);
}
sort(pathes.begin(), pathes.end(), comp_cost);
int lim = pathes.size(), ans = 0;
for (int i = 0; i < lim; i++) {
PATH path = pathes[i];
if (same(path.v1, path.v2)) continue;
unite(path.v1, path.v2);
ans += path.cost;
}
cout << ans << endl;
delete [] par;
delete [] ranks;
}
| a.cc: In function 'int main()':
a.cc:67:3: error: 'sort' was not declared in this scope; did you mean 'short'?
67 | sort(p, p + N, comp_x);
| ^~~~
| short
|
s574669199 | p03682 | C++ | #include <algorithm>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <functional>
#include <climits>
#include <iostream>
namespace std {
template <>
class hash<std::pair<int, int>> {
public:
size_t operator()(const std::pair<int, int>& x) const {
return hash<int>()(x.first) ^ hash<int>()(x.second);
}
};
}
class edge {
public:
edge(int to, long long cost);
int get_to() const;
long long get_cost() const;
private:
int to;
long long cost;
};
edge::edge(int to, long long cost) : to(to), cost(cost) {}
int edge::get_to() const { return to; }
long long edge::get_cost() const { return cost; }
class prim
{
private:
//unordered_mapを使って隣接リストを構築
//first:接続元、second:辺のコストと接続先
std::unordered_map<int, std::vector<edge>> adj_list;
//最小全域木の隣接リスト
std::unordered_map<int, std::vector<edge>> MST_list;
int node_num;
std::vector<bool> is_done;//確定ノードか否かを保持
long long MST_cost;
public:
prim(const int node_num, const std::unordered_map<int, std::vector<edge>>& adj_list);
long long get_MST_cost() const;
std::unordered_map<int, std::vector<edge>> calc_MST();
};
prim::prim(const int node_num, const std::unordered_map<int, std::vector<edge>>& adj_list):
adj_list(adj_list),
node_num(node_num),
is_done(node_num + 1, false),
MST_cost(0)
{
}
std::unordered_map<int, std::vector<edge>> prim::calc_MST() {
MST_cost = 0;
std::vector<long long> key(node_num + 1, LLONG_MAX);
//優先度付きキューpairで頂点番号と最短距離を保持
//firstの要素で比較されるので、firstが距離、secondをfrom,toのペアとする
std::priority_queue<std::pair<long long, std::pair<int, int>>,
std::vector<std::pair<long long, std::pair<int, int>>>,
std::greater<std::pair<long long, std::pair<int, int>>>> p_queue;
p_queue.push(std::make_pair(0,std::make_pair(-1, adj_list.begin()->first)));
key[adj_list.begin()->first] = 0;
while (1) {
if (p_queue.empty() == true) break; //キューが空なら終了
//std::cout << p_queue.size() << "\n";
std::pair<long long, std::pair<int, int>> cost_node = p_queue.top();
p_queue.pop();
if (cost_node.second.first >= 0 &&
is_done[cost_node.second.second] == false) {
//最小全域木の隣接リストを構築
MST_list[cost_node.second.first].
push_back(edge(cost_node.second.second, cost_node.first));
//無向グラフなので逆方向も
MST_list[cost_node.second.second].
push_back(edge(cost_node.second.first, cost_node.first));
MST_cost += cost_node.first;
}
int from_node = cost_node.second.second;
is_done[from_node] = true; //キューから取り出した頂点を確定頂点とする
for (auto &it : adj_list[from_node]) {
int adj_node = it.get_to();
if (is_done[adj_node] == false) {
long long adj_cost = it.get_cost();
if (adj_cost < key[adj_node])
p_queue.push(std::make_pair(adj_cost,
std::make_pair(from_node, adj_node)));
}
}
}
return MST_list;
}
long long prim::get_MST_cost() const {
return MST_cost;
}
#define ATCODER
int main()
{
#ifndef ATCODER
std::unordered_map<int, std::vector<edge>> adj_list;
int N, M;
std::cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b, c;
std::cin >> a >> b >> c;
adj_list[a].push_back(edge(b, c));
adj_list[b].push_back(edge(a, c));
}
prim p(N, adj_list);
p.calc_MST();
return 0;
#else
std::vector<std::pair<long long, int>> x_citys;
std::vector<std::pair<long long, int>> y_citys;
std::unordered_map<int, std::vector<edge>> adj_list;
int N;
std::cin >> N;
for (int i = 0; i < N; i++) {
int x, y;
std::cin >> x >> y;
x_citys.push_back(std::make_pair(x, i + 1));
y_citys.push_back(std::make_pair(y, i + 1));
}
std::sort(x_citys.begin(), x_citys.end());
std::sort(y_citys.begin(), y_citys.end());
//std::unordered_map<std::pair<int, int>, long long> adj_map;
//std::unordered_map<int, std::unordered_set<int>> adj_map;
std::vector<std::pair<int, int>> adj_pair_list;
for (int i = 0; i < N - 1; i++) {
///*
//long long dist = abs(x_citys[i + 1].first - x_citys[i].first);
//if (dist < adj_mat[x_citys[i].second][x_citys[i + 1].second]) {
// adj_mat[x_citys[i].second][x_citys[i + 1].second] = dist;
// adj_mat[x_citys[i + 1].second][x_citys[i].second] = dist;
// adj_map[x_citys[i].second].insert(x_citys[i + 1].second);
// adj_map[x_citys[i + 1].second].insert(x_citys[i].second);
//}
//dist = abs(y_citys[i + 1].first - y_citys[i].first);
//if (dist < adj_mat[y_citys[i].second][y_citys[i + 1].second]) {
// adj_mat[y_citys[i].second][y_citys[i + 1].second] = dist;
// adj_mat[y_citys[i + 1].second][y_citys[i].second] = dist;
// adj_map[y_citys[i].second].insert(y_citys[i + 1].second);
// adj_map[y_citys[i + 1].second].insert(y_citys[i].second);
//}
//*/
//std::pair<int, int> adj_pair1(x_citys[i].second, x_citys[i + 1].second);
//std::pair<int, int> adj_pair2(x_citys[i + 1].second, x_citys[i].second);
//long long dist = abs(x_citys[i + 1].first - x_citys[i].first);
//if (adj_map.count(adj_pair1) == 0) {
// adj_map[adj_pair1] = dist;
// adj_map[adj_pair2] = dist;
//}
//else {
// if (dist < adj_map[adj_pair1]) {
// adj_map[adj_pair1] = dist;
// adj_map[adj_pair2] = dist;
// }
//}
//adj_pair1 = std::make_pair(y_citys[i].second, y_citys[i + 1].second);
//adj_pair2 = std::make_pair(y_citys[i + 1].second, y_citys[i].second);
//dist = abs(y_citys[i + 1].first - y_citys[i].first);
//if (adj_map.count(adj_pair1) == 0) {
// adj_map[adj_pair1] = dist;
// adj_map[adj_pair2] = dist;
//}
//else {
// if (dist < adj_map[adj_pair1]) {
// adj_map[adj_pair1] = dist;
// adj_map[adj_pair2] = dist;
// }
//}
adj_list[x_citys[i].second].push_back(edge(x_citys[i + 1].second,
abs(x_citys[i + 1].first - x_citys[i].first)));
adj_list[x_citys[i + 1].second].push_back(edge(x_citys[i].second,
abs(x_citys[i + 1].first - x_citys[i].first)));
adj_list[y_citys[i].second].push_back(edge(y_citys[i + 1].second,
abs(y_citys[i + 1].first - y_citys[i].first)));
adj_list[y_citys[i + 1].second].push_back(edge(y_citys[i].second,
abs(y_citys[i + 1].first - y_citys[i].first)));
}
//for (auto &it : adj_map) {
// adj_list[it.first.first].push_back(edge(it.first.second, it.second));
// //adj_list[it.first.second].push_back(edge(it.first.first, it.second));
//}
//for (auto &it1 : adj_map) {
// for (auto &it2 : it1.second) {
// adj_list[it1.first].push_back(edge(it2, adj_mat[it1.first][it2]));
// }
//}
prim p(N, adj_list);
p.calc_MST();
std::cout << p.get_MST_cost() << "\n";
return 0;
#endif | a.cc: In function 'int main()':
a.cc:213:14: error: expected '}' at end of input
213 | return 0;
| ^
a.cc:111:1: note: to match this '{'
111 | {
| ^
|
s680268192 | p03682 | C++ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for(int i=0; i<(n); ++i)
#define FOR(i, a, b) for(int i=(a); i<(b); ++i)
#define FORR(i, a, b) for(int i=(b)-1; i>=(a); --i)
#define DEBUG(x) cout<<#x<<": "<<x<<'\n'
#define DEBUG_VEC(v) cout<<#v<<":";REP(i, v.size())cout<<' '<<v[i];cout<<'\n'
#define ALL(a) (a).begin(), (a).end()
#define CHMIN(a, b) a=min((a), (b))
#define CHMAX(a, b) a=max((a), (b))
const ll MOD=1000000007ll;
// const ll MOD=998244353ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
const double EPS=1e-11;
#define EQ0(x) (abs((x))<EPS)
#define EQ(a, b) (abs((a)-(b))<EPS)
const ll INF=1e18;
const int MAX_N=114514;
const int MAX_E=214514;
int root[MAX_N], depth[MAX_N];
bool comp(const edge& e1, const edge& e2){
return e1.cost<e2.cost;
}
// n要素で初期化
void init_union_find(int n){
REP(i, n){
root[i]=i;
depth[i]=0;
}
}
// xの根を求める
int find(int x){
if(root[x]==x){
return x;
}
else{
return root[x]=find(root[x]);
}
}
// xとyが属する集合を併合
void unite(int x, int y){
x=find(x);
y=find(y);
if(x==y){
return;
}
if(depth[x]<depth[y]){
root[x]=y;
}
else{
root[y]=x;
if(depth[x]==depth[y]){
++depth[x];
}
}
return;
}
// xとyが同じ集合に属するか判定
bool same(int x, int y){
return find(x)==find(y);
}
struct edge{
pii u;
pii v;
int cost;
};
edge es[MAX_E];
int V, E;
ll kruskal(){
sort(es, es+E, comp);
init_union_find(V);
ll res=0;
REP(i, E){
edge e=es[i];
if(!same(e.u.second, e.v.second)){
unite(e.u.second, e.v.second);
res+=e.cost;
}
}
return res;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
pii x[114514], y[114514];
cin>>n;
V=n;
E=2*(n-1);
REP(i, n){
cin>>x[i].first>>y[i].first;
x[i].second=i;
y[i].second=i;
}
sort(x, x+n);
REP(i, n-1){
edge e;
e.u=x[i];
e.v=x[i+1];
e.cost=e.v.first-e.u.first;
es[i]=e;
}
sort(y, y+n);
REP(i, n-1){
edge e;
e.u=y[i];
e.v=y[i+1];
e.cost=e.v.first-e.u.first;
es[n-1+i]=e;
}
cout<<kruskal()<<'\n';
return 0;
}
| a.cc:37:17: error: 'edge' does not name a type
37 | bool comp(const edge& e1, const edge& e2){
| ^~~~
a.cc:37:33: error: 'edge' does not name a type
37 | bool comp(const edge& e1, const edge& e2){
| ^~~~
a.cc: In function 'bool comp(const int&, const int&)':
a.cc:38:19: error: request for member 'cost' in 'e1', which is of non-class type 'const int'
38 | return e1.cost<e2.cost;
| ^~~~
a.cc:38:27: error: request for member 'cost' in 'e2', which is of non-class type 'const int'
38 | return e1.cost<e2.cost;
| ^~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_comp_iter<_Compare>::operator()(_Iterator1, _Iterator2) [with _Iterator1 = edge*; _Iterator2 = edge*; _Compare = bool (*)(const int&, const int&)]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = edge*; _Compare = bool (*)(const int&, const int&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:93:6: required from here
93 | sort(es, es+E, comp);
| ~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:158:30: error: invalid initialization of reference of type 'const int&' from expression of type 'edge'
158 | { return bool(_M_comp(*__it1, *__it2)); }
| ~~~~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Val_comp_iter<_Compare>::operator()(_Value&, _Iterator) [with _Value = edge; _Iterator = edge*; _Compare = bool (*)(const int&, const int&)]':
/usr/include/c++/14/bits/stl_algo.h:1757:20: required from 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Val_comp_iter<bool (*)(const int&, const int&)>]'
1757 | while (__comp(__val, __next))
| ~~~~~~^~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1785:36: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1785 | std::__unguarded_linear_insert(__i,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
1786 | __gnu_cxx::__ops::__val_comp_iter(__comp));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = edge*; _Compare = bool (*)(const int&, const int&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:93:6: required from here
93 | sort(es, es+E, comp);
| ~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:240:30: error: invalid initialization of reference of type 'const int&' from expression of type 'edge'
240 | { return bool(_M_comp(__val, *__it)); }
| ~~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = edge*; _Value = edge; _Compare = bool (*)(const int&, const int&)]':
/usr/include/c++/14/bits/stl_heap.h:140:48: required from 'void std::__push_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare&) [with _RandomAccessIterator = edge*; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_val<bool (*)(const int&, const int&)>]'
140 | while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
| ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:247:23: required from 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = edge*; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
247 | std::__push_heap(__first, __holeIndex, __topIndex,
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
248 | _GLIBCXX_MOVE(__value), __cmp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:356:22: required from 'void std::__make_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare&) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
356 | std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
357 | __comp);
| ~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1593:23: required from 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1593 | std::__make_heap(__first, __middle, __comp);
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1868:25: required from 'void std::__partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1868 | std::__heap_select(__first, __middle, __last, __comp);
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1884:27: required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = edge*; _Size = long int; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1884 | std::__partial_sort(__first, __last, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1905:25: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = edge*; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(const int&, const int&)>]'
1905 | std::__introsort_loop(__first, __last,
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
1906 | std::__lg(__last - __first) * 2,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1907 | __comp);
| ~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = edge*; _Compare = bool (*)(const int&, const int&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:93:6: required from here
93 | sort(es, es+E, comp);
| ~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:196:30: error: invalid initialization of reference of type 'const int&' from expression of type 'edge'
196 | { return bool(_M_comp(*__it, __val)); }
| ~~~~~~~^~~~~~~~~~~~~~
|
s124258122 | p03682 | C++ | #include <bits/stdc++.h>
#define ll long long
#define met(a,0) memset(a,0,sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;
const int mod=1e9+7;
const int N=1e5+10;
int book[N];
void init()
{
for(int i=1; i<=n; i++)
book[i]=i;
}
int getfa(int x)
{
if(book[x]!=x)
book[x]=getfa(book[x]);
return book[x];
}
void mergexy(int x,int y)
{
book[y]=x;
}
struct node{
int x,y,cnt;}s[N];
struct nodee{
int u,v,w;}f[2*N];
bool cmp(node a,node b){
return a.x<b.x;}
bool cmpp(node a,node b){
return a.y<b.y;}
bool cmppp(nodee a,nodee b){
return a.w<b.w;}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int i,j,k,m,n;
int cnt=0,sum=0,ans=0,num;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>s[i].x>>s[i].y;
s[i].cnt=i;
}
sort(s+1,s+1+n,cmp);
for(i=1;i<n;i++)
{
f[++cnt].u=s[i].cnt;
f[cnt].v=s[i+1].cnt;
f[cnt].w=min(s[i+1].x-s[i].x,abs(s[i+1].y-s[i].y));
}
sort(s+1,s+1+n,cmpp)
for(i=1;i<n;i++)
{
f[++cnt].u=s[i].cnt;
f[cnt].v=s[i+1].cnt;
f[cnt].w=min(s[i+1].y-s[i].y,abs(s[i+1].x-s[i].x));
}
sort(f+1,f+1+n,cmppp)
init();
for(i=1;i<=cnt;++i)
{
k=getfa(f[i].u);
m=getfa(f[i].v);
if(k!=m)
{
mergexy(k,m);
num++;
sum+=f[i].w;
}
if(num==n)
break;
}
cout<<sum<<endl;
return 0;
}
| a.cc:3:15: error: expected parameter name, found "0"
3 | #define met(a,0) memset(a,0,sizeof(a))
| ^
a.cc: In function 'void init()':
a.cc:11:21: error: 'n' was not declared in this scope
11 | for(int i=1; i<=n; i++)
| ^
a.cc: In function 'int main()':
a.cc:53:25: error: expected ';' before 'for'
53 | sort(s+1,s+1+n,cmpp)
| ^
| ;
54 | for(i=1;i<n;i++)
| ~~~
a.cc:54:20: error: expected ';' before ')' token
54 | for(i=1;i<n;i++)
| ^
| ;
a.cc:60:26: error: expected ';' before 'init'
60 | sort(f+1,f+1+n,cmppp)
| ^
| ;
61 | init();
| ~~~~
|
s989492590 | p03682 | Java | static ArrayList<Edge> edges = new ArrayList<>();
public static void addEdge(int f, int t, long c)
{
edges.add(new Edge(f, t, c));
}
static class Edge implements Comparable<Edge>
{
int f;
int t;
long toCost;
Edge(int f, int to, long cost)
{
this.f = f;
t = to;
toCost = cost;
}
@Override
public int compareTo(Edge e)
{
return toCost == e.toCost ? 0 : toCost > e.toCost ? 1 : -1;
}
}
| Main.java:1: error: unnamed classes are a preview feature and are disabled by default.
static ArrayList<Edge> edges = new ArrayList<>();
^
(use --enable-preview to enable unnamed classes)
1 error
|
s880292529 | p03682 | C++ | #include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iostream>
#include <queue>
#include <functional>
using namespace std;
typedef long long ll;
ll min(ll a, ll b){
if(a<b){return a;}
else{return b;}
}
ll x[100005];
ll y[100005];
typedef pair<ll,int> pii;
bool used[100005];
int N;
ll prim() {
priority_queue<pii, vector<pii>, greater<pii> > que;
memset(used, 0, sizeof(used));
que.push(pii(0ll,0));
ll ret = 0ll;
while(!que.empty()) {
ll cst = que.top().first;
int v = que.top().second;
que.pop();
if(used[v]) {continue;}
used[v] = 1;
ret += cst;
for(int i = 0; i < N; i++){
que.push(pii(min(llabs(x[i]-x[v]),llabs(y[i]-y[v])),i));
}
}
return ret;
}
int main(){
scanf("%d",&N);
int i;
for(i=0;i<N;i++){
scanf("%lld %lld",&x[i],&y[i]);
}
printf("%lld\n",prim());
return 0;
} | a.cc: In function 'll prim()':
a.cc:27:5: error: 'memset' was not declared in this scope
27 | memset(used, 0, sizeof(used));
| ^~~~~~
a.cc:8:1: note: 'memset' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
7 | #include <functional>
+++ |+#include <cstring>
8 |
|
s566155194 | p03682 | C++ | #include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
#define INF 1<<50LL
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define RFOR(i,a,b) for(long long i = (b-1);i>=a;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ITR(itr,mp) for(auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr,mp) for(auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define dump(x) cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
typedef long long ll;
typedef pair<ll,ll> P;
struct Edge{
int x,y,cost;
};
struct Node{
int x,y,id;
};
bool cmpx(Node& a,Node& b){
return a.x <= b.x;
}
bool cmpy(Node& a,Node& b){
return a.y <= b.y;
}
bool cmpc(Edge& a,Edge& b){
return a.cost <= b.cost;
}
vector <Edge>edge;
vector <Node>node;
const int MAXN = 100100;
int tree[MAXN];
vector <int> child;
ll ans = 0;
int root(int i){
if(i == tree[i]){
for(int j = 0; j < child.size(); j++)
tree[child[j]] = i;
child.clear();
return i;
}
else{
child.push_back(i);
return i = root(tree[i]);
}
}
int unit(int x,int y){
x = root(x);
y = root(y);
tree[max(x,y)] = min(x,y);
}
bool isUnit(int x,int y){
return root(x) == root(y);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
REP(i,n){
int x,y;
cin >> x >> y;
node.push_back({x,y,i});
}
sort(node.begin(),node.end(),cmpx);
REP(i,n-1){
edge.push_back({node[i].id,node[i+1].id,abs(node[i+1].x-node[i].x)});
}
sort(node.begin(),node.end(),cmpy);
REP(i,n-1){
edge.push_back({node[i].id,node[i+1].id,abs(node[i+1].y-node[i].y)});
}
sort(edge.begin(),edge.end());
/* REP(i,edge.size()){
cout << edge[i].x << " " << edge[i].y << " " << edge[i].cost << endl;
}*/
REP(i,n) tree[i] = i;
REP(i,edge.size()){
if(isUnit(edge[i].x,edge[i].y)) continue;
unit(edge[i].x,edge[i].y);
ans += edge[i].cost;
}
cout << ans << endl;
return 0;
} | a.cc: In function 'int unit(int, int)':
a.cc:62:1: warning: no return statement in function returning non-void [-Wreturn-type]
62 | }
| ^
a.cc: In function 'int main()':
a.cc:79:25: warning: narrowing conversion of 'i' from 'long long int' to 'int' [-Wnarrowing]
79 | node.push_back({x,y,i});
| ^
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >; _Iterator2 = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18: required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >]'
4772 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:92:7: required from here
92 | sort(edge.begin(),edge.end());
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:45:23: error: no match for 'operator<' (operand types are 'Edge' and 'Edge')
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/bits/stl_algobase.h:67:
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
1241 | operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
1249 | operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Val_less_iter::operator()(_Value&, _Iterator) const [with _Value = Edge; _Iterator = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >]':
/usr/include/c++/14/bits/stl_algo.h:1757:20: required from 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Val_less_iter]'
1757 | while (__comp(__val, __next))
| ~~~~~~^~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1785:36: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1785 | std::__unguarded_linear_insert(__i,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
1786 | __gnu_cxx::__ops::__val_comp_iter(__comp));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18: required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >]'
4772 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:92:7: required from here
92 | sort(edge.begin(),edge.end());
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:98:22: error: no match for 'operator<' (operand types are 'Edge' and 'Edge')
98 | { return __val < *__it; }
| ~~~~~~^~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
1241 | operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:98:22: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
98 | { return __val < *__it; }
| ~~~~~~^~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
1249 | operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:98:22: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
98 | { return __val < *__it; }
| ~~~~~~^~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Iter_less_val::operator()(_Iterator, _Value&) const [with _Iterator = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >; _Value = Edge]':
/usr/include/c++/14/bits/stl_heap.h:140:48: required from 'void std::__push_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Distance = long int; _Tp = Edge; _Compare = __gnu_cxx::__ops::_Iter_less_val]'
140 | while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
| ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:247:23: required from 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Distance = long int; _Tp = Edge; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
247 | std::__push_heap(__first, __holeIndex, __topIndex,
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
248 | _GLIBCXX_MOVE(__value), __cmp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:356:22: required from 'void std::__make_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
356 | std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
357 | __comp);
| ~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1593:23: required from 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1593 | std::__m |
s837195504 | p03682 | C++ | #include<iostream>
#include<queue>
using namespace std;
using pii = pair<int, int>;
const int mxn = 100010;
struct edge{int from, to, cost;};
bool comp(edge a, edge b) {
return a.cost < b.cost;
}
vector<edge> es;
int par[mxn];
void init_unionfind(int n){
fill(par, par + n, -1);
}
int root(int x) {
return par[x] < 0 ? x : par[x] = root(par[x]);
}
bool same(int x, int y) {
return root(x) == root(y);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if(par[y] < par[x]) swap(x, y);
par[x] += par[y];
par[y] = x;
}
int main() {
int N;
cin >> N;
vector<pii> xs, ys;
for(int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
xs.push_back({x, i});
ys.push_back({y, i});
}
sort(xs.begin(), xs.end());
sort(ys.begin(), ys.end());
// xについての辺をはる
for(int i = 1; i < N; i++) {
int x = xs[i].first, idx = xs[i].second;
int px = xs[i-1].first, pidx = xs[i-1].second;
es.push_back({idx, pidx, abs(x - px)});
es.push_back({pidx, idx, abs(x - px)});
}
// yについての辺をはる
for(int i = 1; i < N; i++) {
int y = ys[i].first, idx = ys[i].second;
int py = ys[i-1].first, pidx = ys[i-1].second;
es.push_back({idx, pidx, abs(y - py)});
es.push_back({pidx, idx, abs(y - py)});
}
sort(es.begin(), es.end(), comp);
init_unionfind(N+1);
int ans = 0;
for(int i = 0; i < es.size() ;i++) {
if(!same(es[i].from, es[i].to)){
unite(es[i].from, es[i].to);
ans += es[i].cost;
}
}
cout << ans << endl;
return 0;
} | a.cc: In function 'int main()':
a.cc:49:5: error: 'sort' was not declared in this scope; did you mean 'short'?
49 | sort(xs.begin(), xs.end());
| ^~~~
| short
|
s513366385 | p03682 | C++ | #include <iostream>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <numeric> // accumulate(v.begin(), v.end(), 0)
using namespace std;
#define ll long long
#define MAX_N 100000
int par[MAX_N]; // 親の番号
int rank[MAX_N];
// n要素で初期化
void init(int n){
for(int i=0; i<n; i++){
par[i] = i;
rank[i] = 0;
}
}
// 木の根を求める
int root(int x){
if(par[x] == x){ // 根
return x;
} else {
return par[x] = root(par[x]); // 経路圧縮
}
}
// xとyが同じ集合に属するか否か
bool same(int x, int y){
return root(x) == root(y);
}
// xとyの属する集合を併合
void unite(int x, int y){
x = root(x);
y = root(y);
if(x == y) return;
if(rank[x] < rank[y]){
par[x] = y;
} else {
par[y] = x;
if(rank[x] == rank[y])
rank[x]++;
}
}
struct data{
int n;
ll x;
ll y;
};
struct edge{
int p;
int q;
ll cost;
};
bool compx(data d1, data d2){
return d1.x <= d2.x;
}
bool compy(data d1, data d2){
return d1.y <= d2.y;
}
bool compe(edge e1, edge e2){
return e1.cost <= e2.cost;
}
int main(){
int N;
cin >> N;
vector<data> Dx, Dy;
for(int i=0; i<N; i++){
ll x, y;
cin >> x >> y;
data dtmp = {i, x, y};
Dx.push_back(dtmp);
Dy.push_back(dtmp);
}
sort(Dx.begin(), Dx.end(), compx);
sort(Dy.begin(), Dy.end(), compy);
vector<edge> E;
for(int i=0; i<N-1; i++){
edge etmpx = {Dx[i].n, Dx[i+1].n, Dx[i+1].x - Dx[i].x};
edge etmpy = {Dx[i].n, Dx[i+1].n, Dy[i+1].y - Dy[i].y};
E.push_back(etmpx);
E.push_back(etmpy);
}
sort(E.begin(), E.end(), compe);
init(MAX_N);
ll ans = 0;
for(int i=0; i<2*(N-1); i++){
edge e = E[i];
if(!same(e.p, e.q)){
ans += e.cost;
unite(e.p, e.q);
cout << e.p << ' ' << e.q << endl;
}
}
cout << ans << endl;
return 0;
}
| a.cc: In function 'void init(int)':
a.cc:20:5: error: reference to 'rank' is ambiguous
20 | rank[i] = 0;
| ^~~~
In file included from /usr/include/c++/14/bits/move.h:37,
from /usr/include/c++/14/bits/exception_ptr.h:41,
from /usr/include/c++/14/exception:166,
from /usr/include/c++/14/ios:41,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:43:6: error: reference to 'rank' is ambiguous
43 | if(rank[x] < rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc:43:16: error: reference to 'rank' is ambiguous
43 | if(rank[x] < rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc:47:8: error: reference to 'rank' is ambiguous
47 | if(rank[x] == rank[y])
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc:47:19: error: reference to 'rank' is ambiguous
47 | if(rank[x] == rank[y])
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc:48:7: error: reference to 'rank' is ambiguous
48 | rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:14:5: note: 'int rank [100000]'
14 | int rank[MAX_N];
| ^~~~
a.cc: At global scope:
a.cc:63:12: error: reference to 'data' is ambiguous
63 | bool compx(data d1, data d2){
| ^~~~
In file included from /usr/include/c++/14/string:53,
from /usr/include/c++/14/bits/locale_classes.h:40,
from /usr/include/c++/14/bits/ios_base.h:41,
from /usr/include/c++/14/ios:44:
/usr/include/c++/14/bits/range_access.h:344:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(initializer_list<_Tp>)'
344 | data(initializer_list<_Tp> __il) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:334:5: note: 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
334 | data(_Tp (&__array)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:323:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
323 | data(const _Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:312:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
312 | data(_Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
a.cc:52:8: note: 'struct data'
52 | struct data{
| ^~~~
a.cc:63:21: error: reference to 'data' is ambiguous
63 | bool compx(data d1, data d2){
| ^~~~
/usr/include/c++/14/bits/range_access.h:344:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(initializer_list<_Tp>)'
344 | data(initializer_list<_Tp> __il) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:334:5: note: 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
334 | data(_Tp (&__array)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:323:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
323 | data(const _Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:312:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
312 | data(_Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
a.cc:52:8: note: 'struct data'
52 | struct data{
| ^~~~
a.cc:63:28: error: expression list treated as compound expression in initializer [-fpermissive]
63 | bool compx(data d1, data d2){
| ^
a.cc:66:12: error: reference to 'data' is ambiguous
66 | bool compy(data d1, data d2){
| ^~~~
/usr/include/c++/14/bits/range_access.h:344:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(initializer_list<_Tp>)'
344 | data(initializer_list<_Tp> __il) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:334:5: note: 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
334 | data(_Tp (&__array)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:323:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
323 | data(const _Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:312:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
312 | data(_Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
a.cc:52:8: note: 'struct data'
52 | struct data{
| ^~~~
a.cc:66:21: error: reference to 'data' is ambiguous
66 | bool compy(data d1, data d2){
| ^~~~
/usr/include/c++/14/bits/range_access.h:344:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(initializer_list<_Tp>)'
344 | data(initializer_list<_Tp> __il) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:334:5: note: 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
334 | data(_Tp (&__array)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:323:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
323 | data(const _Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:312:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
312 | data(_Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
a.cc:52:8: note: 'struct data'
52 | struct data{
| ^~~~
a.cc:66:28: error: expression list treated as compound expression in initializer [-fpermissive]
66 | bool compy(data d1, data d2){
| ^
a.cc: In function 'int main()':
a.cc:76:14: error: template argument 1 is invalid
76 | vector<data> Dx, Dy;
| ^
a.cc:76:14: error: template argument 2 is invalid
a.cc:80:5: error: reference to 'data' is ambiguous
80 | data dtmp = {i, x, y};
| ^~~~
/usr/include/c++/14/bits/range_access.h:344:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(initializer_list<_Tp>)'
344 | data(initializer_list<_Tp> __il) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:334:5: note: 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
334 | data(_Tp (&__array)[_Nm]) noexcept
| ^~~~
/usr/include/c++/14/bits/range_access.h:323:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
323 | data(const _Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
/usr/include/c++/14/bits/range_access.h:312:5: note: 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
312 | data(_Container& __cont) noexcept(noexcept(__cont.data()))
| ^~~~
a.cc:52:8: note: 'struct data'
52 | struct data{
| ^~~~
a.cc:81:8: error: request for member 'push_back' in 'Dx', which is of non-class type 'int'
81 | Dx.push_back(dtmp);
| ^~~~~~~~~
a.cc:81:18: error: 'dtmp' was not declared in this scope; did you mean 'tm'?
81 | Dx.push_back(dtmp);
| ^~~~
| tm
a.cc:82:8: error: request for member 'push_back' in 'Dy', which is of non-class type 'int'
82 | Dy.push_back(dtmp);
| ^~~~~~~~~
a.cc:84:11: error: request for member 'begin' in 'Dx', which is of non-class type 'int'
84 | sort(Dx.begin(), Dx.end(), compx);
| ^~~~~
a.cc:84:23: error: request for member 'end' in 'Dx', which is of non-class type 'int'
84 | sort(Dx.begin(), Dx.end(), compx);
| ^~~
a.cc:85:11: error: request for member 'begin' in 'Dy', which is of non-class type 'int'
85 | sort(Dy.begin(), Dy.end(), compy);
| ^~~~~
a.cc:85:23: error: request for member 'end' in 'Dy', which is of non-class type 'int'
85 | sort(Dy.begin(), Dy.end(), compy);
| ^~~
a.cc:89:21: error: invalid types 'int[int]' for array subscript
89 | edge etmpx = {Dx[i].n, Dx[i+1].n, Dx[i+1].x - Dx[i].x};
| |
s041124546 | p03682 | C++ | #include <bits/stdc++.h>
#define rep(n) for(int i=0;i<n;i++)
#define repp(j, n) for(int j=0;j<n;j++)
#define reppp(i, m, n) for(int i=m;i<n;i++)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
class UnionFind {
public:
int n;
vector<int> par, rank;
UnionFind(int n) {
rep(n) {
par.push_back(i);
rank.push_back(0);
}
}
int find(int x) {
return ((par[x] == x) ? x : par[x] = find(par[x]));
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] < rank[y]){
par[x] = y;
}else{
par[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
return;
}
bool is_same(int x, int y) {
return find(x) == find(y);
}
};
struct Edge{
int from, to; ll cost;
Edge(int from, int to, ll cost){
this->from = from;
this->to = to;
this->cost = cost;
}
bool operator<(const Edge &e) const{
return cost < e.cost;
}
};
class Graph{
public:
int V,E;
vector<Edge> edges;
Graph(int n, vector<Pll> x, vector<Pll> y){
V = 2*n;
E = 2*n-2;
rep(n-1){
edges.push_back(Edge(x[i+1].second, x[i].second, x[i+1].first - x[i].first));
edges.push_back(Edge(y[i+1].second, y[i].second, y[i+1].first - y[i].first));
}
}
ll kruskal(){
ll ret = 0LL;
UnionFind uf = UnionFind(V);
sort(all(edges));
for(Edge e: edges){
if(!uf.is_same(e.from, e.to)){
ret += e.cost;
uf.unite(e.from, e.to);
}
}
return ret;
}
};
int main(){
int n;
cin >> n;
vector< pair<ll, int> > x(n), y(n);
rep(i){
cin >> x[i].first >> y[i].first;
x[i].second = i;
y[i].second = i;
}
sort(all(x)); sort(all(y));
Graph g = Graph(n, x, y);
cout << g.kruskal() << endl;
}
| a.cc: In function 'int main()':
a.cc:103:28: error: no matching function for call to 'Graph::Graph(int&, std::vector<std::pair<long long int, int> >&, std::vector<std::pair<long long int, int> >&)'
103 | Graph g = Graph(n, x, y);
| ^
a.cc:68:5: note: candidate: 'Graph::Graph(int, std::vector<std::pair<long long int, long long int> >, std::vector<std::pair<long long int, long long int> >)'
68 | Graph(int n, vector<Pll> x, vector<Pll> y){
| ^~~~~
a.cc:68:30: note: no known conversion for argument 2 from 'vector<pair<[...],int>>' to 'vector<pair<[...],long long int>>'
68 | Graph(int n, vector<Pll> x, vector<Pll> y){
| ~~~~~~~~~~~~^
a.cc:64:7: note: candidate: 'Graph::Graph(const Graph&)'
64 | class Graph{
| ^~~~~
a.cc:64:7: note: candidate expects 1 argument, 3 provided
a.cc:64:7: note: candidate: 'Graph::Graph(Graph&&)'
a.cc:64:7: note: candidate expects 1 argument, 3 provided
|
s415168162 | p03682 | C++ | #include <iostream>
#include <string>
#include <vector>
// #include <unordered_map>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <climits>
using namespace std;
#define SCD(t) scanf("%d",&t)
#define SCLD(t) scanf("%ld",&t)
#define SCLLD(t) scanf("%lld",&t)
#define SCC(t) scanf("%c",&t)
#define SCS(t) scanf("%s",t)
#define SCF(t) scanf("%f",&t)
#define SCLF(t) scanf("%lf",&t)
#define FOR(i, j, k) for(int i=j ; i<k ; i++)
#define RFOR(i, j, k) for(int i=j ; i>=k ; i--)
#define REP(i, j) FOR(i, 0, j)
#define RREP(i, j) RFOR(i, j, 0)
#define PI 3.1415926535897932384626433832795
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<ll> vll;
typedef vector<vi> vvi;
#define UNION_FIND_MAX_N 100005
int par[UNION_FIND_MAX_N];
int ran[UNION_FIND_MAX_N];
void init(int n){
for(int i=0; i<n; i++){
par[i] = i;
ran[i] = 0;
}
}
int find(int x){
if( par[x] == x ) return x;
else return par[x] = find(par[x]);
}
void unite(int x, int y){
x = find(x);
y = find(y);
if( x == y ) return;
if( ran[x] < ran[y] ){
par[x] = y;
} else {
par[y] = x;
if( ran[x] == ran[y] ) ran[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
#include "union_find.cpp"
#include <algorithm>
using namespace std;
#define MAX_E 200010
struct edge {
long long u, v, cost;
edge(){};
edge(long long a, long long b, long long c){
u = a;
v = b;
cost = c;
}
};
bool comp(const edge& e1, const edge& e2) {
return e1.cost < e2.cost;
}
edge es[MAX_E];
int V, E;
long long kruskal(){
sort(es, es + E, comp);
init(V);
long long res = 0;
for (int i = 0; i < E; i++) {
edge e = es[i];
if (!same(e.u, e.v)) {
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
#define INF (1<<31)
int main() {
int N; cin >> N;
vector<pii> pa(N), pb(N);
REP(i, N) {
int a, b;
cin >> a >> b;
pa[i] = make_pair(a, i);
pb[i] = make_pair(b, i);
}
sort(pa.begin(), pa.end());
sort(pb.begin(), pb.end());
REP(i, N-1) {
es[i] = edge(pa[i].second, pa[i+1].second, pa[i+1].first-pa[i].first);
es[i+N] = edge(pb[i].second, pb[i+1].second, pb[i+1].first-pb[i].first);
}
V = N;
E = N*2;
ll res = kruskal();
cout << res << endl;
return 0;
}
| a.cc:82:10: fatal error: union_find.cpp: No such file or directory
82 | #include "union_find.cpp"
| ^~~~~~~~~~~~~~~~
compilation terminated.
|
s511628331 | p03682 | C++ | #include <iostream>
#include <string>
#include <vector>
// #include <unordered_map>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <climits>
using namespace std;
#define SCD(t) scanf("%d",&t)
#define SCLD(t) scanf("%ld",&t)
#define SCLLD(t) scanf("%lld",&t)
#define SCC(t) scanf("%c",&t)
#define SCS(t) scanf("%s",t)
#define SCF(t) scanf("%f",&t)
#define SCLF(t) scanf("%lf",&t)
#define FOR(i, j, k) for(int i=j ; i<k ; i++)
#define RFOR(i, j, k) for(int i=j ; i>=k ; i--)
#define REP(i, j) FOR(i, 0, j)
#define RREP(i, j) RFOR(i, j, 0)
#define PI 3.1415926535897932384626433832795
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<ll> vll;
typedef vector<vi> vvi;
#include "union_find.cpp"
#include <algorithm>
using namespace std;
#define MAX_E 200010
struct edge {
long long u, v, cost;
edge(){};
edge(long long a, long long b, long long c){
u = a;
v = b;
cost = c;
}
};
bool comp(const edge& e1, const edge& e2) {
return e1.cost < e2.cost;
}
edge es[MAX_E];
int V, E;
long long kruskal(){
sort(es, es + E, comp);
init(V);
long long res = 0;
for (int i = 0; i < E; i++) {
edge e = es[i];
if (!same(e.u, e.v)) {
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
#define INF (1<<31)
int main() {
int N; cin >> N;
vector<pii> pa(N), pb(N);
REP(i, N) {
int a, b;
cin >> a >> b;
pa[i] = make_pair(a, i);
pb[i] = make_pair(b, i);
}
sort(pa.begin(), pa.end());
sort(pb.begin(), pb.end());
REP(i, N-1) {
es[i] = edge(pa[i].second, pa[i+1].second, pa[i+1].first-pa[i].first);
es[i+N] = edge(pb[i].second, pb[i+1].second, pb[i+1].first-pb[i].first);
}
V = N;
E = N*2;
ll res = kruskal();
cout << res << endl;
return 0;
}
| a.cc:49:10: fatal error: union_find.cpp: No such file or directory
49 | #include "union_find.cpp"
| ^~~~~~~~~~~~~~~~
compilation terminated.
|
s763148577 | p03682 | C++ | sort(ALL(x));
sort(ALL(y));
REP(i, N - 1) {
// x
int tmp1, tmp2, from, to, cost;
tie(tmp1, tmp2, from) = x[i];
tie(tmp2, cost, to) = x[i + 1];
e.emplace_back(Edge(from, to, abs(tmp2 - tmp1)));
}
REP(i, N) {
// y
int tmp1, tmp2, from, to, cost;
tie(tmp1, tmp2, from) = y[i];
tie(tmp2, cost, to) = y[i + 1];
e.emplace_back(Edge(from, to, abs(tmp2 - tmp1)));
}
int ans = kruscal();
cout << ans << endl;
return 0;
}
| a.cc:1:7: error: expected constructor, destructor, or type conversion before '(' token
1 | sort(ALL(x));
| ^
a.cc:2:7: error: expected constructor, destructor, or type conversion before '(' token
2 | sort(ALL(y));
| ^
a.cc:4:6: error: expected constructor, destructor, or type conversion before '(' token
4 | REP(i, N - 1) {
| ^
a.cc:12:6: error: expected constructor, destructor, or type conversion before '(' token
12 | REP(i, N) {
| ^
a.cc:20:13: error: 'kruscal' was not declared in this scope
20 | int ans = kruscal();
| ^~~~~~~
a.cc:21:3: error: 'cout' does not name a type
21 | cout << ans << endl;
| ^~~~
a.cc:23:3: error: expected unqualified-id before 'return'
23 | return 0;
| ^~~~~~
a.cc:24:1: error: expected declaration before '}' token
24 | }
| ^
|
s893106946 | p03682 | C++ | # include <iostream>
# include <algorithm>
#include <array>
# include <cassert>
#include <cctype>
#include <climits>
#include <numeric>
# include <vector>
# include <string>
# include <set>
# include <map>
# include <cmath>
# include <iomanip>
# include <functional>
# include <tuple>
# include <utility>
# include <stack>
# include <queue>
# include <list>
# include <bitset>
# include <complex>
# include <chrono>
# include <random>
# include <limits.h>
# include <unordered_map>
# include <unordered_set>
# include <deque>
# include <cstdio>
# include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include <cstdint>
#include <cfenv>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
constexpr long long MOD = 1000000000 + 7;
constexpr long long INF = std::numeric_limits<long long>::max();
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr<<#x<<": "<<x<<'\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll { LL first, second, third; };
typedef pair<LL, Tll> Ptll;
#define rep(i,rept) for(LL i=0;i<rept;i++)
#define Mfor(i,mf) for(LL i=mf-1;i>=0;i--)
LL h, w, n, m, k, s, t, q, sum, last, cnt, ans;
vector<Tll>a;
string str,ss;
struct Edge { LL cost, from, to; };
vector<Edge>vec;
bool f;
char c;
int par[100010];
int find(int x) { if (par[x] == x)return x; par[x] = find(par[x]); return par[x]; }
void unite(int x, int y) { x = find(x); y = find(y); if (x == y)return; par[x] = y; }
bool same(int x, int y) { return find(x) == find(y); }
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main() {
for (int i = 0; i < 100010; i++)par[i] = i;
cin >> n;
rep(i, n) {
LL x, y, z;
cin >> x >> y;
z = i;
a.push_back(Tll{ x,y,z });
}
sort(a.begin(), a.end());
rep(i, n - 1) {
vec.push_back(Edge{ abs(a[i + 1].first - a[i].first),a[i].third,a[i + 1].third });
}
sort(a.begin(), a.end());
rep(i, n - 1) {
vec.push_back(Edge{ abs(a[i + 1].second - a[i].second),a[i].third,a[i + 1].third });
}
sort(vec.begin(), vec.end());
rep(i, vec.size()) {
LL v = vec[i].from, u = vec[i].to;
if (!same(v, u)) {
unite(v, u);
ans += vec[i].cost;
}
}
cout << ans << endl;
return 0;
} | In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
from /usr/include/c++/14/string:51,
from /usr/include/c++/14/bits/locale_classes.h:40,
from /usr/include/c++/14/bits/ios_base.h:41,
from /usr/include/c++/14/ios:44,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<Tll*, std::vector<Tll> >; _Iterator2 = __gnu_cxx::__normal_iterator<Tll*, std::vector<Tll> >]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18: required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >]'
4772 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:87:6: required from here
87 | sort(a.begin(), a.end());
| ~~~~^~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:45:23: error: no match for 'operator<' (operand types are 'Tll' and 'Tll')
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
In file included from /usr/include/c++/14/string:48:
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
1241 | operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Tll' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
1249 | operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Tll' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >; _Iterator2 = __gnu_cxx::__normal_iterator<Edge*, std::vector<Edge> >]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18: required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<Edge*, vector<Edge> >]'
4772 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:95:6: required from here
95 | sort(vec.begin(), vec.end());
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:45:23: error: no match for 'operator<' (operand types are 'Edge' and 'Edge')
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_IteratorL, _Container>&, const __normal_iterator<_IteratorR, _Container>&)'
1241 | operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_IteratorL, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: candidate: 'template<class _Iterator, class _Container> bool __gnu_cxx::operator<(const __normal_iterator<_Iterator, _Container>&, const __normal_iterator<_Iterator, _Container>&)'
1249 | operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
| ^~~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1249:5: note: template argument deduction/substitution failed:
/usr/include/c++/14/bits/predefined_ops.h:45:23: note: 'Edge' is not derived from 'const __gnu_cxx::__normal_iterator<_Iterator, _Container>'
45 | { return *__it1 < *__it2; }
| ~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Val_less_iter::operator()(_Value&, _Iterator) const [with _Value = Tll; _Iterator = __gnu_cxx::__normal_iterator<Tll*, std::vector<Tll> >]':
/usr/include/c++/14/bits/stl_algo.h:1757:20: required from 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Val_less_iter]'
1757 | while (__comp(__val, __next))
| ~~~~~~^~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1785:36: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1785 | std::__unguarded_linear_insert(__i,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
1786 | __gnu_cxx::__ops::__val_comp_iter(__comp));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4772:18: required from 'void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<Tll*, vector<Tll> >]'
4772 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:87:6: required from here
87 | sort(a.begin(), a.end());
| ~~~~^~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:98:22: error: no match for 'operator<' (operand types are 'Tll' and 'Tll')
98 | { return __val < *__it; }
| ~~~~~~^~~~~~~
/usr/include/c++/14/bits/stl_iterator.h:1241:5: note: candidate: 'template<class _IteratorL, class _IteratorR, cla |
s566888748 | p03682 | C++ | #include <cstdio>
#include <vector>
#include <stack>
#include <iostream>
#include <string>
#include <map>
#include <queue>
#include <cassert>
#include <tuple>
using namespace std;
typedef long long ll;
const ll INF = 1e15;
using Weight = ll;
class Edge {
public:
int s, d;
Weight w;
Edge() : s(0), d(0), w(0) {}
Edge(int s, int d, Weight w) : s(s), d(d), w(w) {}
bool operator < (const Edge &e) const {
return w != e.w ? w < e.w :
s != e.s ? s < e.s :
d < e.d;
}
};
using Graph = vector<vector<Edge>>;
// 最小全域木とそのコストを返す O(ElogE)
pair<Weight, Graph> prim(Graph& g) {
vector<int> visited(g.size());
Weight cost = 0;
Graph f(g.size());
priority_queue<Edge> que;
que.push(Edge(-1, 0, 0));
while (!que.empty()) {
Edge now = que.top();
now.w *= -1;
que.pop();
if (visited[now.d])
continue;
visited[now.d] = true;
cost += now.w;
if(now.s >= 0)
f[now.s].push_back(now);
for (auto&& e : g[now.d]) {
if (!visited[e.d])
que.push(Edge(e.s, e.d, -e.w));
}
}
return make_pair(cost, f);
}
using P = pair<ll, ll>;
int main() {
ll N;
cin >> N;
Graph g(N);
vector<P> xv(N);
vector<P> yv(N);
for (int i = 0;i < N;i++) {
ll x, y;
cin >> x >> y;
xv[i] = P(x, i);
yv[i] = P(y, i);
}
sort(xv.begin(), xv.end());
sort(yv.begin(), yv.end());
for (int i = 0;i < N;i++) {
if (i > 0) {
g[xv[i].second].push_back(Edge(xv[i].second, xv[i - 1].second, abs(xv[i].first - xv[i - 1].first)));
g[yv[i].second].push_back(Edge(yv[i].second, yv[i - 1].second, abs(yv[i].first - yv[i - 1].first)));
}
if (i < N - 1) {
g[xv[i].second].push_back(Edge(xv[i].second, xv[i + 1].second, abs(xv[i].first - xv[i + 1].first)));
g[yv[i].second].push_back(Edge(yv[i].second, yv[i + 1].second, abs(yv[i].first - yv[i + 1].first)));
}
}
Weight cost;
Graph f;
tie(cost, f) = prim(g);
cout << cost << endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:69:9: error: 'sort' was not declared in this scope; did you mean 'short'?
69 | sort(xv.begin(), xv.end());
| ^~~~
| short
|
s371764499 | p03682 | C++ | #include <iostream>
#include <queue>
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#define INF (LLONG_MAX>>2)
using namespace std;
typedef long long ll;
class edge{
public:
int to;
int weight;
edge(int to, int weight){
this->to = to;
this->weight = weight;
}
};
ll minimumSpannTree(int, vector<edge>*);
int main(){
int n; cin >> n;
vector<edge> graph[n+1];
pair<int, int> xp[n+1], yp[n+1]; //(頂点番号・座標)のpair
int x, y;
for(int i=1; i<=n; i++){
cin >> x >> y;
xp[i] = make_pair(x, i);
yp[i] = make_pair(y, i);
}
//隣り合う頂点同士を探すためにソート
sort(xp+1, xp+n+1); sort(yp+1, yp+n+1);
//グラフ作成
for(int i=1; i<n; i++){
int s=xp[i].second, t=xp[i+1].second;
int weight = abs(xp[i].first-xp[i+1].first);
graph[s].push_back(edge(t, weight));
graph[t].push_back(edge(s, weight));
s=yp[i].second, t=yp[i+1].second;
weight = abs(yp[i].first-yp[i+1].first);
graph[s].push_back(edge(t, weight));
graph[t].push_back(edge(s, weight));
}
ll ans = minimumSpannTree(n, graph);
cout << ans << endl;
return 0;
}
ll minimumSpannTree(int n, vector<edge>* graph){
ll minDis[n+1];
bool added[n+1];
for(int i=1; i<=n; i++){
minDis[i] = INF;
added[i] = false;
}
priority_queue<pair<ll, int>, vector<pair<ll, int> >, greater<pair<ll, int> > > pq;
pq.push(make_pair(0, 1));//とりあえず頂点1をプッシュ
minDis[1] = 0;
ll res = 0;
while(!pq.empty()){
pair<ll, int> nowP = pq.top(); pq.pop(); //先頭要素をポップ
ll nowDis = nowP.first; int nowNode = nowP.second;
if(added[nowNode]) continue;
added[nowNode] = true;
res += nowDis;
for(int i=0; i<graph[nowNode].size(); i++){
edge e = graph[nowNode][i];
if(e.weight < minDis[e.to]){
minDis[e.to] = e.weight;
pq.push(make_pair(minDis[e.to], e.to));
}
}
}
return res;
}
| a.cc: In function 'll minimumSpannTree(int, std::vector<edge>*)':
a.cc:7:14: error: 'LLONG_MAX' was not declared in this scope
7 | #define INF (LLONG_MAX>>2)
| ^~~~~~~~~
a.cc:63:17: note: in expansion of macro 'INF'
63 | minDis[i] = INF;
| ^~~
a.cc:7:1: note: 'LLONG_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
6 | #include <cmath>
+++ |+#include <climits>
7 | #define INF (LLONG_MAX>>2)
|
s554938717 | p03682 | C++ | #include <iostream>
#include<cstdlib>
#include<queue>
#include<set>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<map>
#include<cstdio>
using namespace std;
#define rep(i,a) for(int i=0;i<a;i++)
#define mp make_pair
#define pb push_back
#define ll __int64
//#define ll long long
#define P pair<ll,ll>
int n,m,r;
ll x[110000],y[110000];
P t[110000],t2[110000];
vector<P>G[110000];//to,cost
bool used[110000];
ll dist[110000];
priority_queue<P,vector<P>,greater<P> >bfs;
int main(){
cin>>n;
rep(i,n){
cin>>x[i]>>y[i];
x[i]--;
y[i]--;
}
rep(i,n){
t[i]=mp(x[i],i);
t2[i]=mp(y[i],i);
}
sort(t,t+n);
sort(t2,t2+n);
ll ans=0;
for(int i=1;i<n;i++){
ll a=t[i].second,b=t[i-1].second,c=abs(t[i].first-t[i-1].first);
G[a].push_back(mp(b,c));
G[b].push_back(mp(a,c));
//cout<<a<<" "<<b<<" "<<c<<endl;
a=t2[i].second,b=t2[i-1].second,c=abs(t2[i].first-t2[i-1].first);
G[a].push_back(mp(b,c));
G[b].push_back(mp(a,c));
}
/*
rep(i,n){
if(G[i].size()>0){
cout<<i<<":";
rep(j,G[i].size())cout<<G[i][j].first<<" ";
cout<<endl;
}
}*/
bfs.push(mp(0,0));//cost,number
while(!bfs.empty()){
ll next=bfs.top().second,cost=bfs.top().first;
bfs.pop();
if(used[next])continue;
used[next]=1;
ans+=cost;
//cout<<next<<" "<<cost<<endl;
rep(i,G[next].size()){
bfs.push(mp(G[next][i].second,G[next][i].first));
}
}
cout<<ans<<endl;
return 0;
} | a.cc:16:12: error: '__int64' does not name a type; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:21:1: note: in expansion of macro 'll'
21 | ll x[110000],y[110000];
| ^~
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:16: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:22:1: note: in expansion of macro 'P'
22 | P t[110000],t2[110000];
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:19: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:22:1: note: in expansion of macro 'P'
22 | P t[110000],t2[110000];
| ^
a.cc:18:21: error: template argument 1 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:22:1: note: in expansion of macro 'P'
22 | P t[110000],t2[110000];
| ^
a.cc:18:21: error: template argument 2 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:22:1: note: in expansion of macro 'P'
22 | P t[110000],t2[110000];
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:16: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:23:8: note: in expansion of macro 'P'
23 | vector<P>G[110000];//to,cost
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:19: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:23:8: note: in expansion of macro 'P'
23 | vector<P>G[110000];//to,cost
| ^
a.cc:18:21: error: template argument 1 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:23:8: note: in expansion of macro 'P'
23 | vector<P>G[110000];//to,cost
| ^
a.cc:18:21: error: template argument 2 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:23:8: note: in expansion of macro 'P'
23 | vector<P>G[110000];//to,cost
| ^
a.cc:23:9: error: template argument 1 is invalid
23 | vector<P>G[110000];//to,cost
| ^
a.cc:23:9: error: template argument 2 is invalid
a.cc:16:12: error: '__int64' does not name a type; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:25:1: note: in expansion of macro 'll'
25 | ll dist[110000];
| ^~
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:16: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:16: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:19: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:16: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 1 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:16: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 2 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:16: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:16: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:25: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:19: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:25: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 1 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:25: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 2 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:25: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:26:26: error: template argument 1 is invalid
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:26:26: error: template argument 2 is invalid
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:16: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:36: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:18:19: note: in expansion of macro 'll'
18 | #define P pair<ll,ll>
| ^~
a.cc:26:36: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 1 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:36: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:18:21: error: template argument 2 is invalid
18 | #define P pair<ll,ll>
| ^
a.cc:26:36: note: in expansion of macro 'P'
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:26:37: error: template argument 1 is invalid
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:26:39: error: template argument 1 is invalid
26 | priority_queue<P,vector<P>,greater<P> >bfs;
| ^
a.cc:26:39: error: template argument 2 is invalid
a.cc:26:39: error: template argument 3 is invalid
a.cc: In function 'int main()':
a.cc:31:6: error: 'x' was not declared in this scope
31 | cin>>x[i]>>y[i];
| ^
a.cc:31:12: error: 'y' was not declared in this scope
31 | cin>>x[i]>>y[i];
| ^
a.cc:36:9: error: 'x' was not declared in this scope
36 | t[i]=mp(x[i],i);
| ^
a.cc:37:10: error: 'y' was not declared in this scope
37 | t2[i]=mp(y[i],i);
| ^
a.cc:16:12: error: '__int64' was not declared in this scope; did you mean '__int64_t'?
16 | #define ll __int64
| ^~~~~~~
a.cc:42:1: note: in expansion of macro 'll'
42 | ll ans=0;
| ^~
a.cc:45:12: error: expected ';' before 'a'
45 | ll a=t[i].second,b=t[i-1].second,c=abs(t[i].first-t[i-1].first);
| ^
a.cc:46:11: error: 'a' was not declared in this scope
46 | G[a].push_back(mp(b,c));
| ^
a.cc:46:27: error: 'b' was not declared in this scope
46 | G[a].push_back(mp(b,c));
| ^
a.cc:46:29: error: 'c' was not declared in this scope
46 | G[a].push_back(mp(b,c));
| ^
a.cc:49:17: error: request for member 'second' in 't2[i]', which is of non-class type 'int'
49 | a=t2[i].second,b=t2[i-1].second,c=abs(t2[i].first-t2[i-1].first);
| ^~~~~~
a.cc:49:34: error: request for member 'second' in 't2[(i - 1)]', which is of non-class type 'int'
49 | a=t2[i].second,b=t2[i-1].second,c=abs(t2[i].first-t2[i-1].first);
| ^~~~~~
a.cc:49:53: error: request for member 'first' in 't2[i]', which is of non-class type 'int'
49 | a=t2[i].second,b=t2[i-1].second,c=abs(t2[i].first-t2[i-1].first);
| ^~~~~
a.cc:49:67: error: request for member 'first' in 't2[(i - 1)]', which is of non-class type 'int'
49 | a=t2[i].second,b=t2[i-1].second,c=abs(t2[i].first-t2[i-1].first);
| ^~~~~
a.cc:62:5: error: request for member 'push' in 'bfs', which is of non-class type 'int'
62 | bfs.push(mp(0,0));//cost,number
| ^~~~
a.cc:64:12: error: request for member 'empty' in 'bfs', which is of non-class type 'int'
64 | while(!bfs.empty()){
| ^~~~~
a.cc:65:12: error: expected ';' before 'next'
65 | ll next=bfs.top().second,cost=bfs.top().first;
| ^~~~
a.cc:66:13: error: request for member 'pop' in 'bfs', which is of non-class type 'int'
66 | bfs.pop();
| ^~~
a.cc:67:16: error: invalid types 'bool [110000][<unresolved overloaded function type>]' for array subscript
67 | if(used[next])continue;
| ^
a.cc:68:13: error: invalid types 'bool [110000][<unresolved overloaded function type>]' for array subscript
68 | used[next]=1;
| ^
a.cc:69:9: error: 'ans' was not declared in this scope; did you mean 'abs'?
69 | ans+=cost;
| ^~~
| abs
a.cc:69:14: error: 'cost' was not declared in this scope; did you mean 'const'?
69 | ans+=cost;
| |
s620612603 | p03682 | C++ | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF (1<<30)
#define INFLL (1ll<<60)
typedef pair<ll, int> PLI;
typedef pair<int, int> P;
typedef pair<ll, P> E;
#define cost first
#define from second.first
#define to second.second
#define MOD (1000000007ll)
#define l_ength size
void mul_mod(ll& a, ll b){
a *= b;
a %= MOD;
}
int parent[123456];
int rank[123456];
void ufinit(int n){
int i;
for(i=0; i<n; ++i){
parent[i] = i;
rank[i] = 0;
}
}
int ufind(int x){
int ans;
if(parent[x] == x){
return x;
}else{
ans = ufind(parent[x]);
parent[x] = ans;
return ans;
}
}
void unionf(int x, int y){
x = ufind(x);
y = ufind(y);
if(rank[x] > rank[y]){
parent[y] = x;
}else{
parent[x] = y;
}
if(rank[x] == rank[y]){
rank[y]++;
}
}
int main(void){
int n,i;
ll xi,yi,ans=0ll;
E e;
vector<PLI> x,y;
priority_queue< E, vector<E>, greater<E> > pq;
cin >> n;
for(i=0; i<n; ++i){
cin >> xi >> yi;
x.push_back(PLI(xi,i));
y.push_back(PLI(yi,i));
}
sort(x.begin(),x.end());
sort(y.begin(),y.end());
for(i=1; i<n; ++i){
pq.push(E(x[i].first-x[i-1].first,P(x[i-1].second,x[i].second)));
pq.push(E(y[i].first-y[i-1].first,P(y[i-1].second,y[i].second)));
}
ufinit(n);
while(!pq.empty()){
e = pq.top();
pq.pop();
if(ufind(e.from) == ufind(e.to)){
continue;
}
unionf(e.from,e.to);
ans += e.cost;
}
cout << ans << endl;
return 0;
} | a.cc: In function 'void ufinit(int)':
a.cc:27:17: error: reference to 'rank' is ambiguous
27 | rank[i] = 0;
| ^~~~
In file included from /usr/include/c++/14/bits/stl_pair.h:60,
from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
a.cc: In function 'void unionf(int, int)':
a.cc:45:12: error: reference to 'rank' is ambiguous
45 | if(rank[x] > rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
a.cc:45:22: error: reference to 'rank' is ambiguous
45 | if(rank[x] > rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
a.cc:50:12: error: reference to 'rank' is ambiguous
50 | if(rank[x] == rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
a.cc:50:23: error: reference to 'rank' is ambiguous
50 | if(rank[x] == rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
a.cc:51:17: error: reference to 'rank' is ambiguous
51 | rank[y]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:21:5: note: 'int rank [123456]'
21 | int rank[123456];
| ^~~~
|
s851106145 | p03682 | C++ | #include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
struct edge{ int u, v; ll cost; };
bool cmp(const edge& e1, const edge& e2){
return e1.cost < e2.cost;
}
int par[100000], rank[100000];
int find(int x){
if(par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return;
if(rank[x] < rank[y]) par[x] = y;
else{
par[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
int n;
P xs[100000], ys[100000];
edge es[200000];
int main(){
scanf("%d", &n);
for(int i = 0; i < n; i++){
ll x, y; scanf("%lld %lld", &x, &y);
xs[i] = P(x, i); ys[i] = P(y, i);
par[i] = i;
}
sort(xs, xs + n); sort(ys, ys + n);
for(int i = 0; i < n - 1; i++){
es[2 * i] = (edge){xs[i].second, xs[i + 1].second, xs[i + 1].first - xs[i].first};
es[2 * i + 1] = (edge){ys[i].second, ys[i + 1].second, ys[i + 1].first - ys[i].first};
}
sort(es, es + 2 * (n - 1), cmp);
ll res = 0;
for(int i = 0; i < 2 * (n - 1); i++){
if(!same(es[i].u, es[i].v)){
unite(es[i].u, es[i].v);
res += es[i].cost;
}
}
printf("%lld\n", res);
return 0;
} | a.cc: In function 'void unite(int, int)':
a.cc:25:12: error: reference to 'rank' is ambiguous
25 | if(rank[x] < rank[y]) par[x] = y;
| ^~~~
In file included from /usr/include/c++/14/bits/stl_pair.h:60,
from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from a.cc:2:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:15:18: note: 'int rank [100000]'
15 | int par[100000], rank[100000];
| ^~~~
a.cc:25:22: error: reference to 'rank' is ambiguous
25 | if(rank[x] < rank[y]) par[x] = y;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:15:18: note: 'int rank [100000]'
15 | int par[100000], rank[100000];
| ^~~~
a.cc:28:20: error: reference to 'rank' is ambiguous
28 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:15:18: note: 'int rank [100000]'
15 | int par[100000], rank[100000];
| ^~~~
a.cc:28:31: error: reference to 'rank' is ambiguous
28 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:15:18: note: 'int rank [100000]'
15 | int par[100000], rank[100000];
| ^~~~
a.cc:28:40: error: reference to 'rank' is ambiguous
28 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:15:18: note: 'int rank [100000]'
15 | int par[100000], rank[100000];
| ^~~~
|
s267141370 | p03682 | C++ |
#include<bits/stdc++.h>
using namespace std;
struct edge{
int u, v, cost;
};
struct node{
int x, y, id;
};
int pare[100000];
int trank[100000];
bool xcomp(node& x, node& y){
return x.x<y.x;
}
bool ycomp(node& x, node& y){
return x.y<y.y;
}
bool ccomp(edge& x, edge& y){
return x.cost<y.cost;
}
int find(int u){
if(u==pare[u])
return u;
return pare[u]=find(pare[u]);
}
void unite(int u, int v){
u=find(u);
v=find(v);
if(u==v)
return;
if(trank[u]<trank[v]){
pare[u]=v;
}
else{
pare[v]=u;
if(trank[u]==trank[v]){
trank[u]++;
}
}
return;
}
int main(){
int N;
cin>>N;
vector <edge> edge;
vector <node> node;
for(int i=0;i<N;i++){
int x, y;
cin>>x>>y;
node n;
n.x=x;n.y=y;n.id=i;
node.push_back(n);
pare[i]=i;
trank[i]=0;
}
sort(node.begin(), node.end(), xcomp);
for(int i=0;i<N-1;i++){
edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].x-node[i].x;
}
sort(node.begin(), node.end(), ycomp);
for(int i=0;i<N-1;i++){
Edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].y-node[i].y;
edge.push_back(e);
}
sort(edge.begin(), edge.end(), ccomp);
long long res=0;
for(int i=0;i<(int)edge.size();i++){
edge e=edge[i];
if(find(e.u)!=find(e.v)){
ans+=e.cost;
unite(e.u, e.v);
}
}
cout<<res<<endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:60:21: error: expected ';' before 'n'
60 | node n;
| ^~
| ;
a.cc:61:17: error: 'n' was not declared in this scope
61 | n.x=x;n.y=y;n.id=i;
| ^
a.cc:68:21: error: expected ';' before 'e'
68 | edge e;
| ^~
| ;
a.cc:69:17: error: 'e' was not declared in this scope
69 | e.u=node[i].id;
| ^
a.cc:75:17: error: 'Edge' was not declared in this scope; did you mean 'edge'?
75 | Edge e;
| ^~~~
| edge
a.cc:76:17: error: 'e' was not declared in this scope
76 | e.u=node[i].id;
| ^
a.cc:84:21: error: expected ';' before 'e'
84 | edge e=edge[i];
| ^~
| ;
a.cc:85:25: error: 'e' was not declared in this scope
85 | if(find(e.u)!=find(e.v)){
| ^
a.cc:86:25: error: 'ans' was not declared in this scope; did you mean 'abs'?
86 | ans+=e.cost;
| ^~~
| abs
|
s449610567 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
struct edge{
int u, v, cost;
};
struct node{
int x, y, id;
};
int pare[100000];
int trank[100000];
bool xcomp(node& x, node& y){
return x.x<y.x;
}
bool ycomp(node& x, node& y){
return x.y<y.y;
}
bool ccomp(node& x, node& y){
return x.cost<y.cost;
}
int find(int u){
if(u==pare[u])
return u;
return pare[u]=find(pare[u]);
}
void unite(int u, int v){
u=find(u);
v=find(v);
if(u==v)
return;
if(trank[u]<trank[v]){
pare[u]=v;
}
else{
pare[v]=u;
if(trank[u]==trank[v]){
trank[u]++;
}
}
return;
}
int main(){
int N;
cin>>N;
vector <edge> edge;
vector <node> node;
for(int i=0;i<N;i++){
int x, y;
cin>>x>>y;
node n;
n.x=x;n.y=y;n.id=i;
node.push_back(n);
pare[i]=i;
trank[i]=0;
}
sort(node.begin(), node.end(), xcomp);
for(int i=0;i<N-1;i++){
edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].x-node[i].x;
}
sort(node.begin(), node.end(), ycomp);
for(int i=0;i<N-1;i++){
Edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].y-node[i].y;
edge.push_back(e);
}
sort(edge.begin(), edge.end(), ccomp);
long long res=0;
for(int i=0;i<(int)edge.size();i++){
edge e=edge[i];
if(find(e.u)!=find(e.v)){
ans+=e.cost;
unite(e.u, e.v);
}
}
cout<<res<<endl;
return 0;
}
| a.cc: In function 'bool ccomp(node&, node&)':
a.cc:23:18: error: 'struct node' has no member named 'cost'
23 | return x.cost<y.cost;
| ^~~~
a.cc:23:25: error: 'struct node' has no member named 'cost'
23 | return x.cost<y.cost;
| ^~~~
a.cc: In function 'int main()':
a.cc:59:21: error: expected ';' before 'n'
59 | node n;
| ^~
| ;
a.cc:60:17: error: 'n' was not declared in this scope
60 | n.x=x;n.y=y;n.id=i;
| ^
a.cc:67:21: error: expected ';' before 'e'
67 | edge e;
| ^~
| ;
a.cc:68:17: error: 'e' was not declared in this scope
68 | e.u=node[i].id;
| ^
a.cc:74:17: error: 'Edge' was not declared in this scope; did you mean 'edge'?
74 | Edge e;
| ^~~~
| edge
a.cc:75:17: error: 'e' was not declared in this scope
75 | e.u=node[i].id;
| ^
a.cc:83:21: error: expected ';' before 'e'
83 | edge e=edge[i];
| ^~
| ;
a.cc:84:25: error: 'e' was not declared in this scope
84 | if(find(e.u)!=find(e.v)){
| ^
a.cc:85:25: error: 'ans' was not declared in this scope; did you mean 'abs'?
85 | ans+=e.cost;
| ^~~
| abs
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_comp_iter<_Compare>::operator()(_Iterator1, _Iterator2) [with _Iterator1 = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Iterator2 = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = bool (*)(node&, node&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:80:13: required from here
80 | sort(edge.begin(), edge.end(), ccomp);
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:158:30: error: invalid initialization of reference of type 'node&' from expression of type 'edge'
158 | { return bool(_M_comp(*__it1, *__it2)); }
| ~~~~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Val_comp_iter<_Compare>::operator()(_Value&, _Iterator) [with _Value = edge; _Iterator = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_algo.h:1757:20: required from 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Val_comp_iter<bool (*)(node&, node&)>]'
1757 | while (__comp(__val, __next))
| ~~~~~~^~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1785:36: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1785 | std::__unguarded_linear_insert(__i,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
1786 | __gnu_cxx::__ops::__val_comp_iter(__comp));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = bool (*)(node&, node&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:80:13: required from here
80 | sort(edge.begin(), edge.end(), ccomp);
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:240:30: error: invalid initialization of reference of type 'node&' from expression of type 'edge'
240 | { return bool(_M_comp(__val, *__it)); }
| ~~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Value = edge; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_heap.h:140:48: required from 'void std::__push_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_val<bool (*)(node&, node&)>]'
140 | while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
| ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:247:23: required from 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
247 | std::__push_heap(__first, __holeIndex, __topIndex,
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
248 | _GLIBCXX_MOVE(__value), __cmp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:356:22: required from 'void std::__make_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
356 | std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
357 | __comp);
| ~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1593:23: required from 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1593 | std::__make_heap(__first, __middle, __comp);
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1868:25: required from 'void std::__partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1868 | std::__heap_select(__first, __middle, __last, __comp);
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1884:27: required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Size = long int; _Compare = __gnu_ |
s992966165 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
struct edge{
int u, v, cost;
};
struct node{
int x, y, id;
};
int pare[100000];
int trank[100000];
bool xcomp(node& x, node& y){
return x.x<y.x;
}
bool ycomp(node& x, node& y){
return x.y<y.y;
}
bool ccomp(node& x, node& y){
return x.cost<y.cost;
}
int find(int u){
if(u==pare[u])
return u;
return pare[u]=find(pare[u]);
}
void unite(int u, int v){
u=find(u);
v=find(v);
if(u==v)
return;
if(trank[u]<trank[v]){
pare[u]=v;
}
else{
pare[v]=u;
if(trank[u]==trank[v]){
trank[u]++;
}
}
return;
}
int main(){
int N;
cin>>N;
vector <edge> edge;
vector <node> node;
for(int i=0;i<N;i++){
int x, y;
cin>>x>>y;
node n;
n.x=x;n.y=y;n.id=i;
node.push_back(n);
pare[i]=i;
trank[i]=0;
}
sort(node.begin(), node.end(), xcomp);
for(int i=0;i<N-1;i++){
edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].x-node[i].x;
}
sort(node.begin(), node.end(), ycomp);
for(int i=0;i<N-1;i++){
Edge e;
e.u=node[i].id;
e.v=node[i+1].id;
e.cost=node[i+1].y-node[i].y;
edge.push_back(e);
}
sort(edge.begin(), edge.end(), ccomp);
long long res=0;
for(int i=0;i<(int)edge.size();i++){
edge e=edge[i];
if(find(e.u)!=find(e.v)){
ans+=e.cost;
unite(e.u, e.v);
}
}
cout<<res<<endl;
return 0;
}
| a.cc: In function 'bool ccomp(node&, node&)':
a.cc:23:18: error: 'struct node' has no member named 'cost'
23 | return x.cost<y.cost;
| ^~~~
a.cc:23:25: error: 'struct node' has no member named 'cost'
23 | return x.cost<y.cost;
| ^~~~
a.cc: In function 'int main()':
a.cc:59:21: error: expected ';' before 'n'
59 | node n;
| ^~
| ;
a.cc:60:17: error: 'n' was not declared in this scope
60 | n.x=x;n.y=y;n.id=i;
| ^
a.cc:67:21: error: expected ';' before 'e'
67 | edge e;
| ^~
| ;
a.cc:68:17: error: 'e' was not declared in this scope
68 | e.u=node[i].id;
| ^
a.cc:74:17: error: 'Edge' was not declared in this scope; did you mean 'edge'?
74 | Edge e;
| ^~~~
| edge
a.cc:75:17: error: 'e' was not declared in this scope
75 | e.u=node[i].id;
| ^
a.cc:83:21: error: expected ';' before 'e'
83 | edge e=edge[i];
| ^~
| ;
a.cc:84:25: error: 'e' was not declared in this scope
84 | if(find(e.u)!=find(e.v)){
| ^
a.cc:85:25: error: 'ans' was not declared in this scope; did you mean 'abs'?
85 | ans+=e.cost;
| ^~~
| abs
In file included from /usr/include/c++/14/bits/stl_algobase.h:71,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'constexpr bool __gnu_cxx::__ops::_Iter_comp_iter<_Compare>::operator()(_Iterator1, _Iterator2) [with _Iterator1 = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Iterator2 = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_algo.h:1777:14: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1777 | if (__comp(__i, __first))
| ~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = bool (*)(node&, node&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:80:13: required from here
80 | sort(edge.begin(), edge.end(), ccomp);
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:158:30: error: invalid initialization of reference of type 'node&' from expression of type 'edge'
158 | { return bool(_M_comp(*__it1, *__it2)); }
| ~~~~~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Val_comp_iter<_Compare>::operator()(_Value&, _Iterator) [with _Value = edge; _Iterator = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_algo.h:1757:20: required from 'void std::__unguarded_linear_insert(_RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Val_comp_iter<bool (*)(node&, node&)>]'
1757 | while (__comp(__val, __next))
| ~~~~~~^~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1785:36: required from 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1785 | std::__unguarded_linear_insert(__i,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
1786 | __gnu_cxx::__ops::__val_comp_iter(__comp));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1817:25: required from 'void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1817 | std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
| ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1908:31: required from 'void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1908 | std::__final_insertion_sort(__first, __last, __comp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:4805:18: required from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = bool (*)(node&, node&)]'
4805 | std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
| ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:80:13: required from here
80 | sort(edge.begin(), edge.end(), ccomp);
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h:240:30: error: invalid initialization of reference of type 'node&' from expression of type 'edge'
240 | { return bool(_M_comp(__val, *__it)); }
| ~~~~~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/predefined_ops.h: In instantiation of 'bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = __gnu_cxx::__normal_iterator<edge*, std::vector<edge> >; _Value = edge; _Compare = bool (*)(node&, node&)]':
/usr/include/c++/14/bits/stl_heap.h:140:48: required from 'void std::__push_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_val<bool (*)(node&, node&)>]'
140 | while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
| ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:247:23: required from 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance, _Tp, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Distance = long int; _Tp = edge; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
247 | std::__push_heap(__first, __holeIndex, __topIndex,
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
248 | _GLIBCXX_MOVE(__value), __cmp);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_heap.h:356:22: required from 'void std::__make_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare&) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
356 | std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
357 | __comp);
| ~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1593:23: required from 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1593 | std::__make_heap(__first, __middle, __comp);
| ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1868:25: required from 'void std::__partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Compare = __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(node&, node&)>]'
1868 | std::__heap_select(__first, __middle, __last, __comp);
| ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:1884:27: required from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<edge*, vector<edge> >; _Size = long int; _Compare = __gnu_ |
s246724300 | p03682 | C++ | #include "Union_Find.h"
bool UnionFindTree::Is_valid_index(int index) {
return index >= 0 && index < whole_size_m;
}
int UnionFindTree::Root_of_rec(int index) {
if (parent_p_m[index] == index) {
return index;
} else {
return parent_p_m[index] = Root_of_rec(parent_p_m[index]);
}
}
UnionFindTree::UnionFindTree(int whole_size)
: whole_size_m(whole_size) {
parent_p_m = new int[whole_size_m];
rank_p_m = new int[whole_size_m];
size_p_m = new int[whole_size_m];
for (int i = 0; i < whole_size_m; ++i) {
parent_p_m[i] = i;
rank_p_m[i] = 1;
size_p_m[i] = 1;
}
}
UnionFindTree::~UnionFindTree() {
delete[] parent_p_m;
delete[] rank_p_m;
delete[] size_p_m;
}
int UnionFindTree::Root_of(int index) {
if (Is_valid_index(index) == false) return -1;
return Root_of_rec(index);
}
void UnionFindTree::Unite(int index_l, int index_r) {
if (Is_valid_index(index_l) == false || Is_valid_index(index_r) == false) return;
int root_l = Root_of(index_l);
int root_r = Root_of(index_r);
if (root_l == root_r) return;
if (rank_p_m[root_l] > rank_p_m[root_r]) {
parent_p_m[root_r] = root_l;
size_p_m[root_r] += root_l;
} else {
parent_p_m[root_l] = root_r;
size_p_m[root_l] += root_r;
if (rank_p_m[root_l] == rank_p_m[root_r]) ++rank_p_m[root_r];
}
}
bool UnionFindTree::Are_together(int index_l, int index_r) {
return Root_of(index_l) == Root_of(index_r);
}
int UnionFindTree::Size_of_set(int index) {
return size_p_m[index];
}
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <sstream>
using namespace std;
#define REP(i,a,n) for(int i = a; i < (int)(n); ++i)
#define REPM(i,n,a) for(int i = n - 1; i >= a; --i)
#define EPS 0.0001
#define INF 0x3FFFFFFF
#define INFLL 0x3FFFFFFF3FFFFFFF
#define INFD 1.0e+308
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<LL, LL> PP;
#if 1
#include <unordered_set>
#include <unordered_map>
template<typename T>
using PriorityQ = priority_queue<T, vector<T>, greater<T> >;
#endif
int N;
int A[100001], B[100001];
PP PA[100001], PB[100001];
PriorityQ<pair<int, PP> > Q;
int main() {
cin >> N;
REP(i, 0, N) {
cin >> A[i] >> B[i];
PA[i] = PP(A[i], i);
PB[i] = PP(B[i], i);
}
sort(PA, PA + N);
sort(PB, PB + N);
REP(i, 0, N - 1) {
Q.push(make_pair(PA[i + 1].first - PA[i].first, PP(PA[i + 1].second, PA[i].second)));
Q.push(make_pair(PB[i + 1].first - PB[i].first, PP(PB[i + 1].second, PB[i].second)));
}
UnionFindTree U(N);
LL sum = 0;
while (!Q.empty()) {
auto cp = Q.top(); Q.pop();
int c = cp.first;
PP p = cp.second;
int l = p.first;
int r = p.second;
if (!U.Are_together(l, r)) {
U.Unite(l, r);
sum += c;
}
}
cout << sum << endl;
return 0;
}
| a.cc:1:10: fatal error: Union_Find.h: No such file or directory
1 | #include "Union_Find.h"
| ^~~~~~~~~~~~~~
compilation terminated.
|
s692300553 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
const int MAX_N = 100001;
struct edge {int u,v,cost;};
typedef struct edge edge;
vector<edge> es;
bool comp(const edge& e1,const edge& e2){
return e1.cost<e2.cost;
}
bool comp1(pair<int,int> p1,pair<int,int> p2){
return p1.first<p2.first;
}
bool comp2(pair<int,int> p1,pair<int,int> p2){
return p1.second<p2.second;
}
int par[MAX_N];
int rank[MAX_N];
void init (int n){
for(int i=0;i<n;i++){
par[i]=i;
rank[i]=0;
}
}
int find (int x){
if(par[x] == x){
return x;
}else{
return par[x]=find(par[x]);
}
}
void unite(int x,int y){
x=find(x);
y=find(y);
if(x==y) return;
if(rank[x]<rank[y]){
par[x] = y;
}else{
par[y]=x;
if(rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x,int y){
return find(x)==find(y);
}
int kruskal(int V,int E){
sort(es.begin(),es.end(),comp);
init(V);
int res=0;
for(int i=0;i<E;i++){
edge e=es[i];
if(!same(e.u,e.v)){
unite(e.u,e.v);
res += e.cost;
}
}
return res;
}
int main (){
int n;
cin >> n;
vector<pair<int,int> > xy;
for(int i=0;i<n;i++){
int t1,t2;
cin >> t1 >> t2 ;
xy.push_back(make_pair(t1,t2));
}
sort(xy.begin(),xy.end(),comp1);
for(int i=0;i<n;i++){
int p,next;
p=i-1;
next=i+1;
if(p>=0){
edge t1;
t1.u = p;
t1.v = i;
t1.cost = abs(xy[i].first-xy[p].first);
es.push_back(t1);
}
if(next<n){
edge t;
t.u = i;
t.v = next;
t.cost = abs(xy[i].first-xy[next].first);
es.push_back(t);
}
}
sort(xy.begin(),xy.end(),comp2);
for(int i=0;i<n;i++){
cout<<xy[i].first<<" "<<xy[i].second<<endl;
}
for(int i=0;i<n;i++){
int p,next;
p=i-1;
next=i+1;
if(p>=0){
edge t;
t.u = p;
t.v = i;
t.cost = abs(xy[i].second-xy[p].second);
es.push_back(t);
}
if(next<n){
edge t;
t.u = i;
t.v = next;
t.cost = abs(xy[i].second-xy[next].second);
es.push_back(t);
}
}
//cout<<es.size()<<endl;
//V = n;
//E = ((n-2)*2+2)*2;
cout<<kruskal(n,es.size())<<endl;
return 0;
}
| a.cc: In function 'void init(int)':
a.cc:24:5: error: reference to 'rank' is ambiguous
24 | rank[i]=0;
| ^~~~
In file included from /usr/include/c++/14/bits/stl_pair.h:60,
from /usr/include/c++/14/bits/stl_algobase.h:64,
from /usr/include/c++/14/algorithm:60,
from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:40:6: error: reference to 'rank' is ambiguous
40 | if(rank[x]<rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
a.cc:40:14: error: reference to 'rank' is ambiguous
40 | if(rank[x]<rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
a.cc:44:8: error: reference to 'rank' is ambiguous
44 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
a.cc:44:19: error: reference to 'rank' is ambiguous
44 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
a.cc:44:28: error: reference to 'rank' is ambiguous
44 | if(rank[x] == rank[y]) rank[x]++;
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:20:5: note: 'int rank [100001]'
20 | int rank[MAX_N];
| ^~~~
|
s524811344 | p03682 | C++ | #include <iostream>
#include <vector>
#include <numeric>
using namespace std;
class Edge {
public:
int from;
int to;
int cost;
Edge(int from, int to, int cost): from{from}, to{to}, cost{cost} {}
bool operator<(const Edge& other) const {
return this->cost < other.cost;
}
bool operator>(const Edge& other) const {
return this->cost > other.cost;
}
};
class UnionFindTree {
public:
vector<int> parent;
UnionFindTree(int size) {
parent.resize((unsigned long) (size + 1));
iota(parent.begin(), parent.end(), 0);
}
bool isSameSet(int x, int y) {
return findRoot(x) == findRoot(y);
}
void unionSet(int x, int y) {
int xRoot { findRoot(x) };
int yRoot { findRoot(y) };
if (xRoot == yRoot) { return; }
parent[xRoot] = yRoot;
}
int getNumberOfSet() {
int n = 0;
for (int i = 0; parent.size(); ++i) {
if (parent[i] == i) { n++; }
}
return n;
}
private:
int findRoot(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = findRoot(parent[x]);
}
};
int kruskal(int v, vector<Edge>& edges) {
sort(edges.begin(), edges.end());
UnionFindTree uf(v);
int res { 0 };
for (auto& e : edges) {
if (!uf.isSameSet(e.from, e.to)) {
uf.unionSet(e.from, e.to);
res += e.cost;
}
}
return res;
}
int main() {
int N;
cin >> N;
vector<pair<int, int>> xList((unsigned long) N);
vector<pair<int, int>> yList((unsigned long) N);
for (int i { 0 }; i < N; ++i) {
int x, y;
cin >> x >> y;
xList[i] = { x, i };
yList[i] = { y, i };
}
sort(xList.begin(), xList.end());
sort(yList.begin(), yList.end());
vector<Edge> edges;
for (int i { 1 }; i < N; ++i) {
edges.push_back(Edge(xList[i - 1].second, xList[i].second, abs(xList[i - 1].first - xList[i].first)));
edges.push_back(Edge(xList[i].second, xList[i + 1].second, abs(xList[i].first - xList[i + 1].first)));
edges.push_back(Edge(yList[i - 1].second, yList[i].second, abs(yList[i - 1].first - yList[i].first)));
edges.push_back(Edge(yList[i].second, yList[i + 1].second, abs(yList[i].first - yList[i + 1].first)));
}
cout << kruskal(N, edges) << endl;
return 0;
}
| a.cc: In function 'int kruskal(int, std::vector<Edge>&)':
a.cc:61:5: error: 'sort' was not declared in this scope; did you mean 'short'?
61 | sort(edges.begin(), edges.end());
| ^~~~
| short
a.cc: In function 'int main()':
a.cc:85:5: error: 'sort' was not declared in this scope; did you mean 'short'?
85 | sort(xList.begin(), xList.end());
| ^~~~
| short
|
s490533664 | p03682 | C++ | #include <climits>
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAX_X_Y 1000000000
#define MAX_N 100000
class Node
{
public:
int x, y, index, cost = MAX_X_Y;;
bool used = false;
};
int A[MAX_N][MAX_N] = {};
Node *nodes = new Node[MAX_N];
int prim(int n)
{
int i, u, v, minv, sum = 0;
nodes[0].cost = 0;
while (true) {
u = -1; minv = MAX_X_Y;
for (i = 0; i < n; i++) {
if (nodes[i].cost < minv && !nodes[i].used) {
u = i;
minv = nodes[i].cost;
}
}
if (-1 == u) break;
nodes[u].used = true;
sum += nodes[u].cost;
for (v = 0; v < n; v++) {
if (!nodes[v].used && A[u][v] != 0) {
nodes[v].cost = A[u][v] < nodes[v].cost ? A[u][v] : nodes[v].cost;
}
}
}
return sum;
}
bool xsort(Node a, Node b)
{
if (a.x < b.x) return true;
else return false;
}
bool ysort(Node a, Node b)
{
if (a.y < b.y) return true;
else return false;
}
void build_table(int n)
{
Node *xsorted = new Node[n];
Node *ysorted = new Node[n];
memcpy(xsorted, nodes, sizeof(Node) * n);
memcpy(ysorted, nodes, sizeof(Node) * n);
sort(xsorted, xsorted + n, xsort);
sort(ysorted, ysorted + n, ysort);
/*
cout << "xsorted:" << endl;
for (int i = 0; i < n; i++) {
cout << xsorted[i].x << " " << xsorted[i].y << endl;
}
cout << "ysorted:" << endl;
for (int i = 0; i < n; i++) {
cout << ysorted[i].x << " " << ysorted[i].y << endl;
}
*/
for (int i = 1; i < n - 1; i++) {
A[xsorted[i].index][xsorted[i - 1].index] = A[xsorted[i].index][xsorted[i - 1].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i].index][xsorted[i - 1].index]);
A[xsorted[i - 1].index][xsorted[i].index] = A[xsorted[i - 1].index][xsorted[i].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i - 1].index][xsorted[i].index]);
A[xsorted[i + 1].index][xsorted[i].index] = A[xsorted[i + 1].index][xsorted[i].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i + 1].index][xsorted[i].index]);
A[xsorted[i].index][xsorted[i + 1].index] = A[xsorted[i].index][xsorted[i + 1].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i].index][xsorted[i + 1].index]);
A[ysorted[i].index][ysorted[i - 1].index] = A[ysorted[i].index][ysorted[i - 1].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i].index][ysorted[i - 1].index]);
A[ysorted[i - 1].index][ysorted[i].index] = A[ysorted[i - 1].index][ysorted[i].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i - 1].index][ysorted[i].index]);
A[ysorted[i + 1].index][ysorted[i].index] = A[ysorted[i + 1].index][ysorted[i].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i + 1].index][ysorted[i].index]);
A[ysorted[i].index][ysorted[i + 1].index] = A[ysorted[i].index][ysorted[i + 1].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i].index][ysorted[i + 1].index]);
}
}
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++) {
nodes[i].index = i;
cin >> nodes[i].x >> nodes[i].y;
}
build_table(n);
/* for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << " " << A[i][j];
}
cout << endl;
}
*/
cout << prim(n) << endl;
return 0;
} | /tmp/ccCtRh7A.o: in function `prim(int)':
a.cc:(.text+0x11): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x36): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x5c): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x8b): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0xc9): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0xeb): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x11b): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x19e): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x1ec): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
a.cc:(.text+0x20d): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccCtRh7A.o
/tmp/ccCtRh7A.o: in function `build_table(int)':
a.cc:(.text+0x37a): additional relocation overflows omitted from the output
collect2: error: ld returned 1 exit status
|
s752739979 | p03682 | C++ | #include <climits>
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAX_X_Y 1000000000
#define MAX_N 100000
class Node
{
public:
int x, y, index, cost = MAX_X_Y;;
bool used = false;
};
int n;
int A[MAX_N][MAX_N] = {};
Node *nodes = new Node[MAX_N];
int prim()
{
int i, u, v, minv, sum = 0;
nodes[0].cost = 0;
while (true) {
u = -1; minv = MAX_X_Y;
for (i = 0; i < n; i++) {
if (nodes[i].cost < minv && !nodes[i].used) {
u = i;
minv = nodes[i].cost;
}
}
if (-1 == u) break;
nodes[u].used = true;
sum += nodes[u].cost;
for (v = 0; v < n; v++) {
if (!nodes[v].used && A[u][v] != 0) {
nodes[v].cost = A[u][v] < nodes[v].cost ? A[u][v] : nodes[v].cost;
}
}
}
return sum;
}
bool xsort(Node a, Node b)
{
if (a.x < b.x) return true;
else return false;
}
bool ysort(Node a, Node b)
{
if (a.y < b.y) return true;
else return false;
}
void build_table()
{
Node *xsorted = new Node[n];
Node *ysorted = new Node[n];
memcpy(xsorted, nodes, sizeof(Node) * n);
memcpy(ysorted, nodes, sizeof(Node) * n);
sort(xsorted, xsorted + n, xsort);
sort(ysorted, ysorted + n, ysort);
/*
cout << "xsorted:" << endl;
for (int i = 0; i < n; i++) {
cout << xsorted[i].x << " " << xsorted[i].y << endl;
}
cout << "ysorted:" << endl;
for (int i = 0; i < n; i++) {
cout << ysorted[i].x << " " << ysorted[i].y << endl;
}
*/
for (int i = 1; i < n - 1; i++) {
A[xsorted[i].index][xsorted[i - 1].index] = A[xsorted[i].index][xsorted[i - 1].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i].index][xsorted[i - 1].index]);
A[xsorted[i - 1].index][xsorted[i].index] = A[xsorted[i - 1].index][xsorted[i].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i - 1].index][xsorted[i].index]);
A[xsorted[i + 1].index][xsorted[i].index] = A[xsorted[i + 1].index][xsorted[i].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i + 1].index][xsorted[i].index]);
A[xsorted[i].index][xsorted[i + 1].index] = A[xsorted[i].index][xsorted[i + 1].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i].index][xsorted[i + 1].index]);
A[ysorted[i].index][ysorted[i - 1].index] = A[ysorted[i].index][ysorted[i - 1].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i].index][ysorted[i - 1].index]);
A[ysorted[i - 1].index][ysorted[i].index] = A[ysorted[i - 1].index][ysorted[i].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i - 1].index][ysorted[i].index]);
A[ysorted[i + 1].index][ysorted[i].index] = A[ysorted[i + 1].index][ysorted[i].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i + 1].index][ysorted[i].index]);
A[ysorted[i].index][ysorted[i + 1].index] = A[ysorted[i].index][ysorted[i + 1].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i].index][ysorted[i + 1].index]);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++) {
nodes[i].index = i;
cin >> nodes[i].x >> nodes[i].y;
}
build_table();
/* for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << " " << A[i][j];
}
cout << endl;
}
*/
cout << prim() << endl;
return 0;
} | /tmp/ccEpedsU.o: in function `prim()':
a.cc:(.text+0xe): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x33): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x59): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x88): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0xc9): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0xeb): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x11b): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x19e): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x1ec): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
a.cc:(.text+0x20d): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccEpedsU.o
/tmp/ccEpedsU.o: in function `build_table()':
a.cc:(.text+0x383): additional relocation overflows omitted from the output
collect2: error: ld returned 1 exit status
|
s676140436 | p03682 | C++ | #include <climits>
#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAX_N 100000
class Node
{
public:
int x, y, index, cost = INT_MAX;;
bool used = false;
};
int n;
int A[MAX_N][MAX_N] = {};
Node *nodes = new Node[MAX_N];
int prim()
{
int i, u, v, minv, sum = 0;
nodes[0].cost = 0;
while (true) {
u = -1; minv = INT_MAX;
for (i = 0; i < n; i++) {
if (nodes[i].cost < minv && !nodes[i].used) {
u = i;
minv = nodes[i].cost;
}
}
if (-1 == u) break;
nodes[u].used = true;
sum += nodes[u].cost;
for (v = 0; v < n; v++) {
if (!nodes[v].used && A[u][v] != 0) {
nodes[v].cost = A[u][v] < nodes[v].cost ? A[u][v] : nodes[v].cost;
}
}
}
return sum;
}
bool xsort(Node a, Node b)
{
if (a.x < b.x) return true;
else return false;
}
bool ysort(Node a, Node b)
{
if (a.y < b.y) return true;
else return false;
}
void build_table()
{
Node *xsorted = new Node[n];
Node *ysorted = new Node[n];
memcpy(xsorted, nodes, sizeof(Node) * n);
memcpy(ysorted, nodes, sizeof(Node) * n);
sort(xsorted, xsorted + n, xsort);
sort(ysorted, ysorted + n, ysort);
/*
cout << "xsorted:" << endl;
for (int i = 0; i < n; i++) {
cout << xsorted[i].x << " " << xsorted[i].y << endl;
}
cout << "ysorted:" << endl;
for (int i = 0; i < n; i++) {
cout << ysorted[i].x << " " << ysorted[i].y << endl;
}
*/
for (int i = 1; i < n - 1; i++) {
A[xsorted[i].index][xsorted[i - 1].index] = A[xsorted[i].index][xsorted[i - 1].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i].index][xsorted[i - 1].index]);
A[xsorted[i - 1].index][xsorted[i].index] = A[xsorted[i - 1].index][xsorted[i].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i - 1].index][xsorted[i].index]);
A[xsorted[i + 1].index][xsorted[i].index] = A[xsorted[i + 1].index][xsorted[i].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i + 1].index][xsorted[i].index]);
A[xsorted[i].index][xsorted[i + 1].index] = A[xsorted[i].index][xsorted[i + 1].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i].index][xsorted[i + 1].index]);
A[ysorted[i].index][ysorted[i - 1].index] = A[ysorted[i].index][ysorted[i - 1].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i].index][ysorted[i - 1].index]);
A[ysorted[i - 1].index][ysorted[i].index] = A[ysorted[i - 1].index][ysorted[i].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i - 1].index][ysorted[i].index]);
A[ysorted[i + 1].index][ysorted[i].index] = A[ysorted[i + 1].index][ysorted[i].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i + 1].index][ysorted[i].index]);
A[ysorted[i].index][ysorted[i + 1].index] = A[ysorted[i].index][ysorted[i + 1].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i].index][ysorted[i + 1].index]);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++) {
nodes[i].index = i;
cin >> nodes[i].x >> nodes[i].y;
}
build_table();
/* for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << " " << A[i][j];
}
cout << endl;
}
*/
cout << prim() << endl;
return 0;
} | /tmp/ccIgo44U.o: in function `prim()':
a.cc:(.text+0xe): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x33): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x59): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x88): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0xc9): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0xeb): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x11b): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x19e): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x1ec): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
a.cc:(.text+0x20d): relocation truncated to fit: R_X86_64_PC32 against symbol `nodes' defined in .bss section in /tmp/ccIgo44U.o
/tmp/ccIgo44U.o: in function `build_table()':
a.cc:(.text+0x383): additional relocation overflows omitted from the output
collect2: error: ld returned 1 exit status
|
s404440444 | p03682 | C++ | #include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
#define MAX_N 100000
class Node
{
public:
int x, y, index, cost = INT_MAX;;
bool used = false;
};
int n;
int A[MAX_N][MAX_N] = {};
Node *nodes = new Node[MAX_N];
int prim()
{
int i, u, v, minv, sum = 0;
nodes[0].cost = 0;
while (true) {
u = -1; minv = INT_MAX;
for (i = 0; i < n; i++) {
if (nodes[i].cost < minv && !nodes[i].used) {
u = i;
minv = nodes[i].cost;
}
}
if (-1 == u) break;
nodes[u].used = true;
sum += nodes[u].cost;
for (v = 0; v < n; v++) {
if (!nodes[v].used && A[u][v] != 0) {
nodes[v].cost = A[u][v] < nodes[v].cost ? A[u][v] : nodes[v].cost;
}
}
}
return sum;
}
bool xsort(Node a, Node b)
{
if (a.x < b.x) return true;
else return false;
}
bool ysort(Node a, Node b)
{
if (a.y < b.y) return true;
else return false;
}
void build_table()
{
Node *xsorted = new Node[n];
Node *ysorted = new Node[n];
memcpy(xsorted, nodes, sizeof(Node) * n);
memcpy(ysorted, nodes, sizeof(Node) * n);
sort(xsorted, xsorted + n, xsort);
sort(ysorted, ysorted + n, ysort);
/*
cout << "xsorted:" << endl;
for (int i = 0; i < n; i++) {
cout << xsorted[i].x << " " << xsorted[i].y << endl;
}
cout << "ysorted:" << endl;
for (int i = 0; i < n; i++) {
cout << ysorted[i].x << " " << ysorted[i].y << endl;
}
*/
for (int i = 1; i < n - 1; i++) {
A[xsorted[i].index][xsorted[i - 1].index] = A[xsorted[i].index][xsorted[i - 1].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i].index][xsorted[i - 1].index]);
A[xsorted[i - 1].index][xsorted[i].index] = A[xsorted[i - 1].index][xsorted[i].index] == 0 ? xsorted[i].x - xsorted[i - 1].x : min(xsorted[i].x - xsorted[i - 1].x, A[xsorted[i - 1].index][xsorted[i].index]);
A[xsorted[i + 1].index][xsorted[i].index] = A[xsorted[i + 1].index][xsorted[i].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i + 1].index][xsorted[i].index]);
A[xsorted[i].index][xsorted[i + 1].index] = A[xsorted[i].index][xsorted[i + 1].index] == 0 ? xsorted[i + 1].x - xsorted[i].x : min(xsorted[i + 1].x - xsorted[i].x, A[xsorted[i].index][xsorted[i + 1].index]);
A[ysorted[i].index][ysorted[i - 1].index] = A[ysorted[i].index][ysorted[i - 1].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i].index][ysorted[i - 1].index]);
A[ysorted[i - 1].index][ysorted[i].index] = A[ysorted[i - 1].index][ysorted[i].index] == 0 ? ysorted[i].y - ysorted[i - 1].y : min(ysorted[i].y - ysorted[i - 1].y, A[ysorted[i - 1].index][ysorted[i].index]);
A[ysorted[i + 1].index][ysorted[i].index] = A[ysorted[i + 1].index][ysorted[i].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i + 1].index][ysorted[i].index]);
A[ysorted[i].index][ysorted[i + 1].index] = A[ysorted[i].index][ysorted[i + 1].index] == 0 ? ysorted[i + 1].y - ysorted[i].y : min(ysorted[i + 1].y - ysorted[i].y, A[ysorted[i].index][ysorted[i + 1].index]);
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++) {
nodes[i].index = i;
cin >> nodes[i].x >> nodes[i].y;
}
build_table();
/* for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << " " << A[i][j];
}
cout << endl;
}
*/
cout << prim() << endl;
return 0;
} | a.cc:11:33: error: 'INT_MAX' was not declared in this scope
11 | int x, y, index, cost = INT_MAX;;
| ^~~~~~~
a.cc:4:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
3 | #include <algorithm>
+++ |+#include <climits>
4 | using namespace std;
a.cc: In function 'int prim()':
a.cc:24:24: error: 'INT_MAX' was not declared in this scope
24 | u = -1; minv = INT_MAX;
| ^~~~~~~
a.cc:24:24: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
|
s801595684 | p03682 | C++ | // http://abc065.contest.atcoder.jp/tasks/arc076_b
#include <algorithm>
#include <cstdio>
#include <cstdlib>
class UnionFind {
int n;
int * parent;
int * depth;
public:
UnionFind (int n) {
this->n = n;
parent = new int[n];
depth = new int[n];
for (int i = 0; i < n; ++i) {
parent[i] = i;
depth[i] = 1;
}
}
~UnionFind () {
delete[] parent;
delete[] depth;
}
int find (int node) {
while (parent[node] != parent[parent[node]]) {
parent[node] = parent[parent[node]];
}
return parent[node];
}
void union_ (int nodeA, int nodeB) {
int rootA = find(nodeA), rootB = find(nodeB);
if (rootA != rootB) {
if (depth[rootA] < depth[rootB]) {
std::swap(rootA, rootB);
}
parent[rootB] = rootA;
depth[rootA] = std::max(depth[rootA], depth[rootB] + 1);
}
}
};
struct Town { int x, y; };
struct Road {
int a, b, cost;
Road (int a, int b, int cost) : a(a), b(b), cost(cost) {}
};
int main () {
int n;
scanf("%d", &n);
std::vector<Town> towns(n);
std::vector<Road> roads;
UnionFind unionFind(n);
int totalCost = 0;
auto getCost = [&towns] (int a, int b) -> int {
return std::min(abs(towns[a].x - towns[b].x), abs(towns[a].y - towns[b].y));
};
for (int i = 0; i < n; ++i) {
// towns[i] = Town();
scanf("%d%d", &towns[i].x, &towns[i].y);
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
roads.push_back(Road(i, j, getCost(i, j)));
}
}
std::sort(roads.begin(), roads.end(), [] (
const Road & a,
const Road & b
) -> bool {
return a.cost < b.cost;
});
for (Road road : roads) {
if (unionFind.find(road.a) != unionFind.find(road.b)) {
totalCost += road.cost;
unionFind.union_(road.a, road.b);
}
}
printf("%d\n", totalCost);
return 0;
}
| a.cc: In function 'int main()':
a.cc:55:14: error: 'vector' is not a member of 'std'
55 | std::vector<Town> towns(n);
| ^~~~~~
a.cc:6:1: note: 'std::vector' is defined in header '<vector>'; this is probably fixable by adding '#include <vector>'
5 | #include <cstdlib>
+++ |+#include <vector>
6 |
a.cc:55:25: error: expected primary-expression before '>' token
55 | std::vector<Town> towns(n);
| ^
a.cc:55:27: error: 'towns' was not declared in this scope
55 | std::vector<Town> towns(n);
| ^~~~~
a.cc:56:14: error: 'vector' is not a member of 'std'
56 | std::vector<Road> roads;
| ^~~~~~
a.cc:56:14: note: 'std::vector' is defined in header '<vector>'; this is probably fixable by adding '#include <vector>'
a.cc:56:25: error: expected primary-expression before '>' token
56 | std::vector<Road> roads;
| ^
a.cc:56:27: error: 'roads' was not declared in this scope
56 | std::vector<Road> roads;
| ^~~~~
a.cc: In lambda function:
a.cc:63:37: error: 'towns' is not captured
63 | return std::min(abs(towns[a].x - towns[b].x), abs(towns[a].y - towns[b].y));
| ^~~~~
a.cc:62:31: note: the lambda has no capture-default
62 | auto getCost = [&towns] (int a, int b) -> int {
| ^
a.cc:55:27: note: '<typeprefixerror>towns' declared here
55 | std::vector<Town> towns(n);
| ^~~~~
a.cc:63:50: error: 'towns' is not captured
63 | return std::min(abs(towns[a].x - towns[b].x), abs(towns[a].y - towns[b].y));
| ^~~~~
a.cc:62:31: note: the lambda has no capture-default
62 | auto getCost = [&towns] (int a, int b) -> int {
| ^
a.cc:55:27: note: '<typeprefixerror>towns' declared here
55 | std::vector<Town> towns(n);
| ^~~~~
a.cc:63:67: error: 'towns' is not captured
63 | return std::min(abs(towns[a].x - towns[b].x), abs(towns[a].y - towns[b].y));
| ^~~~~
a.cc:62:31: note: the lambda has no capture-default
62 | auto getCost = [&towns] (int a, int b) -> int {
| ^
a.cc:55:27: note: '<typeprefixerror>towns' declared here
55 | std::vector<Town> towns(n);
| ^~~~~
a.cc:63:80: error: 'towns' is not captured
63 | return std::min(abs(towns[a].x - towns[b].x), abs(towns[a].y - towns[b].y));
| ^~~~~
a.cc:62:31: note: the lambda has no capture-default
62 | auto getCost = [&towns] (int a, int b) -> int {
| ^
a.cc:55:27: note: '<typeprefixerror>towns' declared here
55 | std::vector<Town> towns(n);
| ^~~~~
|
s499699558 | p03682 | C++ | #include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std;
typedef long long ll;
int par[100000];
int rank[100000];
int n;
void init(int k){
for(int i = 0; i < k; ++i){
par[i] = i;
rank[i] = 0;
}
}
int find(int x){
if(par[x] == x){
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] < rank[y]){
par[x] = y;
}else{
par[y] = x;
if(rank[x] == rank[y]) ++rank[x];
}
}
bool same(int x, int y){
return find(x) == find(y);
}
int main(){
int n; cin >> n;
init(n);
vector< pair<int, int> > vx, vy;
for(int i = 0; i < n; ++i){
int x, y; cin >> x >> y; --x; --y;
vx.push_back(pair<int, int>(x, i));
vy.push_back(pair<int, int>(y, i));
}
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
vector< pair<int, pair<int, int> > > v;
for(int i = 0; i < n - 1; ++i){
pair< int, pair<int, int> > p;
p.first = vx[i + 1].first - vx[i].first;
p.second = pair<int, int>(vx[i + 1].second, vx[i].second);
v.push_back(p);
p.first = vy[i + 1].first - vy[i].first;
p.second = pair<int, int>(vy[i + 1].second, vy[i].second);
v.push_back(p);
}
sort(v.begin(), v.end());
int ans = 0;
for(int i = 0; i < v.size(); ++i){
if(!same(v[i].second.first, v[i].second.second)){
unite(v[i].second.first, v[i].second.second);
ans += v[i].first;
}
}
cout << ans << endl;
return 0;
} | a.cc: In function 'void init(int)':
a.cc:15:17: error: reference to 'rank' is ambiguous
15 | rank[i] = 0;
| ^~~~
In file included from /usr/include/c++/14/bits/move.h:37,
from /usr/include/c++/14/bits/exception_ptr.h:41,
from /usr/include/c++/14/exception:166,
from /usr/include/c++/14/ios:41,
from /usr/include/c++/14/ostream:40,
from /usr/include/c++/14/iostream:41,
from a.cc:1:
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
a.cc: In function 'void unite(int, int)':
a.cc:32:12: error: reference to 'rank' is ambiguous
32 | if(rank[x] < rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
a.cc:32:22: error: reference to 'rank' is ambiguous
32 | if(rank[x] < rank[y]){
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
a.cc:36:20: error: reference to 'rank' is ambiguous
36 | if(rank[x] == rank[y]) ++rank[x];
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
a.cc:36:31: error: reference to 'rank' is ambiguous
36 | if(rank[x] == rank[y]) ++rank[x];
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
a.cc:36:42: error: reference to 'rank' is ambiguous
36 | if(rank[x] == rank[y]) ++rank[x];
| ^~~~
/usr/include/c++/14/type_traits:1437:12: note: candidates are: 'template<class> struct std::rank'
1437 | struct rank
| ^~~~
a.cc:9:5: note: 'int rank [100000]'
9 | int rank[100000];
| ^~~~
|
s368880217 | p03682 | C++ | #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
// UnionFind木
// 素集合データ構造というデータ構造です
// いくつかの対象が集合に分類されている状況で
// 2つの要素が同じ集合にいるのか、それとも違う集合にいるのか
// ということを効率的に調べる機能があります
class UnionFind {
private:
std::vector<int> parent; // あるデータの親
std::vector<int> sizes; // あるデータが属する木のサイズ
public:
// コンストラクタ
// データ一つ一つを木とし、親は自分自身に初期化する
UnionFind(int n)
: parent(n)
, sizes(n, 1)
{
for (int i = 0; i < n; ++i) {
parent[i] = i;
}
}
// データxが属する木の根ノードを取得
// findだがunion-find木の仕組み的に内部で破壊的更新を伴う
int find(int x) {
// 親と自分が同じであることが
// 自分がルートノードであるということ
if( x == parent[x] ) {
return x;
}
// 経路を圧縮するため調べた辺を根に直接繋ぎ直す
parent[x] = find(parent[x]);
return parent[x];
}
// 2つのデータx, yが属する木をマージする
void unite(int x, int y) {
// それぞれのデータの根ノードを取得
int root_x = find(x);
int root_y = find(y);
// x, yが同じ木に属するならマージしない
if (root_x == root_y) return;
// xの木がyの木より大きくなるようにする
if (sizes[root_x] < sizes[root_y]) {
std::swap(root_x, root_y);
}
// xがyの親になるようにマージする
parent[root_y] = root_x;
sizes[root_x] += sizes[root_y];
}
// 2つのデータx, yが同じ木に属するかどうか
bool same(int x, int y) {
return (find(x) == find(y));
}
// データxの属する木のサイズを返す
int size(int x) {
return sizes[find(x)];
}
};
// 頂点a, bを繋ぐコストcostの無向辺
class Edge {
int a, b, cost;
// コストで順序を決める(ソートのときに使われる)
bool operator<(const Edge &o) const {
return cost < o.cost;
}
};
// 頂点数と辺集合の組として定義したグラフ
public Graph {
private:
int n; // 頂点数
std::vector<Edge> edges; // 辺集合
public:
// コンストラクタ
// 頂点数nのグラフを考える
Graph(int n) : n(n) { }
// 辺を追加
void add_edge(const Edge& edge) {
edges.push_back( edge );
}
// クラスカル法は最小全域木と言うものを調べるアルゴリズムです
// クラスカル法を効率的に回すと
int kruskal() {
// costの小さい辺から繫いでいくので、昇順にソートしておく
sort(edges.begin(), edges.end());
// UnionFind木を使うと同じ集合にいることを確認できます
// これを使って「繋がってるノード」をすべて1つの集合にいることにします
// 最初の状態では「どれも繋がっていません」が
// エッジで繋いだ2つのノードは、同じ集合にいることにしてしまいます
// 辺を追加するときに、すでにつながっているノード同士を繋ぐということが閉路ができる条件なので
// 閉路を作らないようにつながっていないノードを繋ぐということを繰り返す
UnionFind uf(n);
int min_cost = 0;
for (size_t i = 0; i < edges.size(); ++i) {
Edge e = edges[i];
if (!uf.same(e.a, e.b)) {
min_cost += e.cost;
uf.unite(e.a, e.b);
}
}
return min_cost;
}
};
int main() {
// 街の数
int N;
// i番目の街のx, y座標をそれぞれ分けて持つ
std::pair<int, int> x[N], y[N];
// 入力
std::cin >> N;
for (size_t i = 0; i < N; ++i) {
std::cin >> x[i].first >> y[i].first;
x[i].second = i;
y[i].second = i;
}
// 式 min( |a-c|, |b-d| ) を検討してみると
// - "x軸側で一番近い"街が正方向・負方向に1つずつ
// - "y軸側で一番近い"街が正方向・負方向に1つずつ
// の4つだけがそれぞれの街に存在することがわかります。
//
// また隣り合う街はどちらから繋いでも同じです。
// ということは問題は無向辺グラフということになります。
//
// これは言い換えると1つの街について
// - x軸側について街を並べた並びで後ろに来る街
// - y軸側について街を並べた並びで後ろに来る街
// の2つの街だけを検討したら十分なことがわかります
//
// そこでx軸y軸それぞれでソートして
// 隣り合う街を見つけ出します
sort(x, x + N);
sort(y, y + N);
// 問題を
// - 街をノード
// - 街の間の道を作る操作をコストを持った辺
// とするグラフの最小全域木問題に帰着する
Graph g( N );
// 後ろの街への辺を作っていく
for (size_t i = 0; i < N - 1; ++i) {
// x軸側で1つ後ろの街への辺
g.add_edge(
Edge(
x[i].second,
x[i+1].second,
x[i+1].first - x[i].first
)
);
// y軸側で1つ後ろの街への辺
g.add_edge(
Edge(
y[i].second,
y[i+1].second,
y[i+1].first - y[i].first
)
);
}
// クラスカル法で最小全域木を作ってコストを見る
std::cout << g.kruskal() << std::endl;
return 0;
} | a.cc:83:1: error: expected unqualified-id before 'public'
83 | public Graph {
| ^~~~~~
a.cc: In function 'int main()':
a.cc:160:3: error: 'Graph' was not declared in this scope; did you mean 'isgraph'?
160 | Graph g( N );
| ^~~~~
| isgraph
a.cc:165:5: error: 'g' was not declared in this scope
165 | g.add_edge(
| ^
a.cc:170:7: error: no matching function for call to 'Edge::Edge(int&, int&, int)'
170 | )
| ^
a.cc:73:7: note: candidate: 'Edge::Edge()'
73 | class Edge {
| ^~~~
a.cc:73:7: note: candidate expects 0 arguments, 3 provided
a.cc:73:7: note: candidate: 'constexpr Edge::Edge(const Edge&)'
a.cc:73:7: note: candidate expects 1 argument, 3 provided
a.cc:73:7: note: candidate: 'constexpr Edge::Edge(Edge&&)'
a.cc:73:7: note: candidate expects 1 argument, 3 provided
a.cc:179:7: error: no matching function for call to 'Edge::Edge(int&, int&, int)'
179 | )
| ^
a.cc:73:7: note: candidate: 'Edge::Edge()'
73 | class Edge {
| ^~~~
a.cc:73:7: note: candidate expects 0 arguments, 3 provided
a.cc:73:7: note: candidate: 'constexpr Edge::Edge(const Edge&)'
a.cc:73:7: note: candidate expects 1 argument, 3 provided
a.cc:73:7: note: candidate: 'constexpr Edge::Edge(Edge&&)'
a.cc:73:7: note: candidate expects 1 argument, 3 provided
a.cc:184:16: error: 'g' was not declared in this scope
184 | std::cout << g.kruskal() << std::endl;
| ^
|
s861290167 | p03682 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
struct X{
int id;
LL x;
LL y;
X(){
id=0;
x=0;
y=0;
}
X(int _id,LL _x,LL _y){
id=_id;
x=_x;
y=_y;
}
LL getCost(X &x1){
LL X1=x-x1.x;
if (X1<0){
X1=-X1;
}
LL Y1=y-x1.y;
if (Y1<0){
Y1=-Y1;
}
if (X1<Y1){
return X1;
}else{
return Y1;
}
}
};
struct EDGE{
X p1;
X p2;
LL cost;
EDGE(X _p1,X _p2){
p1=_p1;
p2=_p2;
cost=p1.getCost(p2);
}
// コストの大小で順序定義
bool operator<(const EDGE& o) const {
return cost < o.cost;
}
bool find(const EDGE &edge){
if (p1.id==edge.p1.id && p2.id==edge.p2.id){
return true;
}
if (p1.id==edge.p2.id && p2.id==edge.p1.id){
return true;
}
return false;
}
};
bool SortX(X &x1,X &x2){
if (x1.x<x2.x){
return true;
}
return false;
}
bool SortY(X &x1,X &x2){
if (x1.y<x2.y){
return true;
}
return false;
}
// 素集合データ構造
struct UnionFind
{
// par[i]：データiが属する木の親の番号。i == par[i]のとき、データiは木の根ノードである
vector<int> par;
// sizes[i]：根ノードiの木に含まれるデータの数。iが根ノードでない場合は無意味な値となる
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
// 最初は全てのデータiがグループiに存在するものとして初期化
for (int i=0;i<n;i++){
par[i] = i;
}
}
// データxが属する木の根を得る
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]); // 根を張り替えながら再帰的に根ノードを探す
}
// 2つのデータx, yが属する木をマージする
void unite(int x, int y) {
// データの根ノードを得る
x = find(x);
y = find(y);
// 既に同じ木に属しているならマージしない
if (x == y) return;
// xの木がyの木より大きくなるようにする
if (sizes[x] < sizes[y]) swap(x, y);
// xがyの親になるように連結する
par[y] = x;
sizes[x] += sizes[y];
sizes[y] = 0; // sizes[y]は無意味な値となるので0を入れておいてもよい
}
// 2つのデータx, yが属する木が同じならtrueを返す
bool same(int x, int y) {
return find(x) == find(y);
}
// データxが含まれる木の大きさを返す
int size(int x) {
return sizes[find(x)];
}
};
// 頂点数と辺集合の組として定義したグラフ
struct Graph
{
int n; // 頂点数
vector<EDGE> edges; // 辺集合
// クラスカル法で無向最小全域木のコストの和を計算する
// グラフが非連結のときは最小全域森のコストの和となる
LL kruskal() {
// コストが小さい順にソート
sort(edges.begin(), edges.end());
UnionFind uf(n);
LL min_cost = 0;
for (int i=0;i<edges.size();i++) {
EDGE& e = edges[i];
if (!uf.same(e.p1.id, e.p2.id)) {
// 辺を追加しても閉路ができないなら、その辺を採用する
min_cost += e.cost;
uf.unite(e.p1.id, e.p2.id);
}
}
return min_cost;
}
};
int main(int argc, char* argv[])
{
int N;
cin>>N;
vector<X> City;
int i,j;
LL x,y;
for (i=0;i<N;i++){
cin>>x>>y;
City.push_back(X(i,x,y));
}
sort(City.begin(),City.end(),SortX);
Graph graph;
graph.n=N;
for (i=0;i<N-1;i++){
graph.edges.push_back(edge);
}
sort(City.begin(),City.end(),SortY);
for (i=0;i<N-1;i++){
EDGE edge(City[i],City[i+1]);
graph.edges.push_back(edge);
}
cout << graph.kruskal() << endl;
return 0;
} | a.cc: In function 'int main(int, char**)':
a.cc:165:39: error: 'edge' was not declared in this scope
165 | graph.edges.push_back(edge);
| ^~~~
|
s186623957 | p03682 | C++ | #include<iostream>
#include<cstring>
#include<math.h>
#include<stdlib.h>
#include<cstring>
#include<cstdio>
#include<utility>
#include<algorithm>
#include<map>
#include<stack>
#include<queue>
using namespace std;
typedef long long ll;
const int Max = 2*1e5+5;
const int mod = 1e9+7;
const int Hash = 10000;
const int INF = 1<<30;
const ll llINF = 1e18;
int n, m;
struct edge
{
int start, finish, w;
};
struct node
{
int a,b, index;
};
node in[Max];//点的输入
edge arr[Max];//储存所有的边，在该数组上跑克鲁斯卡尔算法，O(nlogn)
bool cmp1(const node& t1, const node& t2)
{
return t1.a<t2.a;
}
bool cmp2(const node& t1, const node& t2)
{
return t1.b<t2.b;
}
bool cmp3(const edge& t1, const edge& t2)
{
return t1.w<t2.w;
}
int isvisited[Max];
void init( )
{
for(int i=0; i<Max; i++)
isvisited[i] = i;
}
int f(int k)
{
if(k != isvisited[k])
k = f(isvisited[k]);
return k;
}
int main( )
{
//freopen("input.txt", "r", stdin);
scanf("%d", &n)
for(int i=0; i<n; i++)
{
scanf("%d%d", &in[i].a, &in[i].b);
in[i].index = i;
}
//将所有的可能生成树中的边都加到数组arr中
int cnt = 0;
sort(in, in+n, cmp1);
for(int i=0; i<n-1; i++)
arr[cnt++] = (edge){in[i].index, in[i+1].index, in[i+1].a-in[i].a};
sort(in, in+n, cmp2);
for(int i=0; i<n-1; i++)
arr[cnt++] = (edge){in[i].index, in[i+1].index, in[i+1].b-in[i].b};
//克鲁斯卡尔算法
ll ans = 0;
init( );
sort(arr, arr+cnt, cmp3);
for(int i=0; i<cnt; i++)
{
int a = f(arr[i].start);
int b = f(arr[i].finish);
if(a == b)
continue;
ans += arr[i].w;
isvisited[a] = b;
}
cout<<ans<<endl;
return 0;
}
| a.cc: In function 'int main()':
a.cc:58:20: error: expected ';' before 'for'
58 | scanf("%d", &n)
| ^
| ;
59 | for(int i=0; i<n; i++)
| ~~~
a.cc:59:18: error: 'i' was not declared in this scope
59 | for(int i=0; i<n; i++)
| ^
|
s145700838 | p03682 | C++ | #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <set>
using namespace std;
const int maxn = 1e5 + 5;
struct Node {
int x, y, id;
}node[maxn];
struct Edge {
int u, v, val;
bool operator <(const Edge& rhs) const {
return val < rhs.val;
}
}e[maxn << 1];
int par[maxn];
int n;
bool cmp1(const Node &a, const Node &b) {
return a.x < b.x;
}
bool cmp2(const Node &a, const Node &b) {
return a.y < b.y;
}
void init() {
for (int i = 0; i <= n; i ++)
par[i] = i;
}
int findpar(int x) {
return par[x] = (par[x] == x ? x : findpar(par[x]));
}
void unite(int x, int y) {
x = findpar(x), y = findpar(y);
if (x == y) return;
par[x] = y;
}
int main(int argc, char const *argv[]) {
cin >> n;
init();
for (int i = 1; i <= n; i ++) {
scanf("%d%d", &node[i].x, &node[i].y);
node[i].id = i;
}
sort(node + 1, node + n + 1, cmp1);
int cnt = 0;
for (int i = 2; i <= n; i ++)
e[cnt ++] = (Edge){node[i - 1].id, node[i].id, node[i].x - node[i - 1].x};
sort(node + 1, node + n + 1, cmp2);
for (int i = 2; i <= n; i ++)
e[cnt ++] = (Edge){node[i - 1].id, node[i].id, node[i].y - node[i - 1].y};
sort(e, e + cnt);
long long ans = 0;
for (int i = 0; i < cnt; i ++) {
int u = e[i].u, v = e[i].v, val = e[i].val;
if (findpar(u) == findpar(v)) continue;
unite(u, v);
ans += val;
}
cout << ans << endl;
return 0;
| a.cc: In function 'int main(int, const char**)':
a.cc:84:14: error: expected '}' at end of input
84 | return 0;
| ^
a.cc:51:40: note: to match this '{'
51 | int main(int argc, char const *argv[]) {
| ^
|
s331595795 | p03682 | C++ | #include <iostream>
#include <vector>
#include <queue>
#include <set>
using namespace std;
struct point
{
int id;
int x;
int y;
};
struct edge
{
int src;
int dst;
int cost;
bool operator<(const edge &other) const
{
return other.cost < cost;
}
};
int main()
{
int N;
cin >> N;
vector<point> p(N);
for (int i = 0; i < N; ++i) {
p[i].id = i;
cin >> p[i].x >> p[i].y;
}
vector<vector<edge>> g(N);
sort(p.begin(), p.end(), [](auto &a, auto &b) {return a.x < b.x; });
for (int i = 0; i + 1 < N; ++i) {
edge e;
e.src = p[i].id;
e.dst = p[i + 1].id;
e.cost = p[i + 1].x - p[i].x;
g[e.src].push_back(e);
swap(e.src, e.dst);
g[e.src].push_back(e);
}
sort(p.begin(), p.end(), [](auto &a, auto &b) {return a.y < b.y; });
for (int i = 0; i + 1 < N; ++i) {
edge e;
e.src = p[i].id;
e.dst = p[i + 1].id;
e.cost = p[i + 1].y - p[i].y;
g[e.src].push_back(e);
swap(e.src, e.dst);
g[e.src].push_back(e);
}
set<int> visited;
priority_queue<edge> q;
auto visit = [&](int x) -> bool {
if (!visited.insert(x).second) {
return false;
}
for (auto &e : g[x]) {
q.push(e);
}
return true;
};
visit(0);
int ans = 0;
while (!q.empty()) {
auto e = q.top();
q.pop();
if (visit(e.dst)) {
ans += e.cost;
}
}
cout << ans << endl;
}
| a.cc: In function 'int main()':
a.cc:40:9: error: 'sort' was not declared in this scope; did you mean 'short'?
40 | sort(p.begin(), p.end(), [](auto &a, auto &b) {return a.x < b.x; });
| ^~~~
| short
|
s569678973 | p03682 | C++ | #include<bits/stdc++.h>
using namespace std;
const int M=100010;
struct Edge
{
int u,v,c;
bool operator < (const Edge &b) const {return c<b.c;}
}e[M<<1];
struct Point
{
int x,y,id;
}a[M];
bool cmp1(Point a,Point b)
{
return a.x<b.x;
}
bool cmp2(Point a,Point b)
{
return a.y<b.y;
}
ll ans;
int n,tot;
int f[M];
inline int getf(int x) {return f[x]==x?x:f[x]=getf(f[x]);}
int main()
{
ios::sync_with_stdio(false);
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i].x>>a[i].y,a[i].id=i;
sort(a,a+n,cmp1);
for(int i=0;i+1<n;i++)
e[tot++]=(Edge){a[i].id,a[i+1].id,abs(a[i].x-a[i+1].x)};
sort(a,a+n,cmp2);
for(int i=0;i+1<n;i++)
e[tot++]=(Edge){a[i].id,a[i+1].id,abs(a[i].y-a[i+1].y)};
for(int i=0;i<n;i++)
f[i]=i;
sort(e,e+tot);
for(int i=0;i<tot;i++)
{
int u=e[i].u,v=e[i].v;
if(getf(u)!=getf(v))
ans+=e[i].c,f[getf(u)]=getf(v);
}
cout<<ans;
return 0;
} | a.cc:27:1: error: 'll' does not name a type
27 | ll ans;
| ^~
a.cc: In function 'int main()':
a.cc:52:25: error: 'ans' was not declared in this scope; did you mean 'abs'?
52 | ans+=e[i].c,f[getf(u)]=getf(v);
| ^~~
| abs
a.cc:54:15: error: 'ans' was not declared in this scope; did you mean 'abs'?
54 | cout<<ans;
| ^~~
| abs
|
s775131710 | p03682 | C++ | #include <iostream>
#include <iomanip>
#include <array>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <tuple>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <numeric>
#include <cassert>
#include <functional>
using namespace std;
typedef unsigned long long int llui;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<string, string> pss;
constexpr double pi = 3.141592653589793238462643383279502884L;
// TODO: Mod class
const int sz = 1e5 + 5;
int group[sz];
typedef pair<int, pii> piii;
int Find(int n) {
int g = group[n];
if (g != n) {
group[n] = Find(g);
}
return group[n];
}
void Union(int n, int m) {
int g1 = Find(n);
int g2 = Find(m);
if (g1 != g2) {
group[g1] = g2;
}
}
piii make_piii(int a, int b, int c) {
return make_pair(a, make_pair(b, c));
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pii> ori(n);
for (int i = 0; i < n; ++i) {
cin >> ori[i].first >> ori[i].second;
}
sort(ori.begin(), ori.end());
ori.resize(unique(ori.begin(), ori.end()) - ori.begin());
vector<pii> x;
vector<pii> y;
for (int i = 0; i < ori.size(); ++i) {
int a, b;
a = ori[i].first;
b = ori[i].second;
x.push_back(make_pair(a, i));
y.push_back(make_pair(b, i));
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
vector<piii> xdiff;
vector<piii> ydiff;
for (int i = 0; i < xdiff.size(); ++i) {
xdiff.push_back(make_piii(abs(x[i].first - x[i + 1].first), x[i].second, x[i + 1].second));
ydiff.push_back(make_piii(abs(y[i].first - y[i + 1].first), y[i].second, y[i + 1].second));
}
sort(xdiff.begin(), xdiff.end());
sort(ydiff.begin(), ydiff.end());
for (int i = 0; i < n; ++i) {
group[i] = i;
}
int fx = 0;
int fy = 0;
ll cost = 0;
for (int i = 0; i < ori.size() - 1; ++i) {
piii now;
if (fx == xidff.size() && fy == ydiff.size()) {
break;
}
if (fx == xdiff.size()) {
now = ydiff[fy++];
} else if (fy == ydiff.size()) {
now = xdiff[fx++];
} else {
if (xdiff[fx].first < ydiff[fy].first) {
now = xdiff[fx++];
} else {
now = ydiff[fy++];
}
}
if (Find(now.second.first) == Find(now.second.second)) {
--i;
continue;
}
Union(now.second.first, now.second.second);
cost += now.first;
}
cout << cost << endl;
}
| a.cc: In function 'int main()':
a.cc:100:15: error: 'xidff' was not declared in this scope; did you mean 'xdiff'?
100 | if (fx == xidff.size() && fy == ydiff.size()) {
| ^~~~~
| xdiff
|
s861054099 | p03682 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#define ll long long
using namespace std;
ll N;
vector <ll> x;
vector <ll> y;
int main(){
ll inp;
ll result =0;
ll a;
cin >> N;
for(int i=0;i<N;i++){
cin >> inp;
x.push_back(inp);
cin >> inp;
y.push_back(inp);
}
sort(x.begin(),x.end());
sort(y.begin(),y.end());
for(int i = 0;i < N ; i++){
if(i==1|| i ==N-1){
if((x[i]-x[i-1])<(y[i]-y[i-1])) result += x[i]-x[i-1];
else result += y[i]-y[i-1];}
else{
if((x[i]-x[i-1])<(y[i]-y[i-1])) result += x[i]-x[i-1];
else result += y[i]-y[i-1];}
}
}
cout << result << endl;
return 0;
}
| a.cc:41:3: error: 'cout' does not name a type
41 | cout << result << endl;
| ^~~~
a.cc:42:3: error: expected unqualified-id before 'return'
42 | return 0;
| ^~~~~~
a.cc:44:1: error: expected declaration before '}' token
44 | }
| ^
|
s019340985 | p03682 | C++ | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> xs(N, 0);
vector<int> ys(N, 0);
for (int i = 0; i < N; i++) {
cin >> xs[i] >> ys[i];
}
vector<int> connected;
connected.push_back(0);
vector<int> visited(N, 0);
visited[0] = 1;
int cost = 0;
while (connected.size() != N) {
int min_index = -1;
int min_cost = INT_MAX;
for (int i = 0; i < N; i++) {
if (visited[i] == 1) {
continue;
}
for (int j = 0; j < connected.size(); j++) {
int temp = min(abs(xs[i] - xs[connected[j]]), abs(ys[i] - ys[connected[j]]));
if (temp < min_cost) {
min_index = i;
min_cost = temp;
}
}
}
connected.push_back(min_index);
cost += min_cost;
visited[min_index] = 1;
}
cout << cost << endl;
} | a.cc: In function 'int main()':
a.cc:21:32: error: 'INT_MAX' was not declared in this scope
21 | int min_cost = INT_MAX;
| ^~~~~~~
a.cc:4:1: note: 'INT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
3 | #include <algorithm>
+++ |+#include <climits>
4 | using namespace std;
|
s887191243 | p03682 | Java | import java.util.*;
import java.math.*;
import java.io.*;
class Main{
public static InputReader sc;
public static PrintWriter out;
public static final long MOD = (long)1e9 + 7L;
public static void main(String[] args){
sc=new InputReader(System.in);
out=new PrintWriter(System.out);
int n=sc.nextInt();
ArrayList<Pair> l=new ArrayList<Luck.Pair>();
for(int i=0;i<n;i++){
int u=sc.nextInt();
int v=sc.nextInt();
l.add(new Pair(u,v));
}
Collections.sort(l, Pair.Val);
long ans=0L;
TreeSet<Integer> yA=new TreeSet<Integer>();
for(int i=0;i<l.size()-1;i++){
int tem=Integer.MAX_VALUE;
if(yA.floor(l.get(i).y)!=null && yA.ceiling(l.get(i).y)!=null){
tem=Math.min(Math.abs(l.get(i).y-yA.floor(l.get(i).y)), Math.abs(l.get(i).y=yA.ceiling(l.get(i).y)));
}
else if(yA.floor(l.get(i).y)!=null){
tem=Math.abs(l.get(i).y-yA.floor(l.get(i).y));
}
else if(yA.ceiling(l.get(i).y)!=null){
tem=Math.abs(l.get(i).y=yA.ceiling(l.get(i).y));
}
ans+=Math.min(Math.abs(l.get(i).x-l.get(i+1).x), tem);
}
out.println(ans);
out.close();
}
static class Pair{
int x;
int y;
Pair(int x,int y){
this.x=x;
this.y=y;
}
public static Comparator<Pair> Val=new Comparator<Pair>(){
public int compare(Pair p1,Pair p2){
if(p1.x==p2.x){
return p1.y-p2.y;
}
return p1.x-p2.x;
}
};
}
// static class Pair{
// String x;
// int y;
// Pair(){
// this.x="";
// this.y=-1;
// }
// Pair(String profit,int val,int count){
// this.x=profit;
// this.y=val;
// }
// public static Comparator<Pair> Val=new Comparator<Pair>(){
// public int compare(Pair p1,Pair p2){
// if(p1.x==p2.y){
// return p1.y-p2.y;
// }
// return (int)p1.x-(int)p2.x;
// }
// };
// public int hashCode() {
// final int prime = 31;
// int result = 1;
// result = prime * result + x;
// result = prime * result + x;
// return result;
// }
// public boolean equals(Object obj){
// if (this == obj)
// return true;
// if (!(obj instanceof Pair)) {
// return false;
// }
//
// Pair p = (Pair) obj;
// if(p.x!=this.x){
// return false;
// }
// else if(p.y!=p.y){
// return false;
// }
// return true;
// }
// }
static class DisjointSet{
int n;
int[] par;
int[] rank;
DisjointSet(int n){
this.n=n;
this.par=new int[n];
this.rank=new int[n];
makeSet();
}
void makeSet(){
for(int i=1;i<n;i++){
par[i]=i;
rank[i]=1;
}
}
void union(int x,int y){
int parX=parent(x);
int parY=parent(y);
if(parX!=parY){
if(rank[parX]>=rank[parY]){
rank[parX]+=rank[parY];
rank[parY]=0;
par[parY]=parX;
}
else{
rank[parY]+=rank[parX];
rank[parX]=0;
par[parX]=parY;
}
}
}
int parent(int c){
int i=c;
while(i!=par[i]){
i=par[i];
}
return i;
}
}
static int gcd(int a,int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
static int lcm(int a,int b){
int g;
if(a<b){
g=gcd(b,a);
}
else{
g=gcd(a,b);
}
return (a*b)/g;
}
static long bigmod ( long a, long p, long m ) {
long res = 1 % m, x = a % m;
while ( p>0 ) {
if ( (p & 1)==1 ) res = ( res * x ) % m;
x = ( x * x ) % m; p >>= 1;
}
return res;
}
static boolean isPrime(int n){
if (n == 2)
return true;
for (long i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
static void shuffle(int[] A){
for(int i=A.length-1;i>0;i--){
int j=(int)(Math.random()*(i+1));
int temp=A[j];
A[j]=A[i];
A[i]=temp;
}
}
// public static class Node implements Comparable<Node>{
// int u;
// int v;
// public Node(){
// ;
// }
// public Node (int u, int v) {
// this.u = u;
// this.v = v;
// }
//
// public void print() {
// out.println(v + " " + u + " ");
// }
//
// public int compareTo(Node n1){
// return this.u-n1.u;
// }
// }
public static long pow(long base,long exp,long mod){
if(exp==0){
return 1;
}
if(exp==1){
return base;
}
long temp=exp/2;
long val=pow(base,temp,mod);
long result=val*val;
result=(result%mod);
long AND=exp&1;
if(AND==1){
result*=base;
result=(result%mod);
}
return result;
}
public static BigInteger pow(BigInteger base, BigInteger exp) {
if(exp.equals(new BigInteger(String.valueOf(0)))){
return new BigInteger(String.valueOf(1));
}
if(exp.equals(new BigInteger(String.valueOf(1))))
return base;
BigInteger temp=exp.divide(new BigInteger(String.valueOf(2)));
BigInteger val = pow(base, temp);
BigInteger result = val.multiply(val);
result=result.remainder(new BigInteger(String.valueOf(MOD)));
BigInteger AND=exp.and(new BigInteger(String.valueOf(1)));
if(AND.equals(new BigInteger(String.valueOf(1)))){
result = result.multiply(base);
result=result.remainder(new BigInteger(String.valueOf(MOD)));
}
return result;
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| Main.java:12: error: package Luck does not exist
ArrayList<Pair> l=new ArrayList<Luck.Pair>();
^
1 error
|
s069492500 | p03682 | C++ | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sys/time.h>
#include <cmath>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sizes[x] < sizes[y]) swap(x, y);
par[y] = x;
sizes[x] += sizes[y];
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return sizes[find(x)];
}
};
bool xord(pair< int, pair<int, int> > v1, pair< int, pair<int, int> >v2) {
return v1.second.first < v2.second.first;
}
bool yord(pair< int, pair<int, int> > v1, pair< int, pair<int, int> >v2) {
return v1.second.second < v2.second.second;
}
void solve(int n, vector< pair< int, pair<int, int> > > V) {
vector< pair<int, pair <int, int> > > E;
vector< pair<int, pair<int, int> > > V1 = V;
vector< pair<int, pair<int, int> > > V2 = V;
sort(V1.begin, V1.end, xord)
sort(V2.begin, V2.end, yord)
for (int i = 0; i < n-1; i++) {
pair<int, pair <int, int> > = tmp;
tmp.first = V1[i+1].second.first - V1[i].second.first;
tmp.second.first = V1[i].first;
tmp.second.second = V1[i+1].first;
E.push_back(tmp);
}
for (int i = 0; i < n-1; i++) {
pair<int, pair <int, int> > = tmp;
tmp.first = V2[i+1].second.first - V2[i].second.first;
tmp.second.first = V2[i].first;
tmp.second.second = V2[i+1].first;
E.push_back(tmp);
}
sort(E.begin(), E.end());
int min_cost = 0;
UnionFind uf(n);
for (int i = 0; i < E.size(); i++) {
if (!uf.same(E.second.first, E.second.second)) {
min_cost += e.cost;
uf.unite(E.second.first, E.second.second);
}
}
std::cout << min_cost << std::endl;
}
int main() {
struct timeval start,end;
long long span;
int n;
gettimeofday(&start,NULL);
std::cin >> n;
vector< pair<int, pair<int, int> > > V(n);
for (int i = 0; i < n; i++) {
V[i].first = i;
std::cin >> V[i].second.first >> V[i].second.second;
}
solve(n, V);
gettimeofday(&end,NULL);
span = (end.tv_sec -start.tv_sec)*1000000LL + (end.tv_usec - start.tv_usec);
std::cerr << "--Total Time: " << span/1000 << "ms" << endl;
return 0;
}
| a.cc: In function 'void solve(int, std::vector<std::pair<int, std::pair<int, int> > >)':
a.cc:56:9: error: no matching function for call to 'sort(<unresolved overloaded function type>, <unresolved overloaded function type>, bool (&)(std::pair<int, std::pair<int, int> >, std::pair<int, std::pair<int, int> >))'
56 | sort(V1.begin, V1.end, xord)
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:61,
from a.cc:4:
/usr/include/c++/14/bits/stl_algo.h:4762:5: note: candidate: 'template<class _RAIter> void std::sort(_RAIter, _RAIter)'
4762 | sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
| ^~~~
/usr/include/c++/14/bits/stl_algo.h:4762:5: note: candidate expects 2 arguments, 3 provided
/usr/include/c++/14/bits/stl_algo.h:4793:5: note: candidate: 'template<class _RAIter, class _Compare> void std::sort(_RAIter, _RAIter, _Compare)'
4793 | sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
| ^~~~
/usr/include/c++/14/bits/stl_algo.h:4793:5: note: template argument deduction/substitution failed:
a.cc:56:9: note: couldn't deduce template parameter '_RAIter'
56 | sort(V1.begin, V1.end, xord)
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:86:
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare)'
292 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
| ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:292:1: note: candidate expects 4 arguments, 3 provided
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note: candidate: 'template<class _ExecutionPolicy, class _RandomAccessIterator> __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> std::sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator)'
296 | sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
| ^~~~
/usr/include/c++/14/pstl/glue_algorithm_defs.h:296:1: note: template argument deduction/substitution failed:
a.cc:56:9: note: couldn't deduce template parameter '_ExecutionPolicy'
56 | sort(V1.begin, V1.end, xord)
| ~~~~^~~~~~~~~~~~~~~~~~~~~~~~
a.cc:58:21: error: 'i' was not declared in this scope
58 | for (int i = 0; i < n-1; i++) {
| ^
a.cc:66:37: error: expected unqualified-id before '=' token
66 | pair<int, pair <int, int> > = tmp;
| ^
a.cc:67:9: error: 'tmp' was not declared in this scope; did you mean 'tm'?
67 | tmp.first = V2[i+1].second.first - V2[i].second.first;
| ^~~
| tm
a.cc:76:24: error: 'class std::vector<std::pair<int, std::pair<int, int> > >' has no member named 'second'
76 | if (!uf.same(E.second.first, E.second.second)) {
| ^~~~~~
a.cc:76:40: error: 'class std::vector<std::pair<int, std::pair<int, int> > >' has no member named 'second'
76 | if (!uf.same(E.second.first, E.second.second)) {
| ^~~~~~
a.cc:77:25: error: 'e' was not declared in this scope
77 | min_cost += e.cost;
| ^
a.cc:78:24: error: 'class std::vector<std::pair<int, std::pair<int, int> > >' has no member named 'second'
78 | uf.unite(E.second.first, E.second.second);
| ^~~~~~
a.cc:78:40: error: 'class std::vector<std::pair<int, std::pair<int, int> > >' has no member named 'second'
78 | uf.unite(E.second.first, E.second.second);
| ^~~~~~
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.