Contest Duration: - (local time) (100 minutes) Back to Home

Submission #6708788

Source Code Expand

Copy
```#include <bits/stdc++.h>
using namespace std;
typedef long long   signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for(LL i = (l)    ; i <  (r); ++i)
#define incII(i, l, r) for(LL i = (l)    ; i <= (r); ++i)
#define decID(i, l, r) for(LL i = (r) - 1; i >= (l); --i)
#define decII(i, l, r) for(LL i = (r)    ; i >= (l); --i)
#define inc(i, n)  incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n)  decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inID(v, l, r) ((l) <= (v) && (v) <  (r))
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define  ALL(v)  v.begin(),  v.end()
#define RALL(v) v.rbegin(), v.rend()
template<typename T> bool setmin  (T & a, T b) { if(b <  a) { a = b; return true; } else { return false; } }
template<typename T> bool setmax  (T & a, T b) { if(b >  a) { a = b; return true; } else { return false; } }
template<typename T> bool setmineq(T & a, T b) { if(b <= a) { a = b; return true; } else { return false; } }
template<typename T> bool setmaxeq(T & a, T b) { if(b >= a) { a = b; return true; } else { return false; } }
LL mo(LL a, LL b) { assert(b > 0); a %= b; if(a < 0) { a += b; } return a; }
LL fl(LL a, LL b) { assert(b > 0); return (a > 0 ? a / b : (a - b + 1) / b); }
LL ce(LL a, LL b) { assert(b > 0); return (a < 0 ? a / b : (a + b - 1) / b); }
template<typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template<typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#define bit(b, i) (((b) >> (i)) & 1)
#define BC __builtin_popcountll
#define SC static_cast
#define SI(v) SC<int>(v.size())
#define SL(v) SC<LL >(v.size())
#define RF(e, v) for(auto & e: v)
#define ef else if
#define UR assert(false)

// ---- ----

template<typename T> class SegmentTree {
private:
T * a = NULL;
int N = -1, S;
function<T(T, T)> F;
T I;
bool is_available = false;
public:
SegmentTree() { }
SegmentTree(int n, function<T(T, T)> func, T id) { init(n, func, id); }
void init(int size, function<T(T, T)> func, T id) {
assert(size > 0);
N = size;
F = func;
I = id;
S = 1;
while(S < size) { S *= 2; }
delete[] a;
a = new T[S * 2];
inc(i, S * 2) { a[i] = I; }
is_available = true;
}
const T & operator[](int p) {
assert(inID(p, 0, N));
p += S;
return a[p];
}
T & ref(int p) {
is_available = false;
assert(inID(p, 0, N));
p += S;
return a[p];
}
void calc() {
decID(i, 1, S) { a[i] = F(a[i * 2], a[i * 2 + 1]); }
is_available = true;
}
void apply(int p, function<void(T &)> op) {
assert(inID(p, 0, N));
p += S;
op(a[p]);
while(p != 1) {
p /= 2;
a[p] = F(a[p * 2], a[p * 2 + 1]);
}
}
T fold_ID(int l, int r, bool loop = false) {
assert(is_available);
assert(inII(l, 0, N));
assert(inII(r, 0, N));
if(loop && l >= r) { return F(fold_ID(l, N), fold_ID(0, r)); }
assert(l <= r);
l += S;
r += S;
T v = I, w = I;
while(l < r) {
if(l + 1 == r) { v = F(v, a[l]); break; }
if(l % 2 == 1) { v = F(v, a[l]); }
if(r % 2 == 1) { w = F(a[r - 1], w); }
l = (l + 1) / 2;
r = r / 2;
}
return F(v, w);
}
T fold_II(int l, int r, bool loop = false) { return fold_ID(l    , r + 1, loop); }
T fold_CD(int l, int r, bool loop = false) { return fold_ID(l + 1, r    , loop); }
T fold_CI(int l, int r, bool loop = false) { return fold_ID(l + 1, r + 1, loop); }
};

#define OP(op) [&](auto A, auto B) { return op; }
#define AP(op) [&](auto & A) { op; }

// ---- ----

template<LL M> class ModInt {
private:
LL v = 0;
public:
ModInt() { }
ModInt(LL vv) { setval(vv); }
ModInt & setval(LL vv) { v = vv % M; if(v < 0) { v += M; } return (*this); }
LL getval() const { return v; }
ModInt & operator+=(const ModInt & b)       { return setval(v + b.v); }
ModInt & operator-=(const ModInt & b)       { return setval(v - b.v); }
ModInt & operator*=(const ModInt & b)       { return setval(v * b.v); }
ModInt & operator/=(const ModInt & b)       { return setval(v * b.inv()); }
ModInt & operator^=(            LU b)       { return setval(ex(v, b)); }
ModInt   operator+ (                ) const { return ModInt(+v); }
ModInt   operator- (                ) const { return ModInt(-v); }
ModInt   operator+ (const ModInt & b) const { return ModInt(v + b.v); }
ModInt   operator- (const ModInt & b) const { return ModInt(v - b.v); }
ModInt   operator* (const ModInt & b) const { return ModInt(v * b.v); }
ModInt   operator/ (const ModInt & b) const { return ModInt(v * b.inv()); }
ModInt   operator^ (            LU b) const { return ModInt(ex(v, b)); }
LL inv() const {
LL x = (ex_gcd(v, M).FI + M) % M;
assert(v * x % M == 1);
return x;
}
LL ex(LL a, LU b) const {
LL D = 64, x[64], y = 1;
inc(i, D) { if((b >> i) == 0) { D = i; break; } }
inc(i, D) { x[i] = (i == 0 ? a : x[i - 1] * x[i - 1]) % M; }
inc(i, D) { if((b >> i) & 1) { (y *= x[i]) %= M; } }
return y;
}
pair<LL, LL> ex_gcd(LL a, LL b) const {
if(b == 0) { return MP(1, 0); }
auto p = ex_gcd(b, a % b);
return MP(p.SE, p.FI - (a / b) * p.SE);
}
};
template<LL M> ModInt<M> operator+(LL a, const ModInt<M> & b) { return  b + a; }
template<LL M> ModInt<M> operator-(LL a, const ModInt<M> & b) { return -b + a; }
template<LL M> ModInt<M> operator*(LL a, const ModInt<M> & b) { return  b * a; }
template<LL M> ModInt<M> operator/(LL a, const ModInt<M> & b) { return  a * b.inv(); }
template<LL M> istream & operator>>(istream & is, ModInt<M> & b) { LL v; is >> v; b.setval(v); return is; }
template<LL M> ostream & operator<<(ostream & os, const ModInt<M> & b) { return (os << b.getval()); }

// ---- ----

typedef ModInt<998244353> MI;

int n;
vector<pair<int, int>> v;

int main() {
cin >> n;
inc(i, n) {
int x, y;
cin >> x >> y;
v.EB(x, y);
}
sort(ALL(v));

{
vector<pair<int, int>> w;
inc(i, n) { w.EB(v[i].SE, i); }
sort(ALL(w));
inc(i, n) {
v[i].FI = i;
v[w[i].SE].SE = i;
}
}

SegmentTree<int> stL(n, OP(A + B), 0);
SegmentTree<int> stR(n, OP(A + B), 0);

inc(i, n) { stR.ref(i) = 1; }
stR.calc();

MI ans = n * (MI(2) ^ n);
inc(i, n) {
stL.apply(v[i].SE, AP(A++));
stR.apply(v[i].SE, AP(A--));

int a = stL.fold_ID(0, v[i].SE);
int b = stR.fold_ID(0, v[i].SE);
int c = stR.fold_CD(v[i].SE, n);
int d = stL.fold_CD(v[i].SE, n);

MI A = (MI(2) ^ a) - 1;
MI B = (MI(2) ^ b) - 1;
MI C = (MI(2) ^ c) - 1;
MI D = (MI(2) ^ d) - 1;

ans -= 1 + A + B + C + D + A*B + B*C + C*D + D*A;
}

cout << ans << endl;

return 0;
}
```

