oj.uz

Submission #27310

# Submission time Handle Problem Language Result Execution time Memory
27310 2017-07-12T07:56:36 Z 김현수(#1143) Dragon 2 (JOI17_dragon2) C++14
60 / 100
 4000 ms 245524 KB 
#include<bits/stdc++.h>
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;

ll n, m, q, s1, s2, ans[100005];
pll p1, p2, qry[100005], piv;

map<pll, ll> mem;
vector<ll> z1, z2;
vector<pll> drg[30005], cp, pt;

struct data {pii s[2], e[2]; int i;};
vector<data> rd[30005];

struct sweep {ll s, e, x, i;};
vector<sweep> swp[1111111];

struct segtree {
	ll v[2222222], lim;
	void init () {
		for(lim=1;lim<=2*s2;lim<<=1);
		for(ll i=2*lim;--i;) v[i] = 0;
	}
	void upd (ll P, ll V) {
		P += lim;
		while(P) {v[P] += V; P >>= 1;}
	}
	ll get (ll S, ll E) {
		S += lim; E += lim;
		ll ret = 0;
		while(S <= E) {
			if(S%2==1) ret += v[S++];
			if(E%2==0) ret += v[E--];
			S >>= 1; E >>= 1;
		}
		return ret;
	}
} seg;

ll ccw (const pll &A, const pll &B, const pll &C) {
	return (A.X*B.Y+B.X*C.Y+C.X*A.Y) - (A.Y*B.X+B.Y*C.X+C.Y*A.X);
}

bool isup (const pll &A, const pll &B) {
	return (A.Y < B.Y || (A.Y == B.Y && A.X < B.X));
}

bool cmp (const pll &A, const pll &B) {
	bool F1 = isup(piv, A), F2 = isup(piv, B);
	if(F1 != F2) return F1;
	return ccw(piv, A, B) > 0;
}

void cpr (pll &P, vector<pll> &D, vector<data> &R, int O, vector<ll> &V, ll &S) {
	cp.clear(); V.clear(); piv = P;
	for(auto &T : D) cp.push_back(T);
	for(auto &T : R) {
		cp.push_back(pll(T.s[O].X+P.X, T.s[O].Y+P.Y));
		cp.push_back(pll(T.e[O].X+P.X, T.e[O].Y+P.Y));
	}
	sort(cp.begin(), cp.end(), cmp);
	cp.erase(unique(cp.begin(), cp.end()), cp.end());
	S = cp.size();
	for(auto &T : D) {
		V.push_back(lower_bound(cp.begin(), cp.end(), T, cmp) - cp.begin() + 1);
	}
	for(auto &T : R) {
		T.s[O].X = lower_bound(cp.begin(), cp.end(), pll(T.s[O].X+P.X, T.s[O].Y+P.Y), cmp) - cp.begin() + 1;
		T.e[O].X = lower_bound(cp.begin(), cp.end(), pll(T.e[O].X+P.X, T.e[O].Y+P.Y), cmp) - cp.begin() + 1;
	}
}

void add (ll XS, ll XE, ll YS, ll YE, ll I) {
	swp[XE].push_back({YS, YE+(YS>YE)*s2, 1, I});
	swp[XS-1].push_back({YS, YE+(YS>YE)*s2, -1, I});
	if(XS > XE) swp[s1].push_back({YS, YE+(YS>YE)*s2, 1, I});
}

pll Flip (const pll &A, const pll &B) {
	return pll(2*A.X - B.X, 2*A.Y - B.Y);
}

data conv (pll S[], pll E[], ll I) {
	data C; C.i = I;
	C.s[0] = pii(S[0].X-p1.X, S[0].Y-p1.Y);
	C.e[0] = pii(E[0].X-p1.X, E[0].Y-p1.Y);
	C.s[1] = pii(S[1].X-p2.X, S[1].Y-p2.Y);
	C.e[1] = pii(E[1].X-p2.X, E[1].Y-p2.Y);
	return C;
}

void sadi (ll S, ll M, ll I) {
	for(auto &T : drg[S]) {
		pll L[2], R[2];
		L[0] = T; R[0] = Flip(p1, T);
		if(ccw(p1, L[0], p2) < 0) swap(L[0], R[0]);
		L[1] = T; R[1] = Flip(p2, T);
		if(ccw(p2, L[1], p1) < 0) swap(L[1], R[1]);
		rd[M].push_back(conv(L, R, I));
	}
}

void majo (ll S, ll M, ll I) {
	for(auto &T : drg[M]) {
		pll L[2], R[2];
		L[0] = p2; R[0] = Flip(p1, T);
		if(ccw(p1, L[0], R[0]) < 0) swap(L[0], R[0]);
		L[1] = p1; R[1] = Flip(p2, T);
		if(ccw(p2, L[1], R[1]) < 0) swap(L[1], R[1]);
		rd[S].push_back(conv(L, R, I));
	}
	for(auto &T : drg[M]) {
		pll L[2], R[2];
		L[0] = T; R[0] = Flip(p1, T);
		if(ccw(p1, L[0], p2) > 0) swap(L[0], R[0]);
		L[1] = T; R[1] = Flip(p2, T);
		if(ccw(p2, L[1], p1) > 0) swap(L[1], R[1]);
		rd[S].push_back(conv(L, R, I));
	}
}

int main()
{
	scanf("%lld%lld",&n,&m);
	for(ll i=1;i<=n;i++) {
		ll A, B, C;
		scanf("%lld%lld%lld",&A,&B,&C);
		drg[C].push_back(pll(A, B));
	}
	scanf("%lld%lld%lld%lld%lld",&p1.X,&p1.Y,&p2.X,&p2.Y,&q);
	for(ll i=1;i<=q;i++) {
		ll A, B;
		scanf("%lld%lld",&A,&B);
		qry[i] = pll(A, B);
		if(!mem[qry[i]]) {
			mem[qry[i]] = 1;
			if(drg[A].size() > 2*drg[B].size()) majo(A, B, i);
			else sadi(A, B, i);
		}
	}
	for(ll i=1;i<=m;i++) {
		cpr(p1, drg[i], rd[i], 0, z1, s1);
		cpr(p2, drg[i], rd[i], 1, z2, s2);
		for(auto &T : rd[i]) {
			add(T.s[0].X, T.e[0].X, T.s[1].X, T.e[1].X, T.i);
		}
		seg.init(); pt.clear();
		for(ll j=0;j<drg[i].size();j++) {
			pt.push_back(pll(z1[j], z2[j]));
		}
		sort(pt.begin(), pt.end());
		for(ll j=1,k=0;j<=s1;j++) {
			while(k < pt.size() && pt[k].X <= j) {
				seg.upd(pt[k].Y, 1);
				seg.upd(pt[k].Y+s2, 1);
				k++;
			}
			for(auto &T : swp[j]) {
				ans[T.i] += seg.get(T.s, T.e) * T.x;
			}
			swp[j].clear();
		}
	}
	for(ll i=1;i<=q;i++) {
		mem[qry[i]] += ans[i];
		printf("%lld\n", mem[qry[i]]-1);
	}
}

Compilation message

dragon2.cpp: In function 'int main()':
dragon2.cpp:152:15: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
   for(ll j=0;j<drg[i].size();j++) {
               ^
dragon2.cpp:157:12: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    while(k < pt.size() && pt[k].X <= j) {
            ^
dragon2.cpp:128:25: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%lld%lld",&n,&m);
                         ^
dragon2.cpp:131:33: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
   scanf("%lld%lld%lld",&A,&B,&C);
                                 ^
dragon2.cpp:134:58: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%lld%lld%lld%lld%lld",&p1.X,&p1.Y,&p2.X,&p2.Y,&q);
                                                          ^
dragon2.cpp:137:26: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
   scanf("%lld%lld",&A,&B);
                          ^

Subtask #1
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 16 ms 49744 KB Output is correct
2 Correct 36 ms 50532 KB Output is correct
3 Correct 256 ms 60412 KB Output is correct
4 Correct 636 ms 73644 KB Output is correct
5 Correct 329 ms 58956 KB Output is correct
6 Correct 16 ms 49588 KB Output is correct
7 Correct 6 ms 49452 KB Output is correct
8 Correct 13 ms 49788 KB Output is correct
9 Correct 9 ms 49788 KB Output is correct
10 Correct 9 ms 49788 KB Output is correct

Subtask #2
45.0 / 45.0

# Verdict Execution time Memory Grader output
1 Correct 96 ms 53828 KB Output is correct
2 Correct 473 ms 64156 KB Output is correct
3 Correct 99 ms 52616 KB Output is correct
4 Correct 36 ms 50112 KB Output is correct
5 Correct 29 ms 49980 KB Output is correct
6 Correct 106 ms 53704 KB Output is correct
7 Correct 99 ms 53208 KB Output is correct
8 Correct 83 ms 53704 KB Output is correct
9 Correct 69 ms 53704 KB Output is correct
10 Correct 76 ms 53704 KB Output is correct

Subtask #3
0 / 40.0

# Verdict Execution time Memory Grader output
1 Correct 16 ms 49744 KB Output is correct
2 Correct 36 ms 50532 KB Output is correct
3 Correct 256 ms 60412 KB Output is correct
4 Correct 636 ms 73644 KB Output is correct
5 Correct 329 ms 58956 KB Output is correct
6 Correct 16 ms 49588 KB Output is correct
7 Correct 6 ms 49452 KB Output is correct
8 Correct 13 ms 49788 KB Output is correct
9 Correct 9 ms 49788 KB Output is correct
10 Correct 9 ms 49788 KB Output is correct
11 Correct 96 ms 53828 KB Output is correct
12 Correct 473 ms 64156 KB Output is correct
13 Correct 99 ms 52616 KB Output is correct
14 Correct 36 ms 50112 KB Output is correct
15 Correct 29 ms 49980 KB Output is correct
16 Correct 106 ms 53704 KB Output is correct
17 Correct 99 ms 53208 KB Output is correct
18 Correct 83 ms 53704 KB Output is correct
19 Correct 69 ms 53704 KB Output is correct
20 Correct 76 ms 53704 KB Output is correct
21 Correct 113 ms 53836 KB Output is correct
22 Correct 449 ms 64068 KB Output is correct
23 Correct 3686 ms 151236 KB Output is correct
24 Execution timed out 4000 ms 245524 KB Execution timed out
25 Halted 0 ms 0 KB -