QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#721331#9520. Concave HulltelgsWA 172ms17976kbC++2313.4kb2024-11-07 15:52:312024-11-07 15:52:33

Judging History

你现在查看的是最新测评结果

  • [2024-11-07 15:52:33]
  • 评测
  • 测评结果:WA
  • 用时:172ms
  • 内存:17976kb
  • [2024-11-07 15:52:31]
  • 提交

answer

// #pragma GCC optimize(2)

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<set>
#include<unordered_map>
#include<queue>
#include<iomanip>
#include<cmath>
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)

using namespace std;
using ll=long long;
using pii=pair<ll,ll>;
using ld=long double;

constexpr ll N=1e6+10,mod=1e8-3,INF=1e18;
constexpr ld inf=1e18,eps=1e-5;

ll n;

// using point_t=long long;
using point_t=long double;

// 点与向量
template<typename T> struct point{
    T x,y;
    bool operator==(const point &a) const{
        return (abs(x-a.x)<=eps && abs(y-a.y)<=eps);
    }
    bool operator<(const point &a) const{
    if(abs(x-a.x)<=eps) return y<a.y-eps;
        return x<a.x-eps;
    }
    bool operator>(const point &a) const{
        return !(*this<a||*this==a);
    }
    point operator+(const point &a) const{
        return {x+a.x,y+a.y};
    }
    point operator-(const point &a) const{
        return {x-a.x,y-a.y};
    }
    point operator-() const{
        return {-x,-y};}
    point operator*(const T k) const{
        return {k*x,k*y};
    }
    point operator/(const T k) const{
        return {x/k,y/k};
    }
    // 点积
    T operator*(const point &a) const{return x*a.x+y*a.y;
    }
    // 叉积,注意优先级
    T operator^(const point &a) const{
        return x*a.y-y*a.x;
    }
    // to-left 测试
    int toleft(const point &a) const{
    const auto t=(*this)^a;
        return (t>eps)-(t<-eps);
    }
    // 向量长度的平方
    T len2() const{
        return (*this)*(*this);
    }
    // 两点距离的平方
    T dis2(const point &a) const{
        return (a-(*this)).len2();
    }
    // 涉及浮点数
    // 向量长度
    long double len() const{
        return sqrtl(len2());
    }
    // 两点距离
    long double dis(const point &a) const{
        return sqrtl(dis2(a));
    }
    // 向量夹角
    long double ang(const point &a) const{
        return acosl(max(-1.0l,min(1.0l,((*this)*a)/(len()*a.len()))));
    }
    // 逆时针旋转(给定角度)
    point rot(const long double rad) const{
        return {x*cos(rad)-y*sin(rad),x*sin(rad)+y*cos(rad)};
    }
    // 逆时针旋转(给定角度的正弦与余弦)
    point rot(const long double cosr,const long double sinr) const{
        return {x*cosr-y*sinr,x*sinr+y*cosr};
    }
};
using Point=point<point_t>;
// 极角排序
struct argcmp{
    bool operator()(const Point &a,const Point &b) const{
        const auto quad=[](const Point &a){
            if (a.y<-eps) return 1;
            if (a.y>eps) return 4;if (a.x<-eps) return 5;
            if (a.x>eps) return 3;
            return 2;
        };
        const int qa=quad(a),qb=quad(b);
        if (qa!=qb) return qa<qb;
        const auto t=a^b;
        // if (abs(t)<=eps) return a*a<b*b-eps;
        // 不同长度的向量需要分开
        return t>eps;
    }
};

// 直线
template<typename T> struct line{
    point<T> p,v;
    // p 为直线上一点,v 为方向向量
    bool operator==(const line &a) const{
        return v.toleft(a.v)==0&&v.toleft(p-a.p)==0;
    }
    // to-left 测试
    int toleft(const point<T> &a) const{
        return v.toleft(a-p);
    }
    // 半平面交算法定义的排序
    bool operator<(const line &a) const{
    if (abs(v^a.v)<=eps&&v*a.v>=-eps) return toleft(a.p)==-1;
        return argcmp()(v,a.v);
    }
    // 涉及浮点数
    // 直线交点
    point<T> inter(const line &a) const{
        return p+v*((a.v^(p-a.p))/(v^a.v));
    }
    // 点到直线距离
    long double dis(const point<T> &a) const{
        return abs(v^(a-p))/v.len();
    }
    // 点在直线上的投影
    point<T> proj(const point<T> &a) const{
        return p+v*((v*(a-p))/(v*v));
    }
};
using Line=line<point_t>;

