結果
| 問題 | No.1625 三角形の質問 |
| ユーザー |
 naoya_t
|
| 提出日時 | 2021-07-29 22:54:30 |
| 言語 | C++14 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
MLE
|
| 実行時間 | - |
| コード長 | 14,410 bytes |
| コンパイル時間 | 3,126 ms |
| コンパイル使用メモリ | 220,732 KB |
| 実行使用メモリ | 814,680 KB |
| 最終ジャッジ日時 | 2024-09-14 19:18:07 |
| 合計ジャッジ時間 | 26,405 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge4 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 293 ms
79,012 KB |
| testcase_02 | AC | 2,597 ms
438,976 KB |
| testcase_03 | MLE | - |
| testcase_04 | AC | 1,991 ms
358,200 KB |
| testcase_05 | MLE | - |
| testcase_06 | MLE | - |
| testcase_07 | -- | - |
| testcase_08 | -- | - |
| testcase_09 | -- | - |
| testcase_10 | -- | - |
| testcase_11 | -- | - |
| testcase_12 | -- | - |
| testcase_13 | -- | - |
| testcase_14 | -- | - |
| testcase_15 | -- | - |
| testcase_16 | -- | - |
| testcase_17 | -- | - |
| testcase_18 | -- | - |
| testcase_19 | -- | - |
コンパイルメッセージ
main.cpp: In function 'void solve(int, int, vvi&, vvi&)':
main.cpp:385:18: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17' [-Wc++17-extensions]
385 | auto [xmin, xmax, q_area] = triangles_in_queries.front(); triangles_in_queries.pop();
| ^
ソースコード
#include <bits/stdc++.h>
using namespace std;
#define NDEBUG
#include <cassert>
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> ii;
typedef pair<ll,ll> llll;
typedef pair<double,double> dd;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;
#define pb push_back
#define eb emplace_back
#define rep(var,n) for(int var=0;var<(n);++var)
#define rep1(var,n) for(int var=1;var<=(n);++var)
#define repC2(vari,varj,n) for(int vari=0;vari<(n)-1;++vari)for(int varj=vari+1;varj<(n);++varj)
#define repC3(vari,varj,vark,n) for(int vari=0;vari<(n)-2;++vari)for(int varj=vari+1;varj<(n)-1;++varj)for(int vark=varj+1;vark<(n);++vark)
#define ALL(c) (c).begin(),(c).end()
#define RALL(c) (c).rbegin(),(c).rend()
#define whole(f, x, ...) \
([&](decltype((x)) whole) { \
return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
})(x)
#define tr(i,c) for(auto i=(c).begin(); i!=(c).end(); ++i)
#define found(s,e) ((s).find(e)!=(s).end())
#define mset(arr,val) memset(arr,val,sizeof(arr))
#define mid(x,y) ((x)+((y)-(x))/2)
#define IN(x,a,b) ((a)<=(x)&&(x)<=(b))
#define IN_(x,a,b) ((a)<=(x)&&(x)<(b))
#define tors(a) sort(ALL(a), greater<decltype(a[0])>())
#define nC2(n) ((ll)(n)*((n)-1)/2)
#define clamp(v,lo,hi) min(max(v,lo),hi)
#define ABS(x) max((x),-(x))
#define PQ(T) priority_queue<T,vector<T>,greater<T>>
#define CLEAR(a) remove_reference_t<decltype(a)>().swap(a)
template <typename T>
vector<T> vec(size_t len, T elem) { return vector<T>(len, elem); }
template<typename T1, typename T2> inline void amin(T1 & a, T2 const & b) { if (a>b) a=b; }
template<typename T1, typename T2> inline void amax(T1 & a, T2 const & b) { if (a<b) a=b; }
template <typename T>
void erase_one(multiset<T>& ms, T val) {
auto iter = ms.find(val);
if (iter != ms.end()) ms.erase(iter);
}
inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) { while(a) swap(a, b%=a); return b; }
inline ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
template <typename T>
inline T mod(T a, T b) { return ((a % b) + b) % b; }
#define is_digit(c) ('0'<=(c)&&(c)<='9')
#define is_whitespace(c) ((c)==' '||(c)=='\n'||(c)=='\r'||(c)=='\t'||(c)==EOF)
void reader(int& x){
x=0;
bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break;} }
for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
if(neg) x=-x; }
void reader(long long& x){
x=0;
bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break; } }
for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
if(neg) x=-x; }
void reader(unsigned long long& x){
x=0;
for(;;){ int k=getchar(); if (is_digit(k)){ x=(unsigned long long)(k-'0'); break; } }
for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; } }
int reader(char s[]){
int c,i=0;
for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s[i++]=c;
for(;;){ c=getchar(); if (is_whitespace(c)) break; s[i++]=c; }
s[i]='\0'; return i; }
int reader(string& s){
int c;
for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s.push_back(c);
for(;;){ c=getchar(); if (is_whitespace(c)) break; s.push_back(c); }
return s.size(); }
void reader(char& c){
for(;;){ c=getchar(); if (!is_whitespace(c)) break; } }
void writer(int x, char c=0){
int s=0; bool neg=false; char f[10]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(long long x, char c=0){
int s=0; bool neg=false; char f[20]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(unsigned long long x, char c=0){
int s=0; char f[20]; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(const string& x, char c=0){
for(int i=0;i<x.size();++i) putchar(x[i]); if(c) putchar(c); }
void writer(const char x[], char c=0){
for(int i=0;x[i]!='\0';++i) putchar(x[i]); if(c) putchar(c); }
template <class T,class S> void reader(T& x, S& y){ reader(x); reader(y); }
template <class T,class S,class U> void reader(T& x, S& y, U& z){ reader(x); reader(y); reader(z); }
template <class T,class S,class U,class V> void reader(T& x, S& y, U& z, V& w){ reader(x); reader(y); reader(z); reader(w); }
template <class T> vector<T> readerArray(int n){
vector<T> ret(n); for(int i=0;i<n;++i) reader(ret[i]); return ret; }
template <class T> vector<vector<T>> readerMatrix(int n,int m=0){
if (m==0) m = n; vector<vector<T>> ret(n); for(int i=0;i<n;++i) ret[i] = readerArray<T>(m); return ret; }
template <class T> void writerLn(T x){ writer(x,'\n'); }
template <class T,class S> void writerLn(T x, S y){ writer(x,' '); writer(y,'\n'); }
template <class T,class S,class U> void writerLn(T x, S y, U z){ writer(x,' '); writer(y,' '); writer(z,'\n'); }
template <class T,class S,class U,class V> void writerLn(T x, S y, U z, V v){ writer(x,' '); writer(y,' '); writer(z,' '); writer(v,'\n'); }
template <class T> void writerArrayLn(T x[], int n){
if(n==0){ putchar('\n'); return; }
for(int i=0;i<n-1;++i) writer(x[i],' '); writer(x[n-1],'\n'); }
template <class T> void writerArrayLn(vector<T>& x){ writerArrayLn(x.data(),(int)x.size()); }
template <class T> void writerArrayLnV(T x[], int n){ for(int i=0;i<n;++i) writerLn(x[i]); }
template <class T> void writerArrayLnV(vector<T>& x){ for(T xi: x) writerLn(xi); }
template <class T> void writerMatrix(vector<vector<T>>& x){
int n = x.size(); if (n == 0) return;
int m = x[0].size(); for (int i=0; i<n; ++i) writerArrayLn(x[i]); }
void readerEdges(size_t M,vector<int>& a,vector<int>& b,bool decrement=true){
a.resize(M); b.resize(M);
for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class W> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<W>& c,bool decrement=true){
a.resize(M); b.resize(M); c.resize(M);
for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class S,class T> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<S>& c,vector<T>& d,bool decrement=true){
a.resize(M); b.resize(M); c.resize(M); d.resize(M);
for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); reader(d[i]); if(decrement){ --a[i]; --b[i]; } } }
vector<vector<int>> make_nxt(int N, int M, vector<int>& a, vector<int>& b){
vector<vector<int>> nxt(N);
for(int i=0;i<M;++i){ nxt[a[i]].push_back(b[i]); nxt[b[i]].push_back(a[i]); }
return nxt; }
template <class T> vector<vector<pair<int,T>>> make_nxt(int N, int M, vector<int>& a, vector<int>& b, vector<T>& c){
vector<vector<pair<int,T>>> nxt(N);
for(int i=0;i<M;++i){ nxt[a[i]].emplace_back(b[i],c[i]); nxt[b[i]].emplace_back(a[i],c[i]); }
return nxt; }
template <typename T>
struct SparseSegmentTree {
int depth, N;
static const T ident = numeric_limits<T>::min();
static inline T merge(T a, T b) { return max(a, b); }
struct node {
int depth;
T val;
node *left, *right;
node(int depth) : depth(depth), val(ident), left(nullptr), right(nullptr) {}
~node() {
if (left) delete(left);
if (right) delete(right);
}
void dump() {
if (left) left->dump();
if (right) right->dump();
}
T update(int ix, T newval) {
if (depth == 0) {
assert(ix == 0);
return this->val = newval;
} else {
T leftval = ident, rightval = ident;
int mask = 1 << (depth - 1);
if (ix & mask) {
if (!right) right = new node(depth - 1);
rightval = right->update(ix & ~mask, newval);
leftval = left ? left->val : ident;
} else {
if (!left) left = new node(depth - 1);
leftval = left->update(ix & ~mask, newval);
rightval = right ? right->val : ident;
}
return this->val = merge(leftval, rightval);
}
}
T get(int ix) {
if (depth == 0) {
return this->val;
} else {
int mask = 1 << (depth - 1);
if (ix & mask) {
return right ? right->get(ix & ~mask) : ident;
} else {
return left ? left->get(ix & ~mask) : ident;
}
}
}
T query(int a, int b, int l, int r) {
if (r <= a || b <= l) return ident;
if (a <= l && r <= b) {
return val;
} else {
T leftval = left ? left->query(a, b, l, (l + r) / 2) : ident;
T rightval = right ? right->query(a, b, (l + r) / 2, r) : ident;
return merge(leftval, rightval);
}
}
} *root;
SparseSegmentTree() : depth(0), N(0) {}
SparseSegmentTree(int size) { init(size); }
void init(int size) {
if (size) {
N = 1; depth = 0;
while (N < size) { ++depth; N *= 2; }
} else {
N = 0; depth = 0;
}
this->root = new node(depth);
}
void dump() { root->dump(); }
void update(int ix, T val) {
root->update(ix, val);
}
T query(int lo, int hi) {
return root->query(lo, hi, 0, N);
}
};
template <typename T>
void sort_uniq_max(vector<pair<int,T>>& ar) {
if (ar.empty()) return;
sort(ALL(ar));
int L = ar.size(), i = 0;
for (int j=1; j<ar.size(); ++j){
if (ar[i].first == ar[j].first) {
amax(ar[i].second, ar[j].second);
} else {
++i;
if (i < j) ar[i] = ar[j];
}
}
ar.resize(i+1);
}
template <typename T>
struct SparseSegmentTree2D {
int xsize, ysize, H, W;
vector<SparseSegmentTree<T>*> segs;
static const T ident = numeric_limits<T>::min();
static inline T merge(T a, T b) { return max(a, b); }
SparseSegmentTree2D(int xsize, int ysize) : xsize(xsize), ysize(ysize) {
W = 1; while (W < xsize) W *= 2;
segs.assign(2 * W - 1, nullptr);
}
~SparseSegmentTree2D() {
rep(i, 2*W-1) {
if (segs[i]) delete(segs[i]);
}
}
void update(int x, int y, T newval){
int k = x + (W-1);
while (k >= 0) {
if (!segs[k]) segs[k] = new SparseSegmentTree<T>(ysize);
segs[k]->update(y, newval);
if (k == 0) break;
k = (k - 1)/2;
}
}
T query(int xlo, int xhi, int ylo, int yhi, int k, int l, int r){
if (r <= xlo || xhi <= l) return ident;
if (xlo <= l && r <= xhi) {
return segs[k] ? segs[k]->query(ylo, yhi) : ident;
} else {
return merge(
query(xlo,xhi, ylo,yhi, 2*k+1, l, (l+r)/2),
query(xlo,xhi, ylo,yhi, 2*k+2, (l+r)/2, r)
);
}
}
T query(int xlo, int xhi, int ylo, int yhi){
return query(xlo, xhi, ylo, yhi, 0, 0, W);
}
};
inline ll calc_area(vi& triangle) {
ll x1 = triangle[2] - triangle[0];
ll y1 = triangle[3] - triangle[1];
ll x2 = triangle[4] - triangle[0];
ll y2 = triangle[5] - triangle[1];
return ABS(x1 * y2 - x2 * y1);
}
void solve(int N, int Q, vvi& triangles, vvi& queries) {
set<int> xs;
set<ll> ys;
vll area(N, 0);
using P = tuple<int, int, ll>;
queue<P> triangles_in_queries;
rep(i, N) {
for (int j = 0; j < 6; j += 2) {
xs.insert(triangles[i][j]);
}
area[i] = calc_area(triangles[i]);
ys.insert(area[i]);
}
rep(i, Q) {
int L = queries[i].size();
if (L == 6) {
int xmin = INT_MAX, xmax = INT_MIN;
for (int j = 0; j < 6; j += 2) {
int x = queries[i][j];
xs.insert(x);
amin(xmin, x);
amax(xmax, x);
}
ll q_area = calc_area(queries[i]);
triangles_in_queries.emplace(xmin, xmax, q_area);
ys.insert(q_area);
CLEAR(queries[i]);
} else {
xs.insert(queries[i][0]);
xs.insert(queries[i][1]);
}
}
xs.insert(INT_MIN);
xs.insert(INT_MAX);
ys.insert(LLONG_MIN);
ys.insert(LLONG_MAX);
map<int, int> zx;
int zxid = 0;
for (int x : xs) zx[x] = zxid++;
CLEAR(xs);
map<ll, int> zy;
int zyid = 0;
vll zyR; zyR.reserve(ys.size());
for (ll y : ys) {
zy[y] = zyid++;
zyR.pb(y);
}
CLEAR(ys);
SparseSegmentTree2D<int> seg(zxid, zxid);
rep(i, N) {
int xmin = INT_MAX, xmax = INT_MIN;
for (int j = 0; j < 6; j += 2) {
int x = zx[triangles[i][j]];
amin(xmin, x);
amax(xmax, x);
}
seg.update(xmin, xmax, zy[area[i]]);
}
CLEAR(triangles);
CLEAR(area);
rep(i, Q) {
int L = queries[i].size();
int xmin = INT_MAX, xmax = INT_MIN;
if (L == 0) {
auto [xmin, xmax, q_area] = triangles_in_queries.front(); triangles_in_queries.pop();
seg.update(zx[xmin], zx[xmax], zy[q_area]);
} else {
int l = zx[queries[i][0]], r = zx[queries[i][1]];
int res = seg.query(l, r, l, r+1);
ll resR = (res >= 0) ? zyR[res] : LLONG_MIN;
if (resR < 0) resR = -1;
printf("%lld\n", resR);
}
}
}
int main() {
int N, Q;
reader(N, Q);
vvi triangles(N, vi(6));
rep(i, N) { triangles[i] = readerArray<int>(6); }
vvi queries(Q);
rep(i, Q) {
int op;
reader(op);
if (op == 1) {
queries[i] = readerArray<int>(6);
} else {
queries[i] = readerArray<int>(2);
}
}
solve(N, Q, triangles, queries);
return 0;
}