#### Submission Info

Submission Time 2019-08-04 22:26:00+0900 F - Enclosed Points FF256grhy C++14 (GCC 5.4.1) 600 6764 Byte AC 457 ms 5892 KB

#### Judge Result

Set Name Sample All
Score / Max Score 0 / 0 600 / 600
Status
 AC × 3
 AC × 26
Set Name Test Cases
Sample s1.txt, s2.txt, s3.txt
All 01.txt, 02.txt, 03.txt, 04.txt, 05.txt, 06.txt, 07.txt, 08.txt, 09.txt, 10.txt, 11.txt, 12.txt, 13.txt, 14.txt, 15.txt, 16.txt, 17.txt, 18.txt, 19.txt, 20.txt, 21.txt, 22.txt, 23.txt, s1.txt, s2.txt, s3.txt
Case Name Status Exec Time Memory
01.txt AC 1 ms 256 KB
02.txt AC 1 ms 256 KB
03.txt AC 1 ms 256 KB
04.txt AC 1 ms 256 KB
05.txt AC 1 ms 256 KB
06.txt AC 1 ms 256 KB
07.txt AC 1 ms 256 KB
08.txt AC 1 ms 256 KB
09.txt AC 1 ms 256 KB
10.txt AC 1 ms 256 KB
11.txt AC 449 ms 5864 KB
12.txt AC 440 ms 5892 KB
13.txt AC 456 ms 5848 KB
14.txt AC 437 ms 5792 KB
15.txt AC 455 ms 5844 KB
16.txt AC 457 ms 5844 KB
17.txt AC 455 ms 5844 KB
18.txt AC 456 ms 5844 KB
19.txt AC 358 ms 5852 KB
20.txt AC 357 ms 5876 KB
21.txt AC 387 ms 5844 KB
22.txt AC 387 ms 5844 KB
23.txt AC 1 ms 256 KB
s1.txt AC 1 ms 256 KB
s2.txt AC 1 ms 256 KB
s3.txt AC 1 ms 256 KB