//线段
template<typename T> struct segment{
    point<T> a,b;
    bool operator<(const segment &s) const{
        return make_pair(a,b)<make_pair(s.a,s.b);
    }
    // 判定性函数建议在整数域使用// 判断点是否在线段上
    // -1 点在线段端点 | 0 点不在线段上 | 1 点严格在线段上
    int is_on(const point<T> &p) const{
    if (p==a||p==b) return -1;
        return (p-a).toleft(p-b)==0&&(p-a)*(p-b)<-eps;
    }
    // 判断线段直线是否相交
    // -1 直线经过线段端点 | 0 线段和直线不相交 | 1 线段和直线严格相交
    int is_inter(const line<T> &l) const{
    if (l.toleft(a)==0||l.toleft(b)==0) return -1;
        return l.toleft(a)!=l.toleft(b);
    }
    // 判断两线段是否相交
    // -1 在某一线段端点处相交 | 0 两线段不相交 | 1 两线段严格相交
    int is_inter(const segment<T> &s)const{
    if (is_on(s.a)||is_on(s.b)||s.is_on(a)||s.is_on(b)) return -1;
        const line<T> l={a,b-a},ls={s.a,s.b-s.a};
        return l.toleft(s.a)*l.toleft(s.b)==-1&&ls.toleft(a)*ls.toleft(b)==-1;
    }
    // 点到线段距离
    long double dis(const point<T> &p) const{
    if((p-a)*(b-a)<-eps||(p-b)*(a-b)<-eps) return min(p.dis(a),p.dis(b));
        const line<T> l={a,b-a};
        return l.dis(p);
    }
    // 两线段间距离
    long double dis(const segment<T> &s) const{
    if(is_inter(s)) return 0;
        return min({dis(s.a),dis(s.b),s.dis(a),s.dis(b)});
    }
};
using Segment=segment<point_t>;

// 多边形
template<typename T> struct polygon{
    vector<point<T>> p;
    // 以逆时针顺序存储
    size_t nxt(const size_t i) const{
        return i==p.size()-1?0:i+1;
    }
    size_t pre(const size_t i) const{
        return i==0?p.size()-1:i-1;
    }
    // 回转数
    // 返回值第一项表示点是否在多边形边上
    // 对于狭义多边形,回转数为 0 表示点在多边形外,否则点在多边形内
    pair<bool,int> winding(const point<T> &a) const{
        int cnt=0;
        for(size_t i=0;i<p.size();i++){
            const point<T> u=p[i],v=p[nxt(i)];
            if(abs((a-u)^(a-v))<=eps && (a-u)*(a-v)<=eps) return {true,0};
            if(abs(u.y-v.y)<=eps) continue;
            const Line uv={u,v-u};
            if(u.y<v.y-eps&&uv.toleft(a)<=0) continue;if(u.y>v.y+eps&&uv.toleft(a)>=0) continue;
            if(u.y<a.y-eps&&v.y>=a.y-eps) cnt++;
            if(u.y>=a.y-eps&&v.y<a.y-eps) cnt--;
        }
        return {false,cnt};
    }
    // 多边形面积的两倍
    // 可用于判断点的存储顺序是顺时针或逆时针
    T area() const{
        T sum=0;
        for(size_t i=0;i<p.size();i++) sum+=p[i]^p[nxt(i)];
        return sum;
    }
    // 多边形的周长
    long double circ() const{
        long double sum=0;
        for(size_t i=0;i<p.size();i++) sum+=p[i].dis(p[nxt(i)]);
        return sum;
    }
};
using Polygon=polygon<point_t>;

