結果
| 問題 | No.2337 Equidistant |
| ユーザー |
 hamamu
|
| 提出日時 | 2023-06-02 22:01:36 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 308 ms / 4,000 ms |
| コード長 | 52,032 bytes |
| コンパイル時間 | 6,234 ms |
| コンパイル使用メモリ | 301,072 KB |
| 実行使用メモリ | 44,448 KB |
| 最終ジャッジ日時 | 2024-06-08 23:06:46 |
| 合計ジャッジ時間 | 13,594 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | AC | 2 ms
5,376 KB |
| testcase_03 | AC | 3 ms
5,376 KB |
| testcase_04 | AC | 2 ms
5,376 KB |
| testcase_05 | AC | 2 ms
5,376 KB |
| testcase_06 | AC | 4 ms
5,376 KB |
| testcase_07 | AC | 4 ms
5,376 KB |
| testcase_08 | AC | 3 ms
5,376 KB |
| testcase_09 | AC | 4 ms
6,940 KB |
| testcase_10 | AC | 4 ms
5,376 KB |
| testcase_11 | AC | 269 ms
36,260 KB |
| testcase_12 | AC | 284 ms
36,256 KB |
| testcase_13 | AC | 272 ms
36,384 KB |
| testcase_14 | AC | 269 ms
36,384 KB |
| testcase_15 | AC | 273 ms
36,192 KB |
| testcase_16 | AC | 268 ms
36,344 KB |
| testcase_17 | AC | 272 ms
36,168 KB |
| testcase_18 | AC | 271 ms
36,388 KB |
| testcase_19 | AC | 264 ms
36,256 KB |
| testcase_20 | AC | 267 ms
36,324 KB |
| testcase_21 | AC | 234 ms
44,448 KB |
| testcase_22 | AC | 188 ms
36,644 KB |
| testcase_23 | AC | 220 ms
37,024 KB |
| testcase_24 | AC | 291 ms
41,252 KB |
| testcase_25 | AC | 231 ms
37,024 KB |
| testcase_26 | AC | 308 ms
41,248 KB |
| testcase_27 | AC | 247 ms
37,152 KB |
| testcase_28 | AC | 238 ms
37,280 KB |
ソースコード
#if !defined(MYLOCAL)//提出時用テンプレート
#pragma GCC optimize("Ofast")
#if defined(NDEBUG)
#undef NDEBUG
#endif
#include "bits/stdc++.h"
#if !defined(_MSC_VER) && __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
using namespace std;
using ll=long long; using dd=double;
using vll=vector< ll>; using vdd=vector< dd>;
using vvll=vector< vll>; using vvdd=vector<vdd>;
using vvvll=vector< vvll>; using vvvdd=vector<vvdd>;
using vvvvll=vector<vvvll>;
using pll=pair<ll,ll>; using tll=tuple<ll,ll,ll>; using qll=tuple<ll,ll,ll,ll>;
using vpll=vector< pll>; using vtll=vector< tll>; using vqll=vector< qll>;
using vvpll=vector<vpll>; using vvtll=vector<vtll>; using vvqll=vector<vqll>;
using namespace chrono;
constexpr ll INF = 1001001001001001001;
struct Fast{ Fast(){ cin.tie(0); ios::sync_with_stdio(false); cout<<fixed<<setprecision(numeric_limits<double>::max_digits10); } } fast;
#define REPS(i, S, E) for (ll i = (S); i <= (E); i++)
#define REP(i, N) REPS(i, 0, (N)-1)
#define DEPS(i, S, E) for (ll i = (E); i >= (S); i--)
#define DEP(i, N) DEPS(i, 0, (N)-1)
#define EXPAND( x ) x//VS用おまじない
#define overload3(_1,_2,_3,name,...) name
#define overload4(_1,_2,_3,_4,name,...) name
#define overload5(_1,_2,_3,_4,_5,name,...) name
#define rep3(i, S, E) for (ll i = (S); i <= (E); i++)
#define rep4(i, S, E, t) for (ll i = (S); i <= (E); i+=(t))
#define rep(...) EXPAND(overload4(__VA_ARGS__,rep4,rep3,_,_)(__VA_ARGS__))
#define dep3(i, E, S) for (ll i = (E); i >= (S); i--)
#define dep4(i, E, S, t) for (ll i = (E); i >= (S); i-=(t))
#define dep(...) EXPAND(overload4(__VA_ARGS__, dep4, dep3,_,_)(__VA_ARGS__))
#define each2(e,v) for (auto && e:v)
#define each3(a,b,v) for (auto &&[a,b]:v)
#define each4(a,b,c,v) for (auto &&[a,b,c]:v)
#define each5(a,b,c,d,v) for (auto &&[a,b,c,d]:v)
#define each(...) EXPAND(overload5(__VA_ARGS__,each5,each4,each3,each2,_)(__VA_ARGS__))
#define ALL1(v) (v).begin(), (v).end()
#define ALL2(v,E) (v).begin(), (v).begin()+((E)+1)
#define ALL3(v,S,E) (v).begin()+(S), (v).begin()+((E)+1)
#define ALL(...) EXPAND(overload3(__VA_ARGS__, ALL3, ALL2, ALL1)(__VA_ARGS__))
#define all ALL
#define RALL1(v) (v).rbegin(), (v).rend()
#define RALL2(v,E) (v).rbegin(), (v).rbegin()+((E)+1)
#define RALL3(v,S,E) (v).rbegin()+(S), (v).rbegin()+((E)+1)
#define RALL(...) EXPAND(overload3(__VA_ARGS__, RALL3, RALL2, RALL1)(__VA_ARGS__))
#define rall RALL
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; }
template<class T> inline T MaxE(vector<T>&v,ll S,ll E){ T m=v[S]; rep(i,S,E)chmax(m,v[i]); return m; }
template<class T> inline T MinE(vector<T>&v,ll S,ll E){ T m=v[S]; rep(i,S,E)chmin(m,v[i]); return m; }
template<class T> inline T MaxE(vector<T> &v) { return MaxE(v,0,(ll)v.size()-1); }
template<class T> inline T MinE(vector<T> &v) { return MinE(v,0,(ll)v.size()-1); }
template<class T> inline auto maxe(T &&v,ll S,ll E){ return *max_element(ALL(v,S,E)); }
template<class T> inline auto maxe(T &&v){ return *max_element(ALL(v)); }
template<class T> inline auto mine(T &&v,ll S,ll E){ return *min_element(ALL(v,S,E)); }
template<class T> inline auto mine(T &&v){ return *min_element(ALL(v)); }
template<class T> inline T Sum(vector<T> &v,ll S,ll E){ T s=T(); rep(i,S,E)s+=v[i]; return s; }
template<class T> inline T Sum(vector<T> &v) { return Sum(v,0,v.size()-1); }
template<class T,class U=typename remove_reference<T>::type::value_type>
inline U sum(T &&v,ll S,ll E) {return accumulate(all(v,S,E),U());}
template<class T> inline auto sum(T &&v) {return sum(v,0,v.end()-v.begin()-1);}
template<class T> inline ll sz(T &&v){ return (ll)v.size(); }
inline ll CEIL(ll a,ll b){ return (a<0) ? -(-a/b) : (a+b-1)/b; } //負もOK
inline ll FLOOR(ll a,ll b){ return -CEIL(-a,b); } //負もOK
//pair用テンプレート
template<class T,class S> inline pair<T,S>& operator+=(pair<T,S> &a,const pair<T,S> &b){ a.first+=b.first; a.second+=b.second; return a; }
template<class T,class S> inline pair<T,S>& operator-=(pair<T,S> &a,const pair<T,S> &b){ a.first-=b.first; a.second-=b.second; return a; }
template<class T,class S> inline pair<T,S>& operator*=(pair<T,S> &a,const pair<T,S> &b){ a.first*=b.first; a.second*=b.second; return a; }
template<class T,class S> inline pair<T,S>& operator/=(pair<T,S> &a,const pair<T,S> &b){ a.first/=b.first; a.second/=b.second; return a; }
template<class T,class S> inline pair<T,S>& operator%=(pair<T,S> &a,const pair<T,S> &b){ a.first%=b.first; a.second%=b.second; return a; }
template<class T,class S,class R> inline pair<T,S>& operator+=(pair<T,S> &a,R b){ a.first+=b; a.second+=b; return a; }
template<class T,class S,class R> inline pair<T,S>& operator-=(pair<T,S> &a,R b){ a.first-=b; a.second-=b; return a; }
template<class T,class S,class R> inline pair<T,S>& operator*=(pair<T,S> &a,R b){ a.first*=b; a.second*=b; return a; }
template<class T,class S,class R> inline pair<T,S>& operator/=(pair<T,S> &a,R b){ a.first/=b; a.second/=b; return a; }
template<class T,class S,class R> inline pair<T,S>& operator%=(pair<T,S> &a,R b){ a.first%=b; a.second%=b; return a; }
template<class T,class S,class R> inline pair<T,S> operator+(const pair<T,S> &a,R b){ pair<T,S> c=a; return c+=b; }
template<class T,class S,class R> inline pair<T,S> operator-(const pair<T,S> &a,R b){ pair<T,S> c=a; return c-=b; }
template<class T,class S,class R> inline pair<T,S> operator*(const pair<T,S> &a,R b){ pair<T,S> c=a; return c*=b; }
template<class T,class S,class R> inline pair<T,S> operator/(const pair<T,S> &a,R b){ pair<T,S> c=a; return c/=b; }
template<class T,class S,class R> inline pair<T,S> operator%(const pair<T,S> &a,R b){ pair<T,S> c=a; return c%=b; }
template<class T,class S,class R> inline pair<T,S> operator-(R b,const pair<T,S> &a){ pair<T,S> c=-a; return c+=b; }
template<class T,class S> inline pair<T,S> operator-(const pair<T,S> &a,const pair<T,S> &b){ pair<T,S> c=a; return c-=b; }
template<class T,class S> inline pair<T,S> operator-(const pair<T,S> &a){ pair<T,S> c=a; return c*=(-1); }
template<class T,class S> inline ostream &operator<<(ostream &os,const pair<T,S> &a){ return os << a.first << ' ' << a.second; }
//tuple用テンプレート 出力用のみ
template<class T,class S,class R> inline ostream &operator<<(ostream &os,const tuple<T,S,R> &a){ return os << get<0>(a) << ' ' << get<1>(a) << ' ' << get<2>(a); }
template<class T,class S,class R,class Q> inline ostream &operator<<(ostream &os,const tuple<T,S,R,Q> &a){ return os << get<0>(a) << ' ' << get<1>(a) << ' ' << get<2>(a) << ' ' << get<3>(a); }
//vector用テンプレート
template<class T> inline ostream &operator<<(ostream &os,const vector<T> &a){ for (ll i=0; i<(ll)a.size(); i++) os<<(i>0?" ":"")<<a[i]; return os; }
//array用テンプレート
template<class T,size_t S> inline array<T,S>& operator+=(array<T,S> &a,const array<T,S> &b){ for (ll i=0; i<(ll)S; i++) a[i]+=b[i]; return a; }
template<class T,size_t S> inline array<T,S>& operator-=(array<T,S> &a,const array<T,S> &b){ for (ll i=0; i<(ll)S; i++) a[i]-=b[i]; return a; }
template<class T,size_t S> inline array<T,S>& operator*=(array<T,S> &a,const array<T,S> &b){ for (ll i=0; i<(ll)S; i++) a[i]*=b[i]; return a; }
template<class T,size_t S> inline array<T,S>& operator/=(array<T,S> &a,const array<T,S> &b){ for (ll i=0; i<(ll)S; i++) a[i]/=b[i]; return a; }
template<class T,size_t S> inline array<T,S>& operator%=(array<T,S> &a,const array<T,S> &b){ for (ll i=0; i<(ll)S; i++) a[i]%=b[i]; return a; }
template<class T,size_t S,class R> inline array<T,S>& operator+=(array<T,S> &a,R b){ for (T &e: a) e+=b; return a; }
template<class T,size_t S,class R> inline array<T,S>& operator-=(array<T,S> &a,R b){ for (T &e: a) e-=b; return a; }
template<class T,size_t S,class R> inline array<T,S>& operator*=(array<T,S> &a,R b){ for (T &e: a) e*=b; return a; }
template<class T,size_t S,class R> inline array<T,S>& operator/=(array<T,S> &a,R b){ for (T &e: a) e/=b; return a; }
template<class T,size_t S,class R> inline array<T,S>& operator%=(array<T,S> &a,R b){ for (T &e: a) e%=b; return a; }
template<class T,size_t S,class R> inline array<T,S> operator+(const array<T,S> &a,R b){ array<T,S> c=a; return c+=b; }
template<class T,size_t S,class R> inline array<T,S> operator-(const array<T,S> &a,R b){ array<T,S> c=a; return c-=b; }
template<class T,size_t S,class R> inline array<T,S> operator*(const array<T,S> &a,R b){ array<T,S> c=a; return c*=b; }
template<class T,size_t S,class R> inline array<T,S> operator/(const array<T,S> &a,R b){ array<T,S> c=a; return c/=b; }
template<class T,size_t S,class R> inline array<T,S> operator%(const array<T,S> &a,R b){ array<T,S> c=a; return c%=b; }
template<class T,size_t S,class R> inline array<T,S> operator-(R b,const array<T,S> &a){ array<T,S> c=-a; return c+=b; }
template<class T,size_t S> inline array<T,S> operator-(const array<T,S> &a,const array<T,S> &b){ array<T,S> c=a; return c-=b; }
template<class T,size_t S> inline array<T,S> operator-(const array<T,S> &a){ array<T,S> c=a; return c*=(-1); }
template<class T,size_t S> inline ostream &operator<<(ostream &os,const array<T,S> &a){ for (ll i=0; i<(ll)S; i++) os<<(i>0?" ":"")<<a[i]; return os; }
template<class T,size_t S,class R> struct view1d;
template<class T,size_t S,class R> struct view1dIter{
view1d<T,S,R> *vw=nullptr;
ll idx=INF;
view1dIter(){}
view1dIter(view1d<T,S,R> *vw_,ll idx_):vw(vw_),idx(idx_){}
view1dIter(const view1dIter<T,S,R> &it):vw(it.vw),idx(it.idx){}
R &operator*() { return (*vw)[idx]; }
R &operator*() const{ return (*vw)[idx]; }
R &operator[](ll i) { return (*vw)[idx+i]; }
R &operator[](ll i)const{ return (*vw)[idx+i]; }
auto &operator++(){ idx++; return *this; }
auto &operator--(){ idx--; return *this; }
auto operator++(int){ auto it=*this; idx++; return it; }
auto operator--(int){ auto it=*this; idx--; return it; }
auto &operator+=(ll n){ idx+=n; return *this; }
auto &operator-=(ll n){ idx-=n; return *this; }
auto operator+(ll n){ auto it=*this; return it+=n; }
auto operator-(ll n){ auto it=*this; return it-=n; }
ll operator- (const view1dIter<T,S,R> &it)const{ return idx- it.idx; }
bool operator< (const view1dIter<T,S,R> &it)const{ return idx< it.idx; }
bool operator> (const view1dIter<T,S,R> &it)const{ return idx> it.idx; }
bool operator<=(const view1dIter<T,S,R> &it)const{ return idx<=it.idx; }
bool operator>=(const view1dIter<T,S,R> &it)const{ return idx>=it.idx; }
bool operator!=(const view1dIter<T,S,R> &it)const{ return idx!=it.idx; }
bool operator==(const view1dIter<T,S,R> &it)const{ return idx==it.idx; }
using iterator_category = random_access_iterator_tag;
using value_type = R;
using difference_type = ll;
using pointer = R*;
using reference = R&;
};
template<class T,size_t S,class R> struct view1d{
using Sll=array<ll,S>;
T &data; //参照先データ
Sll dsize; //参照先データ各軸のサイズ
Sll s=Sll(); //view先頭
Sll d=Sll(); //view方向
ll len; //view長さ
R &dummy; //範囲外の値参照
R dummyj=R(); //範囲外の値実体
/*---- コンストラクタ ----*/
view1d(T &v): data(v),dummy(dummyj){
SetDsize(v,dsize);
d[S-1]=1;
len=dsize[S-1];
}
//このコンストラクタは、マイナス座標指定を末尾にしない(暫定)
//代入時Array<ll,2>{...}等と書くため、使い勝手悪い。将来廃止するかも。
view1d(T &v,Sll s,Sll e,Sll d): data(v),s(s),d(d),len(Len(s,e,d)),dummy(dummyj){
SetDsize(v,dsize);
}
view1d(T &v,Sll s,Sll d,ll len,R &dmy_): data(v),s(s),d(d),len(len),dummy(dmy_){
SetDsize(v,dsize);
}
/*---- 演算 ----*/
template<class Q> auto &operator =(const Q &b){ rep(i,0,len-1) (*this)[i] =b; return *this; }
template<class Q> auto &operator+=(const Q &b){ rep(i,0,len-1) (*this)[i]+=b; return *this; }
template<class Q> auto &operator-=(const Q &b){ rep(i,0,len-1) (*this)[i]-=b; return *this; }
template<class Q> auto &operator*=(const Q &b){ rep(i,0,len-1) (*this)[i]*=b; return *this; }
template<class Q> auto &operator/=(const Q &b){ rep(i,0,len-1) (*this)[i]/=b; return *this; }
template<class Q> auto &operator%=(const Q &b){ rep(i,0,len-1) (*this)[i]%=b; return *this; }
auto &operator =(const string &b){ return CpSeq(b); }
template<size_t Q> auto &operator =(const char (&b)[Q]){ return *this=string(b); }
template<class Q> auto &operator =(const vector<Q> &b){ return CpSeq(b); }
template<class Q> auto &operator+=(const vector<Q> &b){ return PlSeq(b); }
template<class Q> auto &operator-=(const vector<Q> &b){ return MnSeq(b); }
template<class Q> auto &operator*=(const vector<Q> &b){ return PrSeq(b); }
template<class Q> auto &operator/=(const vector<Q> &b){ return DvSeq(b); }
template<class Q> auto &operator%=(const vector<Q> &b){ return RmSeq(b); }
template<class Q,size_t P,class O> auto &operator =(const view1d<Q,P,O> &b){ return CpSeq(b); }
template<class Q,size_t P,class O> auto &operator+=(const view1d<Q,P,O> &b){ return PlSeq(b); }
template<class Q,size_t P,class O> auto &operator-=(const view1d<Q,P,O> &b){ return MnSeq(b); }
template<class Q,size_t P,class O> auto &operator*=(const view1d<Q,P,O> &b){ return PrSeq(b); }
template<class Q,size_t P,class O> auto &operator/=(const view1d<Q,P,O> &b){ return DvSeq(b); }
template<class Q,size_t P,class O> auto &operator%=(const view1d<Q,P,O> &b){ return RmSeq(b); }
template<class Q> auto &CpSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i] =b[i]; return *this; }
template<class Q> auto &PlSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i]+=b[i]; return *this; }
template<class Q> auto &MnSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i]-=b[i]; return *this; }
template<class Q> auto &PrSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i]*=b[i]; return *this; }
template<class Q> auto &DvSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i]/=b[i]; return *this; }
template<class Q> auto &RmSeq(const Q &b){ rep(i,0,min(sz(b),len)-1) (*this)[i]%=b[i]; return *this; }
//template<class Q,class P> static bool eq(const Q &a,const P &b){
// return equals(ALL(a),ALL(b));
//}
template<class Q,class P> static bool eq(const Q &a,const P &b){
if ((ll)a.size()!=(ll)b.size()) return false;
rep(i,0,(ll)a.size()-1){
if (a[i]!=b[i]) return false;
}
return true;
}
template<class Q,class P> static bool lt(const Q &a,const P &b){
ll n=min((ll)a.size(),(ll)b.size());
rep(i,0,n-1){
if (a[i]<b[i])return true;
if (a[i]>b[i])return false;
}
return (ll)a.size()<(ll)b.size();
}
template<class Q,size_t P,class O> bool operator==( const view1d<Q,P,O> &b){ return eq(*this,b); }
template<class Q> bool operator==( const Q &b){ return eq(*this,b); }
template<class Q> friend bool operator==(const Q &a,const view1d<T,S,R> &b){ return eq( a,b); }
template<size_t Q> bool operator==( const char (&b)[Q]){ return eq(*this,string(b)); }
template<class Q,size_t P,class O> bool operator!=( const view1d<Q,P,O> &b){ return !(*this==b); }
template<class Q> bool operator!=( const Q &b){ return !(*this==b); }
template<class Q> friend bool operator!=(const Q &a,const view1d<T,S,R> &b){ return !( a==b); }
template<class Q,size_t P,class O> bool operator< ( const view1d<Q,P,O> &b){ return lt(*this,b); }
template<class Q> bool operator< ( const Q &b){ return lt(*this,b); }
template<class Q> friend bool operator< (const Q &a,const view1d<T,S,R> &b){ return lt( a,b); }
template<class Q,size_t P,class O> bool operator> ( const view1d<Q,P,O> &b){ return lt(b,*this); }
template<class Q> bool operator> ( const Q &b){ return lt(b,*this); }
template<class Q> friend bool operator> (const Q &a,const view1d<T,S,R> &b){ return lt(b,a ); }
template<class Q,size_t P,class O> bool operator<=( const view1d<Q,P,O> &b){ return !(*this>b); }
template<class Q> bool operator<=( const Q &b){ return !(*this>b); }
template<class Q> friend bool operator<=(const Q &a,const view1d<T,S,R> &b){ return !( a>b); }
template<class Q,size_t P,class O> bool operator>=( const view1d<Q,P,O> &b){ return !(*this<b); }
template<class Q> bool operator>=( const Q &b){ return !(*this<b); }
template<class Q> friend bool operator>=(const Q &a,const view1d<T,S,R> &b){ return !( a<b); }
/*---- getter ----*/
ll size() const { return len; }
R &operator[](ll i){ return const_cast<R&>(OrgAt(s+d*i)); }
const R &operator[](ll i) const { return OrgAt(s+d*i); }
R &at(ll i){ if(i<0)i+=len; return (*this)[i]; }
//vector<R> tov(){ vector<R> vvv(len); rep(i,0,len-1) vvv[i]=(*this)[i]; return vvv; }
operator vector<R>(){ vector<R> v(len); rep(i,0,len-1) v[i]=(*this)[i]; return v; }
bool contains(R a){ rep(i,0,len-1) if((*this)[i]==a)return true; return false; }
auto begin(){ return view1dIter<T,S,R>(this,0); }
auto end(){ return view1dIter<T,S,R>(this,len); }
/*---- view設定 ----*/
view1d<T,S,R> &dmy(R dmy_) { dummy=dmy_; return *this; }//ダミー値セット
template<class...Q> view1d<T,S,R> &st(Q... s_){//始点set 負は末尾からの位置
this->s=RevIfNeg(SllD(s_...));
this->len=AutoLen(this->s,this->d,this->dsize);
return *this;
}
template<class...Q> view1d<T,S,R> &en(Q... e_){//終了条件再設定 負は末尾から
this->len=Len(s, RevIfNeg(SllD(e_...)), d);
return *this;
}
template<class...Q> view1d<T,S,R> &dir(Q... d_){//方向set、長さはdata端まで
this->d=SllD(d_...);
this->len=AutoLen(this->s,this->d,this->dsize);
return *this;
}
template<class...Q>
view1d<T,S,R> &mv(Q... s_){ this->s+=SllD(s_...); return *this; }//平行移動
view1d<T,S,R> &size(ll len_) { len=len_; return *this; }//長さset
template<class Q> view1d<T,S,R> &size(Q &v){ len=(ll)v.size(); return *this; }//長さset
view1d<T,S,R> &rev() { s+=d*(len-1); d*=-1; return *this; }//反転
/*---- utility ----*/
template<class Q> inline static ll sz(Q &v){ return (ll)v.size(); }
Sll RevIfNeg(Sll pos){//!< 負なら末尾からの位置に変換
rep(i,0,S-1) if (pos[i]<0) pos[i]+=dsize[i];
return pos;
}
static ll AutoLen(Sll s_,Sll d_,Sll dsz){//位置s_から方向d_ではみ出すまでの長さ
Sll e=dsz-1;
rep(i,0,S-1) e[i] *= (d_[i]>=0);//方向が負の軸を0にする
return Len(s_,e,d_);
}
/*---- 先頭位置s、方向d、終了条件eから長さlen計算 ----*/
//template<size_t Q> static ll Len(array<ll,Q> s,array<ll,Q> e,array<ll,Q> d){
// ll ret=INF;
// rep(i,0,Q-1) chmin(ret, Len1(s[i],e[i],d[i]));
// return ret;
//}
static ll Len(Sll s,Sll e,Sll d){
ll ret=INF;
rep(i,0,S-1) chmin(ret, Len1(s[i],e[i],d[i]));
return ret;
}
static ll Len1(ll s,ll e,ll d){
if (d==0) return INF;
if (d<0){ s=-s; e=-e; d=-d; }
if (s>e) return 0;
return (e-s)/d+1;
}
/*---- 可変長引数をSllに変換 ----*/
template<class...Q> static Sll SllD(Q... args){ return SllRec(0,args...); }
template<class...Q> static Sll SllRec(ll i,ll first,Q... rest) {
Sll sll = (i==S-1) ? Sll() : SllRec(i+1,rest...);
sll[i]=first;
return sll;
}
static Sll SllRec(ll i){ return Sll(); }
/*---- dataの位置posの値取得 ----*/
const R &OrgAt(Sll pos) const {
rep(i,0,S-1){
if (pos[i]<0 || dsize[i]<=pos[i]) return dummy;
}
return OrgAt_(data,pos);
}
template<class Q> using V = vector<Q>;
template<class Q> using VV = V<V<Q>>;
template<class Q> using VVV = V<V<V<Q>>>;
using Vs = V<string>;
using VVs = VV<string>;
using ll1 = array<ll,1>;
using ll2 = array<ll,2>;
using ll3 = array<ll,3>;
auto &OrgAt_(V<R> &dat,ll1 pos)const{ auto [i] =pos; return dat[i]; }
auto &OrgAt_(string &dat,ll1 pos)const{ auto [i] =pos; return dat[i]; }
auto &OrgAt_(VV<R> &dat,ll2 pos)const{ auto [i,j] =pos; return dat[i][j]; }
auto &OrgAt_(Vs &dat,ll2 pos)const{ auto [i,j] =pos; return dat[i][j]; }
auto &OrgAt_(VVV<R> &dat,ll3 pos)const{ auto [i,j,k]=pos; return dat[i][j][k]; }
auto &OrgAt_(VVs &dat,ll3 pos)const{ auto [i,j,k]=pos; return dat[i][j][k]; }
/*---- dataの各軸size取得 ----*/
static void SetDsize(V<R> &dat,ll1 &dsz){ dsz={sz(dat)}; }
static void SetDsize(string &dat,ll1 &dsz){ dsz={sz(dat)}; }
static void SetDsize(VV<R> &dat,ll2 &dsz){ dsz={sz(dat),sz(dat[0])}; }
static void SetDsize(Vs &dat,ll2 &dsz){ dsz={sz(dat),sz(dat[0])}; }
static void SetDsize(VVV<R> &dat,ll3 &dsz){ dsz={sz(dat),sz(dat[0]),sz(dat[0][0])}; }
static void SetDsize(VVs &dat,ll3 &dsz){ dsz={sz(dat),sz(dat[0]),sz(dat[0][0])}; }
typedef view1dIter<T,S,R> iterator;
using value_type = R;
};
template<class Q> using V = vector<Q>;
template<class Q> using VV = V<V<Q>>;
template<class Q> using VVV = V<V<V<Q>>>;
template<class T> view1d( VVV<T> ) -> view1d< VVV<T>,3,T>;
template<class T> view1d( VV<T> ) -> view1d< VV<T>,2,T>;
template<class T> view1d( V<T> ) -> view1d< V<T>,1,T>;
; view1d(VV<string> ) -> view1d<VV<string>,3,char>;
; view1d( V<string> ) -> view1d< V<string>,2,char>;
; view1d( string ) -> view1d< string ,1,char>;
template<class T,class S> view1d( VVV<T>,S,S,S) -> view1d< VVV<T>,3,T>;
template<class T,class S> view1d( VV<T>,S,S,S) -> view1d< VV<T>,2,T>;
template<class T,class S> view1d( V<T>,S,S,S) -> view1d< V<T>,1,T>;
template<class S> view1d(VV<string>,S,S,S) -> view1d<VV<string>,3,char>;
template<class S> view1d( V<string>,S,S,S) -> view1d< V<string>,2,char>;
template<class S> view1d( string ,S,S,S) -> view1d< string ,1,char>;
template<class VIEW2D> struct view2dIter{
VIEW2D *vw=nullptr;
ll idx=INF;
view2dIter(){}
view2dIter(VIEW2D *vw_,ll idx_):vw(vw_),idx(idx_){}
view2dIter(const view2dIter &it):vw(it.vw),idx(it.idx){}
auto &operator*() { return (*vw)[x(idx)][y(idx)]; }
auto &operator*() const{ return (*vw)[x(idx)][y(idx)]; }
auto &operator[](ll i) { return (*vw)[x(idx+i)][y(idx+i)]; }
auto &operator[](ll i)const{ return (*vw)[x(idx+i)][y(idx+i)]; }
auto &operator++(){ idx++; return *this; }
auto &operator--(){ idx--; return *this; }
auto operator++(int){ auto it=*this; idx++; return it; }
auto operator--(int){ auto it=*this; idx--; return it; }
auto &operator+=(ll n){ idx+=n; return *this; }
auto &operator-=(ll n){ idx-=n; return *this; }
auto operator+(ll n){ auto it=*this; return it+=n; }
auto operator-(ll n){ auto it=*this; return it-=n; }
ll operator- (const view2dIter &it)const{ return idx- it.idx; }
bool operator< (const view2dIter &it)const{ return idx< it.idx; }
bool operator> (const view2dIter &it)const{ return idx> it.idx; }
bool operator<=(const view2dIter &it)const{ return idx<=it.idx; }
bool operator>=(const view2dIter &it)const{ return idx>=it.idx; }
bool operator!=(const view2dIter &it)const{ return idx!=it.idx; }
bool operator==(const view2dIter &it)const{ return idx==it.idx; }
ll x(ll i)const{ return i/vw->leny(); }
ll y(ll i)const{ return i%vw->leny(); }
using iterator_category = random_access_iterator_tag;
using value_type = typename VIEW2D::value_type;
using difference_type = ll;
using pointer = value_type*;
using reference = value_type&;
};
template<class T,size_t S,class R> struct view2d{
using Sll=array<ll,S>;
T &data; //参照先データ
Sll dsize; //参照先データ各軸のサイズ
Sll s=Sll(); //view始点
Sll dx=Sll(); //view x軸方向
Sll dy=Sll(); //view y軸方向
ll xl; //view x軸長さ
ll yl; //view y軸長さ
R dummy=R(); //範囲外の値
/*---- コンストラクタ ----*/
view2d(T &v): data(v){
view1d<T,S,R>::SetDsize(v,dsize);
dx[S-2]=1;
dy[S-1]=1;
xl=dsize[S-2];
yl=dsize[S-1];
}
/*---- 演算 ----*/
//template<class Q> auto &operator =(const Q &b){ rep(i,0,xl-1) (*this)[i] =b; return *this; }
//template<class Q,size_t P,class O> auto &operator+=(const view2d<Q,P,O> &b){
// rep(i,0,xl-1) (*this)[i]
// return PlSeq(b); }
/*---- getter ----*/
ll size() const { return xl; }
array<ll,2> shape() const { return {xl,yl}; }
ll lenx() const { return xl; }
ll leny() const { return yl; }
///pll shape() const { return {xl,yl}; }
view1d<T,S,R> operator[](ll i){ return view1d(data,s+dx*i,dy,yl,dummy); }
const view1d<T,S,R> operator[](ll i) const { return view1d(data,s+dx*i,dy,yl,dummy); }
R &at(ll i,ll j){ if(i<0)i+=xl; if(j<0)j+=yl; return (*this)[i][j]; }
//vector<vector<R>> tovv(){
// vector<vector<R>> vvv(xl);
// ///rep(i,0,xl-1) vvv[i]=(*this)[i].tov(); return vvv;
// rep(i,0,xl-1) vvv[i]=(*this)[i]; return vvv;
//}
operator vector<vector<R>>(){
vector<vector<R>> v(xl);
rep(i,0,xl-1) v[i]=(*this)[i]; return v;
}
auto begin(){ return view2dIter(this,0); }
auto end(){ return view2dIter(this,xl*yl); }
#if defined(_DEBUG)
void dump(){ ::dump(tovv()); }
#endif
/*---- view設定 ----*/
view2d<T,S,R> &dmy(R dmy_) { dummy=dmy_; return *this; }//ダミー値セット
template<class...Q> view2d<T,S,R> &st(Q... s_){//始点set 負は末尾からの位置
this->s=RevIfNeg(view1d<T,S,R>::SllD(s_...));
this->xl=view1d<T,S,R>::AutoLen(this->s,this->dx,this->dsize);
this->yl=view1d<T,S,R>::AutoLen(this->s,this->dy,this->dsize);
return *this;
}
template<class...Q> view2d<T,S,R> &dirx(Q... d_){//x軸set、長さはdata端まで
this->dx=view1d<T,S,R>::SllD(d_...);
this->xl=view1d<T,S,R>::AutoLen(this->s,this->dx,this->dsize);
return *this;
}
template<class...Q> view2d<T,S,R> &diry(Q... d_){//y軸set、長さはdata端まで
this->dy=view1d<T,S,R>::SllD(d_...);
this->yl=view1d<T,S,R>::AutoLen(this->s,this->dy,this->dsize);
return *this;
}
template<class...Q> view2d<T,S,R> &mv(Q... s_){//平行移動
this->s += view1d<T,S,R>::SllD(s_...);
return *this;
}
view2d<T,S,R> &lenx(ll xl_) { xl=xl_; return *this; }
view2d<T,S,R> &leny(ll yl_) { yl=yl_; return *this; }
view2d<T,S,R> &shape(ll xl_,ll yl_) { xl=xl_; yl=yl_; return *this; }
template<class Q> view2d<T,S,R> &shape(Q &v) { xl=v.lenx(); yl=v.leny(); return *this; }
view2d<T,S,R> &rot90 () { s+=dx*(xl-1); swap(xl,yl); swap(dx,dy); dy*=-1; return *this; }
view2d<T,S,R> &rot270() { s+=dy*(yl-1); swap(xl,yl); swap(dx,dy); dx*=-1; return *this; }
view2d<T,S,R> &rot180() { s+=dx*(xl-1)+dy*(yl-1); dx*=-1; dy*=-1; return *this; }
view2d<T,S,R> &revx() { s+=dx*(xl-1); dx*=-1; return *this; }
view2d<T,S,R> &revy() { s+=dy*(yl-1); dy*=-1; return *this; }
view2d<T,S,R> &swapxy() { swap(xl,yl); swap(dx,dy); return *this; }//xy軸入替
/*---- utility ----*/
Sll RevIfNeg(Sll pos){//!< 負なら末尾からの位置に変換
rep(i,0,S-1) if (pos[i]<0) pos[i]+=dsize[i];
return pos;
}
using value_type = R;
};
template<class T> view2d( VVV<T>) -> view2d< VVV<T>,3,T>;
template<class T> view2d( VV<T>) -> view2d< VV<T>,2,T>;
; view2d(VV<string>) -> view2d<VV<string>,3,char>;
; view2d( V<string>) -> view2d< V<string>,2,char>;
/*
zipは参照のpairを返す。それをさらに参照するのはまずいので、コピーする。
*/
template<class ZIP> struct zipIter{
ZIP *z=nullptr;
ll idx=INF;
zipIter(){}
zipIter(ZIP *z_,ll idx_):z(z_),idx(idx_){}
zipIter(const zipIter<ZIP> &it):z(it.z),idx(it.idx){}
auto operator*() { return (*z)[idx]; }//参照ではなく値戻し
auto operator*() const{ return (*z)[idx]; }//同上
auto operator[](ll i) { return (*z)[idx+i]; }//同上
auto operator[](ll i)const{ return (*z)[idx+i]; }//同上
auto &operator++(){ idx++; return *this; }
auto &operator--(){ idx--; return *this; }
auto operator++(int){ auto it=*this; idx++; return it; }
auto operator--(int){ auto it=*this; idx--; return it; }
auto &operator+=(ll n){ idx+=n; return *this; }
auto &operator-=(ll n){ idx-=n; return *this; }
auto operator+(ll n){ auto it=*this; return it+=n; }
auto operator-(ll n){ auto it=*this; return it-=n; }
ll operator- (const zipIter<ZIP> &it)const{ return idx- it.idx; }
bool operator< (const zipIter<ZIP> &it)const{ return idx< it.idx; }
bool operator> (const zipIter<ZIP> &it)const{ return idx> it.idx; }
bool operator<=(const zipIter<ZIP> &it)const{ return idx<=it.idx; }
bool operator>=(const zipIter<ZIP> &it)const{ return idx>=it.idx; }
bool operator!=(const zipIter<ZIP> &it)const{ return idx!=it.idx; }
bool operator==(const zipIter<ZIP> &it)const{ return idx==it.idx; }
using iterator_category = random_access_iterator_tag;
using value_type = typename ZIP::value_type;
using difference_type = ll;
using pointer = value_type*;
using reference = value_type&;
};
template<class T,class S> struct zip2{
T &t; S &s;
zip2(T &t_,S &s_):t(t_),s(s_){}
ll size() const { return t.end()-t.begin(); }
auto operator[](ll i) { return make_pair(ref(t.begin()[i]),ref(s.begin()[i])); }
auto operator[](ll i)const{ return make_pair(ref(t.begin()[i]),ref(s.begin()[i])); }
auto begin(){ return zipIter(this,0); }
auto end(){ return zipIter(this,size()); }
using value_type = pair<typename T::value_type,typename S::value_type>;
};
template<class T,class S,class R> struct zip3{
T &t; S &s; R &r;
zip3(T &t_,S &s_,R &r_):t(t_),s(s_),r(r_){}
ll size() const { return t.end()-t.begin(); }
auto operator[](ll i) { return make_tuple(ref(t.begin()[i]),ref(s.begin()[i]),ref(r.begin()[i])); }
auto operator[](ll i)const{ return make_tuple(ref(t.begin()[i]),ref(s.begin()[i]),ref(r.begin()[i])); }
auto begin(){ return zipIter(this,0); }
auto end(){ return zipIter(this,size()); }
using value_type = tuple<typename T::value_type,typename S::value_type,typename R::value_type>;
};
#endif//テンプレートend
#if defined(_MSC_VER) && __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#endif
struct{
system_clock::time_point st = system_clock::now();
ll operator()()const{return duration_cast<microseconds>(system_clock::now()-st).count()/1000;}
} timeget;
//////////////////////////////////////////
template<long long MOD> struct mll_{
using ll = long long;
ll val=0;
/*---- utility ----*/
mll_ &norm(){ return normR().normS(); }//正規化
mll_ &normR(){ val%=MOD; return *this; }//剰余正規化のみ
mll_ &normS(){ if (val<0) val+=MOD; return *this; }//正負正規化のみ
mll_ &normP(){ if (val>=MOD) val-=MOD; return *this; }//加算時正規化
mll_ &invsg(){ val=-val; return normS(); }//正負反転
ll modinv(int a){//a^-1 mod MOD
int ypre=0,y=1,apre=MOD;
while (a>1){
int t=apre/a;
apre-=a*t,swap(a,apre);
ypre-=y*t,swap(y,ypre);
}
return y<0 ? y+MOD: y;
}
/*---- I/F ----*/
mll_(){}
mll_(ll v): val(v){ norm(); }
mll_(ll v,bool b): val(v){} //正規化無のコンストラクタ
bool isnone() const { return val==-1; } //true:値なし
mll_ &none() { val=-1; return *this; } //値なしにする
mll_ &inv(){ val=modinv((int)val); return *this; }
mll_ &operator+=(mll_ b){ val+=b.val; return normP(); }
mll_ &operator-=(mll_ b){ val-=b.val; return normS(); }
mll_ &operator*=(mll_ b){ val*=b.val; return normR(); }
mll_ &operator/=(mll_ b){ return *this*=b.inv(); }
mll_ &operator+=(ll b){ return *this+=mll_(b); }
mll_ &operator-=(ll b){ return *this-=mll_(b); }
mll_ &operator*=(ll b){ return *this*=mll_(b); }
mll_ &operator/=(ll b){ return *this/=mll_(b); }
mll_ operator-()const{ return mll_(*this).invsg(); }
mll_ operator+(mll_ b)const{ return mll_(*this)+=b; }
mll_ operator-(mll_ b)const{ return mll_(*this)-=b; }
mll_ operator*(mll_ b)const{ return mll_(*this)*=b; }
mll_ operator/(mll_ b)const{ return mll_(*this)/=b; }
mll_ operator+(ll b)const{ return mll_(*this)+=b; }
mll_ operator-(ll b)const{ return mll_(*this)-=b; }
mll_ operator*(ll b)const{ return mll_(*this)*=b; }
mll_ operator/(ll b)const{ return mll_(*this)/=b; }
friend mll_ operator+(ll a,mll_ b){ return b+a; }
friend mll_ operator-(ll a,mll_ b){ return -b+a; }
friend mll_ operator*(ll a,mll_ b){ return b*a; }
friend mll_ operator/(ll a,mll_ b){ return mll_(a)/b; }
bool operator==(mll_ b)const{ return val==b.val; }
bool operator!=(mll_ b)const{ return val!=b.val; }
bool operator==(ll b)const{ return *this==mll_(b); }
bool operator!=(ll b)const{ return *this!=mll_(b); }
friend bool operator==(ll a,mll_ b){ return mll_(a)==b; }
friend bool operator!=(ll a,mll_ b){ return mll_(a)!=b; }
friend ostream &operator<<(ostream &os,mll_ a){ return os << a.val; }
friend istream &operator>>(istream &is,mll_ &a){ return is >> a.val; }
enum{ modll=MOD };
};
#if 0
#define MODLL (1000000007LL)
#else
#define MODLL (998244353LL)
#endif
using mll = mll_<MODLL>;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
template<class T> struct Vector: vector<T>{
using Int = long long;
using vT=vector<T>;
using cvT=const vector<T>;
using cT=const T;
using vT::vT; //親クラスのコンストラクタの隠蔽を回避
using vT::begin,vT::end,vT::insert,vT::erase;
auto it(Int i){ return begin()+i; }
auto it(Int i)const{ return begin()+i; }
Vector(cvT& b):vT(b){}
Vector(vT&& b):vT(move(b)){}
Int size()const{ return (Int)vT::size(); }
Vector &push_back(cT& x){ vT::push_back(x); return *this; }
Vector &pop_back(){ vT::pop_back(); return *this; }
Vector &push_front(cT& x){ insert(begin(),x); return *this; }
Vector &pop_front(){ erase(0); return *this; }
Vector &insert(Int i,cT& x){ insert(it(i),x); return *this; }
Vector &insert(Int i,cvT& b){ insert(it(i),b.begin(),b.end()); return *this; }
Vector &erase(Int i){ erase(it(i)); return *this; }
Vector &erase(Int l,Int r){ erase(it(l),it(r+1)); return *this; }
Vector &concat(cvT &b){ insert(end(),b.begin(),b.end()); return *this; }
Vector &concat(cvT &b,Int n){ for (int i=0;i<n;++i) concat(b); return *this; }
Vector &repeat(Int n){ concat(vT(*this),n-1); return *this; }
Vector &reverse(){ std::reverse(begin(),end()); return *this; }
Vector &sort(){ std::sort(begin(),end()); return *this; }
Vector &rsort(){ std::sort(vT::rbegin(),vT::rend()); return *this; }
template<class Pr> Vector &sort(Pr pr){ std::sort(begin(),end(),pr); return *this; }
Vector &uniq(){ erase(unique(begin(),end()),end()); return *this; }
Vector &sortq(){ return sort().uniq(); }
Vector &fill(Int l,Int r,cT& x){ std::fill(it(l),it(r+1),x); return *this; }
template<class S=Int> Vector &iota(Int n,T s=0,S d=1){
vT::resize(n);
if (n==0) return *this;
(*this)[0]=s;
for (int i=1;i<n;++i) (*this)[i]=(*this)[i-1]+d;
return *this;
}
Int count(cT& x)const{ return std::count(begin(),end(),x); }
Int count(Int l,Int r,cT& x)const{ return std::count(it(l),it(r+1),x); }
template<class Pr> Int countif(Pr pr)const{ return count_if(begin(),end(),pr); }
template<class Pr> Int countif(Int l,Int r,Pr pr)const{ return count_if(it(l),it(r+1),pr); }
Int find(cT& x)const{ return std::find(begin(),end(),x)-begin(); }
Int find(Int l,Int r,cT& x)const{ return std::find(it(l),it(r+1),x)-begin(); }
template<class Pr> Int findif(Pr pr)const{ return find_if(begin(),end(),pr)-begin(); }
template<class Pr> Int findif(Int l,Int r,Pr pr)const{ return find_if(it(l),it(r+1),pr)-begin(); }
Vector<Int> findall(cT& x)const{ return findall(0,size()-1,x); }
Vector<Int> findall(Int l,Int r,cT& x)const{ return findallif(l,r,[&](cT& y){return y==x;}); }
template<class Pr> Vector<Int> findallif(Pr pr)const{ return findallif(0,size()-1,pr); }
template<class Pr> Vector<Int> findallif(Int l,Int r,Pr pr)const{
Vector<Int> ret;
for (Int i=l;i<=r;++i) if (pr((*this)[i])) ret.push_back(i);
return ret;
}
Int flooridx(cT& x)const{ return upper_bound(begin(),end(),x)-begin()-1; }
Int ceilidx(cT& x)const{ return lower_bound(begin(),end(),x)-begin(); }
Int leftnmof(cT& x)const{ return flooridx(x)+1; }
Int rightnmof(cT& x)const{ return size()-ceilidx(x); }
template<class Pr> Int flooridx(cT& x,Pr pr)const{ return upper_bound(begin(),end(),x,pr)-begin()-1; }
template<class Pr> Int ceilidx(cT& x,Pr pr)const{ return lower_bound(begin(),end(),x,pr)-begin(); }
template<class Pr> Int leftnmof(cT& x,Pr pr)const{ return flooridx(x,pr)+1; }
template<class Pr> Int rightnmof(cT& x,Pr pr)const{ return size()-ceilidx(x,pr); }
};
using Vll=Vector< ll>; using Vdd=Vector< dd>;
using VVll=Vector< Vll>; using VVdd=Vector< Vdd>;
using VVVll=Vector<VVll>; using VVVdd=Vector<VVdd>;
using Vpll=Vector< pll>; using Vtll=Vector< tll>; using Vqll=Vector< qll>;
using VVpll=Vector<Vpll>; using VVtll=Vector<Vtll>; using VVqll=Vector<Vqll>;
/*
Vll a={9,8,7},b={1,2,3};
Vpll p={{5,3},{7,8},{0,2},};
- -------- 操作系 --------
a.push_front(x);
a.push_back(x);
a.pop_front();
a.pop_back();
a.insert(i,x); //a[i]にx挿入
a.insert(i,b); //a[i]にVll b挿入
a.erase(i); //a[i]削除
a.erase(l,r); //区間[l,r]削除
a.concat(b); //aにbを結合
a.concat(b,n); //aにbをn回結合
a.repeat(n); //aをn回繰り返す
a.reverse(); //反転
a.sort(); //ソート
a.rsort(); //逆順ソート
p.sort([&](pll x,pll y){return x.second<y.second;});//比較関数指定ソート
a.uniq(); //連続同値を1つにする
a.sortq(); //ソートしてユニーク
a.fill(l,r,x); //[l,r]にx代入
a.iota(n,s,d); //aを等差数列にする 長さn,初項s,公差d
- -------- 検索系 --------
auto pr=[&](auto &x){ return x>0; }; //検索条件
ll m=a.count(x); //xの個数
ll m=a.count(l,r,x); //xの個数in[l,r]
ll m=a.countif(pr); //条件満たす個数
ll m=a.countif(l,r,pr); //条件満たす個数in[l,r]
ll i=a.find(x); //xの最左位置i ない時N(配列長)
ll i=a.find(l,r,x); //xの最左位置i in[l,r] ない時r+1
ll i=a.findif(pr); //条件満たす最左位置i ない時N(配列長)
ll i=a.findif(l,r,pr); //条件満たす最左位置i in[l,r] ない時r+1
Vll is=a.findall(x); //xの位置i列挙
Vll is=a.findall(l,r,x); //xの位置i列挙in[l,r]
Vll is=a.findallif(pr); //条件満たす位置i列挙
Vll is=a.findallif(l,r,pr); //条件満たす位置i列挙in[l,r]
- -------- 昇順sort済み配列用 --------
ll i=a.flooridx(x); //x以下の最近傍位置i ない時-1
ll i=a.ceilidx(x); //x以上の最近傍位置i ない時N(配列長)
ll m=a.leftnmof(x); //x以下の個数
ll m=a.rightnmof(x); //x以上の個数
- -------- 比較関数prでsort済みの配列用 --------
auto pr=[&](auto &x,auto &y){ return x>y; }; //降順ソート時
ll i=a.flooridx(x,pr); //x以左の最近傍位置i ない時-1
ll i=a.ceilidx(x,pr); //x以右の最近傍位置i ない時N(配列長)
ll m=a.leftnmof(x,pr); //x以左の個数
ll m=a.rightnmof(x,pr); //x以右の個数
a.concat(b,n).pop_back().rsort().uniq(); //連続適用できる
*/
using Vmll = Vector<mll>;
using VVmll = Vector<Vmll>;
using VVVmll = Vector<VVmll>;
using VVVVmll = Vector<VVVmll>;
struct rndutil{
using Int = long long;
mt19937 mt;
rndutil(Int seed=0):mt((unsigned int)seed){}
Int val(Int a,Int b){ return mt()%(b-a+1)+a; }//[a,b]の乱数
dd dval(){ return (dd)mt()/(1ll<<32); }//[0,1)の浮動小数点乱数
vector<Int> ary(Int n,Int a,Int b){//長さnの配列、要素[a,b]内、重複可
vector<Int> v(n);
for (Int i=0;i<n;++i) v[i]=this->val(a,b);
return v;
}
vdd dary(Int n){//長さnの[0,1)の浮動小数点乱数
vdd v(n);
for (Int i=0;i<n;++i) v[i]=this->dval();
return v;
}
string str(Int n,char cs,char ce){//長さnのstring、使用文字cs~ce、重複可
string str(n,cs);
for (Int i=0;i<n;++i) str[i]+=(char)this->val(0,ce-cs);
return str;
}
vector<Int> sample(Int n,Int a,Int b){//長さnの配列、要素[a,b]内、重複無
Int len=b-a+1;
assert(n<=len);
vector<Int> v(len);
iota(v.begin(),v.end(),a);
for (Int i=0;i<n;++i) swap(v[i],v[this->val(i,len-1)]);
v.resize(n);
return v;
}
template <class T> auto sample(const T &v){//1つ選択
return v[val(0,(Int)v.size()-1)];
}
template <class T> auto samplepop(T &v){//1つ取り出し(末尾swapし削除)
Int i=val(0,(Int)v.size()-1);
auto ret=v[i];
v[i]=v.back();
v.pop_back();
return ret;
}
Int weightedSampleCore(const vector<Int> &cm){//重み付き乱択 累積和版
Int randval=val(1,cm.back());
return lower_bound(cm.begin(),cm.end(),randval)-cm.begin();
}
Int weightedSample(const vector<Int> &pr){//重み付き乱択
vector<Int> cm=pr;
for (Int i=1;i<(Int)cm.size();++i) cm[i]+=cm[i-1];
return weightedSampleCore(cm);
}
template <class T> void shuffle(T &v){//配列や文字列をシャッフル
Int n=(Int)v.size();
for (Int i=0;i<n;++i) swap(v[i],v[this->val(i,n-1)]);
}
pair<Int,Int> range(Int a,Int b,Int m=1){ //[a,b]内閉区間長さm以上
while (true){
Int l=this->val(a,b+1),r=this->val(a,b+1);
if (r-l<m)continue;
return {l,r-1};
}
}
pair<Int,vector<pair<Int,Int>>> graph(Int n){ //単純連結無向グラフ 木に近いものが多め
while (true){
vector<pair<Int,Int>> uv;
UnionFindTree uft(n);
for (Int v=0;v<n;++v) for (Int u=v+1;u<n;++u){
if (this->val(1,n*(n-1)/2)>=n)continue;//各辺確率n/Mで採用(M:総辺数n(n-1)/2)
uv.emplace_back(v,u);
uft.Unite(v,u);
}
if (uft.grpnm()==1) return {(Int)uv.size(),uv};
}
}
vector<pair<Int,Int>> tree(Int n){ //木
vector<pair<Int,Int>> uv;
UnionFindTree uft(n);
while (uft.grpnm()>1){
Int u=this->val(0,n-1),v=this->val(0,n-1);
if (uft.Same(u,v)) continue;
if (u>v)swap(u,v);
uft.Unite(u,v);
uv.emplace_back(u,v);
}
return uv;
}
struct UnionFindTree{
vector<Int> par,rank,size;
Int g;
UnionFindTree(Int num): par(num),rank(num),size(num,1),g(num){
for (Int i=0;i<num;++i) par[i] = i;
}
bool Same(Int x,Int y) { return Root(x) == Root(y); }
Int Root(Int x) { return (par[x] == x) ? x : par[x]=Root(par[x]); }
Int Size(Int x){ return size[Root(x)]; }
Int grpnm() { return g; }
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]++;
size[x] = size[y] = size[x] + size[y];
g--;
}
};
};
/*
rndutil ru;
- -------- 整数x -------- 区間[a,b]
ll x=ru.val(a,b);
- -------- 浮動小数点数x -------- [0,1)
dd x=ru.dval();
- -------- 整数ベクトルv -------- 長さn,要素の区間[a,b] 配列重複有
vll v=ru.ary(n,a,b);
- -------- 整数ベクトルv -------- 長さn,要素の区間[a,b] 配列重複無
vll v=ru.sample(n,a,b);
- -------- 浮動小数点ベクトルv -------- 長さn,[0,1)
vdd v=ru.dary(n);
- -------- 文字列s -------- 長さn,使用文字'a'~'z'
string s=ru.str(n,'a','z');
- -------- 乱択 -------- vll,string等から1つ選択
ll x=ru.sample(v);
char c=ru.sample(s);
- -------- 乱択削除 -------- vll,string等から1つ取り出し(末尾swapし削除)
ll x=ru.samplepop(v);
- -------- 重み付き乱択 -------- i∈{0,1,…,n-1}を重みwiで選択
ll i=ru.weightedSample(w);
ll i=ru.weightedSampleCore(cm);
. ↑wの累積和を与えることで高速に
- -------- シャッフル -------- vll,string等
ru.shuffle(a);
- -------- 範囲[l,r] -------- [l,r]⊆[a,b] 区間長1以上
auto[l,r]=ru.range(a,b);
auto[l,r]=ru.range(a,b,m);
. ↑区間長m以上
- -------- 木(辺集合uv) -------- 頂点数n
vpll uv=ru.tree(n);
- -------- 単純連結無向グラフ(辺集合uv,辺数m) -------- 頂点数n
auto[m,uv]=ru.graph(n);
*/
template<class E> struct HeavyLightDecomposition{
using Int = long long;
vector<vector<E>> *to=nullptr; //グラフ
vector<Int> head; //head[v] 頂点vの属する重パスの根側端頂点
vector<Int> id; //id[v] 頂点vの行きがけ順番号 0-origin
vector<Int> rev; //rev[ID] 行きがけ順番号IDの頂点v
vector<Int> lst; //lst[v] 頂点vのサブ木内頂点の行きがけ順番号最大値
vector<Int> par; //par[v] 頂点vの親頂点 par[根]は-1
vector<Int> siz; //siz[v] 頂点vのサブ木内頂点数(v含む)
vector<Int> dpt; //dpt[v] 頂点vの深さ(根が0)
HeavyLightDecomposition(){}
HeavyLightDecomposition(vector<vector<E>> &to_,Int root=0):
to(&to_),head(size(),root),id(size()),rev(size()),lst(size()),
par(size()),siz(size(),1),dpt(size())
{
assert(!to_.empty());
dfsSz(root);
dfsHld(root);
}
Int size()const{ return to->size(); } //頂点数
Int vof(Int id_)const{ return rev[id_]; }
Int idof(Int v)const{ return id[v]; }
Int parentof(Int v)const{ return par[v]; }
Int subszof(Int v)const{ return siz[v]; }
Int depthof(Int v)const{ return dpt[v]; }
bool isleaf(Int v)const{
return id[v]==size()-1 || head[v]!=head[rev[id[v]+1]];
}
vector<pair<Int,Int>> preorder()const{ //行きがけ順の(頂点,親頂点)列
vector<pair<Int,Int>> ret;
for (int i=0;i<size();++i) ret.emplace_back(rev[i],par[rev[i]]);
return ret;
}
Int lcaorg(Int u,Int v)const{ //u,vのLCA
while (head[u]!=head[v]){
if (id[u]>id[v]) swap(u,v);
v=par[head[v]];
}
return id[u]<id[v] ? u : v;
}
Int lca(Int u,Int v)const{ //u,vのLCA
if (id[u]>id[v])swap(u,v);
while (head[u]!=head[v] && id[u]<id[v]) v=par[head[v]];
return id[u]<id[v] ? u : v;
}
Int dist(Int u,Int v)const{ return dpt[u]+dpt[v]-2*dpt[lca(u,v)]; }
Int jump(Int v,Int k)const{ //vのk個上 なければ-1
while (id[v]-k<id[head[v]]){
k-=id[v]-id[head[v]]+1;
v=par[head[v]];
if (v==-1) return -1;
}
return rev[id[v]-k];
}
vector<pair<Int,Int>> heavypaths()const{ //[stID0,enID0],[stID1,enID1],…
vector<pair<Int,Int>> ret;
Int enID=to->size()-1;
while (enID!=-1){
Int stID=id[head[rev[enID]]];
ret.emplace_back(stID,enID);
enID=stID-1;
}
reverse(ret.begin(),ret.end());
return ret;
}
vector<pair<Int,Int>> uv2idranges(Int u,Int v,bool isedge=false)const
{ //パスu→vを重パス分解
Int a=lca(u,v);
//aを含む重パス上まで移動
auto func=[&](Int &t){
vector<pair<Int,Int>> t2a;
while (head[t]!=head[a]){
t2a.emplace_back(id[t],id[head[t]]);
t=par[head[t]];
}
return t2a;
};
vector<pair<Int,Int>> u2a=func(u),v2a=func(v);
//aを含む重パス上の追加
if (!isedge){//頂点
if (u!=a) u2a.emplace_back(id[u],id[a]);
else if (v!=a) v2a.emplace_back(id[v],id[a]);
else u2a.emplace_back(id[a],id[a]);
}
else{//辺
if (u!=a) u2a.emplace_back(id[u],id[a]-1);
else if (v!=a) v2a.emplace_back(id[v],id[a]-1);
}
//v2aを反転して結合
while (!v2a.empty()){
auto [st,en]=v2a.back(); v2a.pop_back();
u2a.emplace_back(en,st);
}
return u2a;
}
vector<Int> path(Int u,Int v)const{ //パスu→v 頂点列
Int a=lca(u,v);
auto func=[&](Int t){
vector<Int> t2a;
for (;t!=a;t=par[t]) t2a.push_back(t);
return t2a;
};
vector<Int> u2a=func(u),v2a=func(v);
u2a.push_back(a);
while (!v2a.empty()){
u2a.push_back(v2a.back()); v2a.pop_back();
}
return u2a;
}
pair<Int,Int> subtree2idrange(Int v)const{ //サブ木ID範囲
return {id[v],lst[v]};
}
private:
void dfsSz(Int v,Int p=-1){
par[v]=p;
for (auto&& u: (*to)[v]){
if (u==p)continue;
dpt[u]=dpt[v]+1;
dfsSz(u,v);
siz[v]+=siz[u];
}
}
Int idcnt=0;
void dfsHld(Int v,Int p=-1){
vector<E> &tov=(*to)[v];
id[v]=idcnt++;
rev[id[v]]=v;
//重パスの子を先頭へ
Int mxsz=-1;
for (auto&& u: tov){
if (u==p)continue;
if (mxsz<siz[u]) mxsz=siz[u],swap(tov[0],u);
}
//head決めるdfs
for (auto&& u: tov){
if (u==p)continue;
head[u] = (u==(*to)[v][0]) ? head[v] : u;
dfsHld(u,v);
}
lst[v]=idcnt-1;
}
Int root()const{ return rev[0]; }
};
/*
- 定義 ↓木グラフ to[v][0]が重パスになるよう変更される
HeavyLightDecomposition hld(to);
HeavyLightDecomposition hld(to,root);
- 行きがけ順番号id ⇔ 頂点v
ll v=hld.vof(id);
ll id=hld.idof(v);
- 親頂点
ll p=hld.parentof(v);
- サブ木内頂点数(v含む)
ll s=hld.subszof(v);
- 深さ(根が0)
ll d=hld.depthof(v);
- 葉?
bool b=hld.isleaf(v);
- 行きがけ順の頂点列
vpll vp=hld.preorder();
for (auto&&[v,p]:vp){
for (ll u:to[v]){
if (u==p)continue;
//
}
}
- LCA
ll a=hld.lca(u,v);
- k個上の親頂点 なければ-1
ll u=hld.jump(v,k);
- 距離
ll d=hld.dist(u,v);
- ID列上の重パス列挙 [stID0,enID0],[stID1,enID1],…
vpll hs=hld.heavypaths();
- パスu→vを重パス分解 [uID,enID0],[stID1,enID1],…,[stID*,vID]
. u→vの順のためstID>enIDもあり
vpll hs=hld.uv2idranges(u,v);
vpll hs=hld.uv2idranges(u,v,true); //辺の値を乗せる時(LCA含まない)
- パスu→vの頂点列
vll path=hld.path(u,v);
- ID列上のサブ木範囲
auto[l,r]=hld.subtree2idrange(v);
*/
auto solve(
ll n,ll q,vpll &ab,vpll &st
){
auto makeGraph=[](ll n,vector<pair<ll,ll>> &ab,bool isDirected){
vvll to(n);
for (auto [a,b]:ab){
to[a].push_back(b);
if (!isDirected) to[b].push_back(a);
}
return to;
};
vvll to=makeGraph(n,ab,false);
HeavyLightDecomposition hld(to);
Vll ans;
for (auto&&[u,v]:st){
ll dist=hld.dist(u,v);
if (dist&1){
ans.push_back(0);
continue;
}
ll du=hld.depthof(u);
ll dv=hld.depthof(v);
if (du<dv) swap(u,v),swap(du,dv);
ll c =hld.jump(u,dist/2);
ll cc=hld.jump(u,dist/2-1);
if (du==dv){
ll ccc=hld.jump(v,dist/2-1);
ll an=n-hld.subszof(cc)-hld.subszof(ccc);
ans.push_back(an);
}
else{
ll an=hld.subszof(c)-hld.subszof(cc);
ans.push_back(an);
}
}
//each(e,ans) cout << e << '\n';
return ans;
}
auto solv2(
ll n,ll q,vpll &ab,vpll &st
){
auto makeGraph=[](ll n,vector<pair<ll,ll>> &ab,bool isDirected){
vvll to(n);
for (auto [a,b]:ab){
to[a].push_back(b);
if (!isDirected) to[b].push_back(a);
}
return to;
};
vvll to=makeGraph(n,ab,false);
HeavyLightDecomposition hld(to);
Vll ans;
for (auto&&[u,v]:st){
ll nm=0;
rep(vv,0,n-1){
ll du=hld.dist(u,vv);
ll dv=hld.dist(v,vv);
nm+=(du==dv);
}
ans.push_back(nm);
}
return ans;
}
void solvecomp(
ll n,ll q,vpll &ab,vpll &st
){
auto coutans=[](auto ans){
/*
出力を書く
*/
each(e,ans) cout << e << '\n';
};
auto ans=solve(
n,q,ab,st
);
coutans(ans);
#if 0
cout << "- - - - -\n";
auto an2=solv2(
n,q,ab,st
);
coutans(an2);
cout << "================\n";
if (ans!=an2){
cout << "============ input =============\n";
/*
inputファイルの形式で吐き出す
*/
cout << pll(n,q) << '\n';
each(e,ab) cout << e+1 << '\n';
each(e,st) cout << e+1 << '\n';
cout << "============ input end =========\n\n================\n";
getchar(); rep(i,0,10000000000) i++;//getchar()の代わり
}
#endif
}
void cin2solve(){
/*
cinからの入力を書く
*/
ll n,q;
cin >> n >> q;
vector<pair<ll,ll>> ab;
rep(i,0,n-1-1){ ll a; ll b; cin>>a>>b; ab.emplace_back(a-1,b-1); }
vector<pair<ll,ll>> st;
rep(i,0,q-1){ ll s; ll t; cin>>s>>t; st.emplace_back(s-1,t-1); }
solvecomp(
n,q,ab,st
);
}
void generand(){
rndutil ru;
rep(_,0,INF){
/*
乱数による入力の生成を書く
*/
ll n=ru.val(2,10);
ll q=1;
vpll ab=ru.tree(n);
ll s=ru.val(0,n-1);
ll t=ru.val(0,n-1);
if (s==t)continue;
vpll st;
st.emplace_back(s,t);
solvecomp(
n,q,ab,st
);
}
}
//////////////////////////////////////////
int main(){
#if 1
cin2solve();
//generand();
#else
ll t; cin >> t;
rep(i,0,t-1){
cin2solve();
//generand();
}
#endif
cerr << timeget() <<"ms"<< '\n';
return 0;
}