#include<bits/stdc++.h>
#include<chrono>
using namespace std;
using namespace chrono;
#define all(a) a.begin(), a.end()
#define sz(x) (int(x.size()))
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef vector<string> vs;
template<class T1, class T2>
istream &operator>>(istream &in, pair<T1, T2> &P){
in >> P.first >> P.second;
return in;
}
template<class T1, class T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &P){
out << "(" << P.first << ", " << P.second << ")";
return out;
}
template<class T>
istream &operator>>(istream &in, vector<T> &arr){
for(auto &x: arr) in >> x;
return in;
}
template<class T>
ostream &operator<<(ostream &out, const vector<T> &arr){
for(auto &x: arr) out << x << ' '; cout << "\n";
return out;
}
template<class T>
istream &operator>>(istream &in, deque<T> &arr){
for(auto &x: arr) in >> x;
return in;
}
template<class T>
ostream &operator<<(ostream &out, const deque<T> &arr){
for(auto &x: arr) out << x << ' '; cout << "\n";
return out;
}
struct point{
ll x, y;
int ind;
point(pll p): x(p.first), y(p.second){}
point(ll x = 0, ll y = 0): x(x), y(y){}
bool operator<(const point &other) const{
return x < other.x || (x == other.x && y < other.y);
}
point operator+(const point &other) const{
return point(x + other.x, y + other.y);
}
point operator+=(const point &other){
return *this = *this + other;
}
point operator-(const point &other) const{
return point(x - other.x, y - other.y);
}
point operator-=(const point &other){
return *this = *this - other;
}
ll operator*(const point &other) const{
return x * other.x + y * other.y;
}
};
ostream &operator<<(ostream &out, point p){
cout << "(" << p.x << ", " << p.y << ")";
return out;
}
ll ori(const point &p, const point &q, const point &r){
return p.x * q.y + q.x * r.y + r.x * p.y - p.y * q.x - q.y * r.x - r.y * p.x;
}
struct convhull{
int N, L, U;
vector<point> ch;
convhull(vector<point> arr = vector<point>(), bool sorted = false){
if(arr.size() <= 1){
ch = arr;
N = L = U = arr.size();
return;
}
if(!sorted) sort(arr.begin(), arr.end());
vector<point> upper, lower;
point p = arr.front(), q = arr.back();
upper.push_back(p), lower.push_back(p);
for(int i = 1; i < arr.size(); i ++){
if(i == arr.size() - 1 || ori(p, arr[i], q) < 0){
while(upper.size() >= 2 && ori(upper[upper.size() - 2], upper[upper.size() - 1], arr[i]) >= 0){
upper.pop_back();
}
upper.push_back(arr[i]);
}
if(i == arr.size() - 1 || ori(p, arr[i], q) > 0){
while(lower.size() >= 2 && ori(lower[lower.size() - 2], lower[lower.size() - 1], arr[i]) <= 0){
lower.pop_back();
}
lower.push_back(arr[i]);
}
}
U = upper.size(), L = lower.size();
for(int i = 0; i < L; i ++) ch.push_back(lower[i]);
for(int i = U - 2; i; i --) ch.push_back(upper[i]);
N = ch.size();
}
vector<point> linearize() const{
if(N <= 1) return ch;
int i = 0, j = N - 1;
vector<point> res;
while(i != L - 1 && j != L - 1){
if(ch[i] < ch[j]) res.push_back(ch[i ++]);
else res.push_back(ch[j --]);
}
while(i < L) res.push_back(ch[i ++]);
while(j >= L) res.push_back(ch[j --]);
res.push_back(ch[L - 1]);
return res;
}
int max_element(ll x, ll y){
point p(x, y);
int l = L - 1, r = N;
while(r - l > 3){
int m1 = (2 * l + r) / 3, m2 = (l + 2 * r) / 3;
p * ch[m1] <= p * ch[m2] ? l = m1 : r = m2;
}
int res = l;
for(int i = l + 1; i < r; i ++) if(p * ch[res] < p * ch[i]) res = i;
return res;
}
int min_element(ll x, ll y){
point p(x, y);
int l = 0, r = L;
while(r - l > 3){
int m1 = (2 * l + r) / 3, m2 = (l + 2 * r) / 3;
p * ch[m1] >= p * ch[m2] ? l = m1 : r = m2;
}
int res = l;
for(int i = l + 1; i < r; i ++) if(p * ch[res] > p * ch[i]) res = i;
return res;
}
convhull operator+(const convhull &other) const{
if(!this->N || !other.N) return convhull();
convhull temp1(*this), temp2(other), temp;
for(int i = 0; i + 1 < temp1.N; i ++) temp1.ch[i] = this->ch[i + 1] - this->ch[i];
for(int i = 0; i + 1 < temp2.N; i ++) temp2.ch[i] = other.ch[i + 1] - other.ch[i];
temp1.ch.back() = this->ch.front() - this->ch.back();
temp2.ch.back() = other.ch.front() - other.ch.back();
int i = 0, j = 0;
while(i < temp1.N && j < temp2.N){
if(ori(temp1.ch[i], temp2.ch[j], point(0, 0)) >= 0) temp.ch.push_back(temp1.ch[i ++]);
else temp.ch.push_back(temp2.ch[j ++]);
}
for(; i < temp1.N; i ++) temp.ch.push_back(temp1.ch[i]);
for(; j < temp2.N; j ++) temp.ch.push_back(temp2.ch[j]);
convhull res;
res.ch.push_back(this->ch[0] + other.ch[0]);
for(int i = 0; i + 1 < temp.ch.size(); i ++){
res.ch.push_back(res.ch.back() + temp.ch[i]);
}
res.N = res.ch.size();
if(res.N == 1){
res.L = res.U = 1;
}
else{
res.L = std::max_element(all(res.ch)) - res.ch.begin() + 1;
res.U = res.N - res.L + 2;
}
return res;
}
convhull operator^(const convhull &other) const{
if(!this->N) return other;
if(!other.N) return *this;
auto temp1 = this->linearize(), temp2 = other.linearize();
vector<point> res(temp1.size() + temp2.size());
merge(all(temp1), all(temp2), res.begin());
return convhull(res, true);
}
};
convhull c;
typedef pair<convhull, convhull> pcc;
void Init(vi a, vi d, vi p){
int n = a.size();
vector<vector<point>> data(2, vector<point>(n));
for(int i = 0; i < n; i ++) data[0][i] = point(a[i], p[i]), data[1][i] = point(d[i], p[i]);
sort(all(data[0])), sort(all(data[1]));
function<pcc(int, int)> solve = [&](int l, int r){
if(r - l == 1){
return pcc(convhull({data[0][l]}), convhull({data[1][l]}));
}
int m = l + r >> 1;
auto p = solve(l, m), q = solve(m, r);
auto res = p.first + q.second;
for(auto &x: res.ch) c.ch.push_back(x);
res = p.second + q.first;
for(auto &x: res.ch) c.ch.push_back(x);
return pcc(p.first^q.first, p.second^q.second);
};
solve(0, n);
c = convhull(c.ch);
}
ll BestSquad(int x, int y){
int p = c.max_element(x, y);
return point(x, y) * c.ch[p];
}
/*
6
2 1 1
2 1 2
2 1 3
2 1 4
2 1 5
2 1 6
100
4
3 1 4
2 3 3
2 1 6
4 4 1
2
1 3
3 1
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// _____________ //
// ++++++++++ ___------------------\\\\ //
// +++`+``+`+`++++ ///`````````````````````````````\\\ //
// ++`+`+``+++`++++ /////```````````````````````````````````\\ //
// +++`++`+`+``+++/////`````````````````````````````````````````\\ //
// +++`++`+``+///```````````|```````````````````````````````````\\ //
// ____++++/++++/`````````````/````````|````````|```````````````````\\ //
// / / / | //``````````````|````````|```````|````````|````````````\\ //
// / / / | ///````````/```````|```````||```````|````````|``````\```````\\ //
// | / / |///`````````|``````/````````|````````|````````|```````|```````\\ //
// |/ | |//``|```````|``````|````````|`````````|```````|```````|````````\\ //
// /\___|__//`|``|```````|` | ``:|````````|:```````|```````|```|`````| //
// / / /``|``|``````|/ | :| ```:|```````|```````|``++````++ //
// / / //```|``|``````| | |: :| ```|```````|```++``++`\ //
// | / /````|``|``````/ _.::::. | | | ````|```|`++`\`| //
// | / |````|``|`````| ` | ``|```++``++`| //
// | / |````|``|`````| : |``++````++| //
// | / /````|``|`````| _.-:::. |..`|``.`|.| //
// |/ /`````|``|`````| ` |```|````|`| //
// /| |`````|``|`````| :' .|```|````|.| //
// / | |`````|``|`````| /|-|``|````|`| //
// / | |`````|```\````| / ||```|````|``\ //
// / | |`````|````|```|:: /_| ||```|````|``| //
// |`````|````|```|:|:. `.._ .\___/:|```|````|``| //
// |`````\````|```|:|::- ``:::.... -:|:|:::|```|````|``| //
// |``````|```|```|:|::`|. .:::|:|:::|```|````|``| //
// \`````|```|```|:|::/|--. .`:|:::|:|:::/```|````|``| //
// |````|```|```\:|:|:|----- _..-:|:|:|:::|:|::|````|````|`/ //
// |````|```|````\|:|:|-------.____.....------|/::|:::|:|::|````|````|`| //
// |````|```|\````\:|/\___________ ________/\--\:::|:|::|````/````|`| //
// |````\```| \```|:/-------------\ /----------\``\::|:|::|```/`````|`| //
// |`````|``| \``|/---------------\/------------\_________|```|`````|`| //
// //
//////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// Created by Aeren //
// //
//////////////////////////////////////////////////////////////////////////////////////////////////////
Compilation message
squad.cpp: In function 'std::ostream& operator<<(std::ostream&, const std::vector<_Tp>&)':
squad.cpp:32:2: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
for(auto &x: arr) out << x << ' '; cout << "\n";
^~~
squad.cpp:32:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
for(auto &x: arr) out << x << ' '; cout << "\n";
^~~~
squad.cpp: In function 'std::ostream& operator<<(std::ostream&, const std::deque<_Tp>&)':
squad.cpp:42:2: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
for(auto &x: arr) out << x << ' '; cout << "\n";
^~~
squad.cpp:42:37: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
for(auto &x: arr) out << x << ' '; cout << "\n";
^~~~
squad.cpp: In constructor 'convhull::convhull(std::vector<point>, bool)':
squad.cpp:90:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
for(int i = 1; i < arr.size(); i ++){
~~^~~~~~~~~~~~
squad.cpp:91:9: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
if(i == arr.size() - 1 || ori(p, arr[i], q) < 0){
~~^~~~~~~~~~~~~~~~~
squad.cpp:97:9: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
if(i == arr.size() - 1 || ori(p, arr[i], q) > 0){
~~^~~~~~~~~~~~~~~~~
squad.cpp: In member function 'convhull convhull::operator+(const convhull&) const':
squad.cpp:160:24: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
for(int i = 0; i + 1 < temp.ch.size(); i ++){
~~~~~~^~~~~~~~~~~~~~~~
squad.cpp: In lambda function:
squad.cpp:193:13: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
int m = l + r >> 1;
~~^~~
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
256 KB |
Output isn't correct |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
256 KB |
Output isn't correct |
| 2 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Incorrect |
2 ms |
256 KB |
Output isn't correct |
| 2 |
Halted |
0 ms |
0 KB |
- |