//凸多边形
template<typename T> struct convex:polygon<T>{
    // 闵可夫斯基和
    convex operator+(const convex &c) const{
        const auto &p=this->p;
        vector<Segment> e1(p.size()),e2(c.p.size()),edge(p.size()+c.p.size());
        vector<point<T>> res;
        res.reserve(p.size()+c.p.size());
        const auto cmp=[](const Segment &u,const Segment &v){
            return argcmp()(u.b-u.a,v.b-v.a);
        };
        for(size_t i=0;i<p.size();i++) e1[i]={p[i],p[this->nxt(i)]};
        for(size_t i=0;i<c.p.size();i++) e2[i]={c.p[i],c.p[c.nxt(i)]};
        rotate(e1.begin(),min_element(e1.begin(),e1.end(),cmp),e1.end());
        rotate(e2.begin(),min_element(e2.begin(),e2.end(),cmp),e2.end());
        merge(e1.begin(),e1.end(),e2.begin(),e2.end(),edge.begin(),cmp);
        const auto check=[](const vector<point<T>> &res,const point<T> &u){
            const auto back1=res.back(),back2=*prev(res.end(),2);
            return (back1-back2).toleft(u-back1)==0 && (back1-back2)*(u-back1)>=-eps;
        };
        auto u=e1[0].a+e2[0].a;
        for(const auto &v:edge){
            while(res.size()>1&&check(res,u)) res.pop_back();
            res.push_back(u);
            u=u+v.b-v.a;
        }
        if(res.size()>1&&check(res,res[0])) res.pop_back();
        return {res};
    }
    // 旋转卡壳// 例:凸多边形的直径的平方
    T rotcaliper() const{
        const auto &p=this->p;
        if(p.size()==1) return 0;
        if(p.size()==2) return p[0].dis2(p[1]);
        const auto area=[](const point<T> &u,const point<T> &v,const point<T> &w)
        {return (w-u)^(w-v);};
        T ans=0;
        for(size_t i=0,j=1;i<p.size();i++){
            const auto nxti=this->nxt(i);
            ans=max({ans,p[j].dis2(p[i]),p[j].dis2(p[nxti])});
            while (area(p[this->nxt(j)],p[i],p[nxti])>=area(p[j],p[i],p[nxti])){
                j=this->nxt(j);
                ans=max({ans,p[j].dis2(p[i]),p[j].dis2(p[nxti])});
            }
        }
        return ans;
    }
    // 判断点是否在凸多边形内
    // 复杂度 O(logn)
    // -1 点在多边形边上 | 0 点在多边形外 | 1 点在多边形内
    int is_in(const point<T> &a) const{
        const auto &p=this->p;
        if(p.size()==1) return a==p[0]?-1:0;
        if(p.size()==2) return segment<T>{p[0],p[1]}.is_on(a)?-1:0;
        if(a==p[0]) return -1;
        if((p[1]-p[0]).toleft(a-p[0])==-1 || (p.back()-p[0]).toleft(a-p[0])==1)
        return 0;
        const auto cmp=[&](const point<T> &u,const point<T> &v){
            return (u-p[0]).toleft(v-p[0])==1;
        };
        const size_t i=lower_bound(p.begin()+1,p.end(),a,cmp)-p.begin();
        if(i==1) return segment<T>{p[0],p[i]}.is_on(a)?-1:0;
        if(i==p.size()-1&&segment<T>{p[0],p[i]}.is_on(a)) return -1;
        if(segment<T>{p[i-1],p[i]}.is_on(a)) return -1;
        return (p[i]-p[i-1]).toleft(a-p[i-1])>0;
    }
    // 凸多边形关于某一方向的极点
    // 复杂度 O(logn)
    // 参考资料:https://codeforces.com/blog/entry/48868
    template<typename F> size_t extreme(const F &dir) const{
        const auto &p=this->p;
        const auto check=[&](const size_t i){
        return dir(p[i]).toleft(p[this->nxt(i)]-p[i])>=0;
    };
    const auto dir0=dir(p[0]);
    const auto check0=check(0);
    if(!check0&&check(p.size()-1)) return 0;
        const auto cmp=[&](const point<T> &v){
            const size_t vi=&v-p.data();
            if (vi==0) return 1;
            const auto checkv=check(vi);
            const auto t=dir0.toleft(v-p[0]);
            if (vi==1 && checkv==check0 && t==0) return 1;
            return checkv^(checkv==check0&&t<=0);
        };
        return partition_point(p.begin(),p.end(),cmp)-p.begin();
    }
    // 过凸多边形外一点求凸多边形的切线,返回切点下标
    // 复杂度 O(logn)
    // 必须保证点在多边形外
    pair<size_t,size_t> tangent(const point<T> &a) const{
        const size_t i=extreme([&](const point<T> &u){return u-a;});
        const size_t j=extreme([&](const point<T> &u){return a-u;});
        return {i,j};
    }
    // 求平行于给定直线的凸多边形的切线,返回切点下标
    // 复杂度 O(logn)
    pair<size_t,size_t> tangent(const line<T> &a) const{
        const size_t i=extreme([&](...){return a.v;});
        const size_t j=extreme([&](...){return -a.v;});
        return {i,j};
    }
};
using Convex=convex<point_t>;

// 点集的凸包
// Andrew 算法,复杂度 O(nlogn)
Convex convexhull(vector<Point> p){
    vector<Point> st;
    if (p.empty()) return Convex{st};sort(p.begin(),p.end());
    const auto check=[](const vector<Point> &st,const Point &u){
        const auto back1=st.back(),back2=*prev(st.end(),2);
        return (back1-back2).toleft(u-back1)<=0;
    };
    for (const Point &u:p){
        while (st.size()>1 && check(st,u)) st.pop_back();
        st.push_back(u);
    }
    size_t k=st.size();
    p.pop_back();
    reverse(p.begin(),p.end());
    for (const Point &u:p){
        while (st.size()>k && check(st,u)) st.pop_back();
        st.push_back(u);
    }
    st.pop_back();
    return Convex{st};
}

void solve(){
    cin>>n;
    
    vector<Point> vec1;
    Point p;
    for(int i=1;i<=n;i++){
        cin>>p.x>>p.y;
        vec1.push_back(p);
    }
    sort(vec1.begin(),vec1.end(),argcmp());
    // for(auto x:vec1) cout<<x.x<<' '<<x.y<<'\n';

    Convex cvx1=convexhull(vec1);
    
    set<Point> q;
    for(auto x:cvx1.p){
        q.insert(x);
    }

    vector<Point> vec2;
    for(auto x:vec1){
        if(q.find(x)==q.end()){
            vec2.push_back(x);
        } 
    }
    sort(vec2.begin(),vec2.end(),argcmp());

    if(vec2.size()==0) return cout<<"-1\n",void();
    // cout<<vec2.size()<<'\n';
    Convex cvx2=convexhull(vec2);
    if(cvx2.p.size()==0) cvx2.p.push_back(vec2[0]);
    // cout<<cvx2.p.size()<<'\n';
    // for(auto x:cvx2.p) cout<<x.x<<' '<<x.y<<'\n';

    ll pos1=0,pos2=0;
    ll cnt0=0;
    ld ans=INF,sum=cvx1.area();
    while(!cnt0){
        Point p=cvx1.p[pos1],p1=cvx1.p[cvx1.nxt(pos1)];
        ld dlt=(p1-p)^(cvx2.p[pos2]-p);
        while(((p1-p)^(cvx2.p[cvx2.nxt(pos2)]-p))<dlt){
            dlt=(p1-p)^(cvx2.p[cvx2.nxt(pos2)]-p);
            pos2=cvx2.nxt(pos2);
        }

        pos1=cvx1.nxt(pos1);
        if(!pos1) cnt0++;
        // cout<<dlt<<'\n';
        ans=min(ans,dlt);
    }

    cout<<(ll)(sum-ans)<<'\n';
}

int main(){
    IOS;
    int t=1;
    cin>>t;
    while(t--) solve();
    return 0;
}

/*
2
6
-2 0
1 -2
5 2
0 4
1 2
3 1
4
0 0
1 0
0 1
1 1
*/

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 0ms
memory: 3732kb

input:

2
6
-2 0
1 -2
5 2
0 4
1 2
3 1
4
0 0
1 0
0 1
1 1

output:

40
-1

result:

ok 2 lines

Test #2:

score: 0
Accepted
time: 1ms
memory: 3792kb

input:

10
243
-494423502 -591557038
-493438474 -648991734
-493289308 -656152126
-491185085 -661710614
-489063449 -666925265
-464265894 -709944049
-447472922 -737242534
-415977509 -773788538
-394263365 -797285016
-382728841 -807396819
-373481975 -814685302
-368242265 -818267002
-344482838 -833805545
-279398...

output:

2178418010787347715
1826413114144932145
1651687576234220014
1883871859778998985
2119126281997959892
894016174881844630
2271191316922158910
1998643358049669416
1740474221286618711
1168195646932543192

result:

ok 10 lines

Test #3:

score: 0
Accepted
time: 61ms
memory: 4072kb

input:

1000
125
64661186 -13143076
302828013 -185438065
-418713797 -191594241
430218126 -397441626
354327250 -836704374
149668812 -598584998
311305970 66790541
199720625 -592356787
468137 -584752683
258775829 96211747
-358669612 -134890109
-129221188 -998432368
-277309896 -140056561
356901185 420557649
-51...

output:

1986320445246155278
1900093336073022078
1612088392301142476
2012259136539173407
1819942017252118749
1772230185841892196
1164835025329039520
1527446155241140517
1807368432185303666
1236918659444944569
1306839249967484778
1984123720246784099
1868728080720036006
667458140583450322
2127932992585026491
4...

result:

ok 1000 lines

Test #4:

score: 0
Accepted
time: 85ms
memory: 3832kb

input:

10000
9
484630042 51929469
-40468396 -517784096
98214104 -103353239
629244333 -475172587
106398764 153884485
49211709 -44865749
1 10
166321833 -247717657
406208245 668933360
13
548702216 -631976459
37150086 -292461024
707804811 -486185860
239775286 -903166050
10096571 -541890068
686103484 558731937
...

output:

950319193795831919
1661025342421008544
1285164852091455548
1159924751776806668
1206071151805176722
794021230296144371
699991678992587791
1133990718508584290
1486311831172661605
984875884297072200
1327767982175057345
758247019006396699
1355381234262206155
1139262078529131471
1613462877860621700
12392...

result:

ok 10000 lines

Test #5:

score: 0
Accepted
time: 134ms
memory: 4992kb

input:

100
439
471536154 -312612104
155692036 -937312180
-461624056 -357636609
236656684 -911414873
-288656914 -74788431
-465779694 -381475149
-334197401 -903065737
491513067 -447615916
337664889 -852236281
-281689379 -53519178
-159101704 -920779200
-326159514 -95396204
21868593 -994282736
488425383 -41046...

output:

1973162724053130487
2054612790507830954
1726805687754843724
1699420177872986528
2129388571309147631
2198295137903288810
1697185883164440272
1219697450095721478
2027023581922285255
1674691247127206655
1673105966817209954
2179188692918747442
2146544318743443141
2230356305133660648
1676850321902993764
...

result:

ok 100 lines

Test #6:

score: 0
Accepted
time: 125ms
memory: 4932kb

input:

100
1362
-467257672 -466669
-467054869 -478108
-466973270 -481776
-466556983 -499770
-466329414 -508693
-466248017 -511805
-466158865 -513786
-466101273 -515035
-465927700 -518748
-465717624 -522106
-465303448 -528127
-465124548 -530726
-464649746 -536693
-464554872 -537799
-464478196 -538680
-46416...

output:

1666097696993497
1791366071767866
1806187278469532
1683419854733713
1685891971828916
1730190225081651
1787048201197565
1850308098208660
1710694884375502
1826363113637639
1816375352374659
2047431269497691
1549806516003854
1829438662895747
1678707854135065
1687423392883819
2121960009997761
16687219538...

result:

ok 100 lines

Test #7:

score: 0
Accepted
time: 77ms
memory: 11836kb

input:

2
62666
-486101704 -505730259
-486101698 -506082699
-486101689 -506111362
-486101682 -506126031
-486101528 -506293759
-486101259 -506556385
-486101196 -506613483
-486101154 -506648604
-486100935 -506831392
-486100631 -507083675
-486100470 -507199151
-486100233 -507368923
-486100193 -507397039
-48609...

output:

2178736946152219010
1825181940245096152

result:

ok 2 lines

Test #8:

score: 0
Accepted
time: 172ms
memory: 17976kb

input:

2
100000
301945097 76373292
467957663 -286424714
8245445 -597212507
-474204621 -708828667
184159460 105942538
443435905 -429212625
490658771 -382198656
82512047 -612522436
-228221388 -965890088
394789011 -145801151
-106120174 -528202395
428939626 -194437311
497429477 -527407728
365739746 -114818962
...

output:

2502889432701099511
2267250485735988121

result:

ok 2 lines

Test #9:

score: 0
Accepted
time: 170ms
memory: 17560kb

input:

2
100000
221128057 -975244780
-618765360 -785575858
422567455 -906331476
-988680318 -150037424
-929870145 367887908
-757813541 -652471177
291995621 -956419655
-785381507 619012026
468864522 -883270094
-588416522 808557973
859345881 511394814
988105866 153775152
216931298 -976186873
467050734 8842305...

output:

6283183114882825575
6283183188903854361

result:

ok 2 lines

Test #10:

score: -100
Wrong Answer
time: 0ms
memory: 3916kb

input:

7
5
-1000000000 -1000000000
1000000000 -1000000000
1000000000 1000000000
1 0
-1 0
5
1000000000 1000000000
-1000000000 -1000000000
-2 0
-1 0
1 -1
6
1000000000 1000000000
-1000000000 -1000000000
-3 0
-1 0
0 -1
1 -1
4
-1000000000 -1000000000
1000000000 -1000000000
1000000000 1000000000
-1000000000 1000...

output:

4000000000000000000
7000000000
9000000001
-1
7000000000000000000
7999999998000000000
-1

result:

wrong answer 5th lines differ - expected: '6000000002000000000', found: '7000000000000000000'