QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#799117#7862. Land Tradeucup-team173AC ✓1166ms38024kbC++175.3kb2024-12-04 22:24:362024-12-04 22:24:36

Judging History

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

  • [2024-12-04 22:24:36]
  • 评测
  • 测评结果:AC
  • 用时:1166ms
  • 内存:38024kb
  • [2024-12-04 22:24:36]
  • 提交

answer

#include <bits/stdc++.h>
using namespace std;
#define pb push_back

using ll = long long;
using db = long double;

const int mod = 1e9 + 7;
int add(int x, int y) {
    x += y;
    return x >= mod ? x - mod : x;
}
void addto(int& x, int y) {
    x += y;
    if (x >= mod) x -= mod;
}
int mul(int x, int y) {
    return 1ll * x * y % mod;
}

int qpow(int a, int b) {
    int ans = 1;
    while (b) {
        if (b & 1) ans = mul(ans, a);
        a = mul(a, a);
        b >>= 1;
    }
    return ans;
}

const int maxn = 111111;

const db eps = 1e-12;
int sgn(db x) {
    if (x > eps) return 1;
    if (x < -eps) return -1;
    return 0;
}

struct vec {
    db x, y;
    vec(db _x = 0, db _y = 0) : x(_x), y(_y) {}
    vec operator+(vec b) {
        return vec(x + b.x, y + b.y);
    }
    vec operator-(vec b) {
        return vec(x - b.x, y - b.y);
    }
    vec operator*(db b) {
        return vec(x * b, y * b);
    }
    db operator*(vec b) {
        return x * b.y - y * b.x;
    }
};
db cross(vec a, vec b, vec c) {
    return (b - a) * (c - a);
}
vec inter(vec p1, vec p2, vec q1, vec q2) {
    db s1 = cross(p1, q1, p2);
    db s2 = cross(p1, p2, q2);
    db t1 = s1 / (s1 + s2);
    db t2 = s2 / (s1 + s2);
    return  q2*t1  +  q1*t2;
}

vector<vector<vec>> split(vector<vec> p, vec p1, vec p2) {
    int havepos1 = -1, haveneg1 = -1;
    for (int i=0;i<p.size();i++) {
        int tmp = sgn(cross(p1, p2, p[i]));
        if (tmp == -1) haveneg1 = i;
        if (tmp == 1) havepos1 = i;
    }
    if (havepos1==-1 || haveneg1==-1) return {p};
    auto ne=[&](int i){
        return i+1==p.size()?0:i+1;
    };
    auto pre=[&](int i){
        return i==0?(int)p.size()-1:i-1;
    };
    while(sgn(cross(p1, p2, p[ne(havepos1)]))==1)havepos1=ne(havepos1);
    while(sgn(cross(p1, p2, p[ne(haveneg1)]))==-1)haveneg1=ne(haveneg1);
    auto q1=inter(p[haveneg1], p[ne(haveneg1)], p1, p2);
    auto q2=inter(p[havepos1], p[ne(havepos1)], p1, p2);
    vector<vec> ans1, ans2;
    ans1.push_back(q2);
    ans1.push_back(q1);
    while(sgn(cross(p1,p2,p[haveneg1]))==-1)ans1.push_back(p[haveneg1]),haveneg1=pre(haveneg1);
    ans2.push_back(q1);
    ans2.push_back(q2);
    while(sgn(cross(p1,p2,p[havepos1]))==1)ans2.push_back(p[havepos1]),havepos1=pre(havepos1);
    reverse(ans1.begin(), ans1.end())  ;
    reverse(ans2.begin(), ans2.end());
    return {ans1, ans2};
}

vector<int>tr[maxn];
string ty[maxn];
int id[maxn];
db A[maxn],B[maxn],C[maxn];
int linecnt;
int cnt;
int curpos=0;
string s;
int res[maxn];
int parse(){
    if(s[curpos]=='-'||isdigit(s[curpos])){
        int sym=1;
        if(s[curpos]=='-')sym=-1,curpos++;
        int x=0;
        while(isdigit(s[curpos]))x=x*10+s[curpos++]-'0';
        return sym*x;
    }
    int cur=++cnt;
    if(s[curpos]=='['){
        ++curpos;
        ++linecnt;
        id[cur]=linecnt;
        ty[cur]="atomic";
        A[linecnt]=parse();
        ++curpos;
        B[linecnt]=parse();
        ++curpos;
        C[linecnt]=parse();
        ++curpos;
        return cur;
    }
    ++curpos;
    if(s[curpos]=='!'){
        ++curpos;
        ty[cur]="not";
        tr[cur].push_back(parse());
        ++curpos;
        return cur;
    }
    tr[cur].push_back(parse());
    if(s[curpos]=='&')ty[cur]="and";
    if(s[curpos]=='^')ty[cur]="xor";
    if(s[curpos]=='|')ty[cur]="or";
    curpos++;
    tr[cur].push_back(parse());
    ++curpos;
    return cur;
    
}
vec cent(vector<vec>p){
    db a=0;
    vec b;
    for(int i=1;i+1<p.size();i++){
        db s=cross(p[0],p[i],p[i+1])/2;
        vec cen=(p[0]+p[i]+p[i+1])*(1./3);
        a+=s;
        b=b+cen*s;
    }
    return b*(1./a);
}
db S(vector<vec>p){
    db a=0;
    for(int i=1;i+1<p.size();i++){
        db s=cross(p[0],p[i],p[i+1])/2;
        a+=s;
    }
    return a;
}

int getres(int i){
    if(ty[i]=="atomic")return res[id[i]];
    if(ty[i]=="not")return !getres(tr[i][0]);
    if(ty[i]=="and")return getres(tr[i][0])&&getres(tr[i][1]);
    if(ty[i]=="or")return getres(tr[i][0])||getres(tr[i][1]);
    return getres(tr[i][0])^getres(tr[i][1]);
}
void solve() {
    db xmi,xma,ymi,yma;
    cin>>xmi>>xma>>ymi>>yma;;
    vector<vector<vec>>p={{vec(xmi,ymi),vec(xma,ymi),vec(xma,yma),vec(xmi,yma)}};
    cin>>s;
    curpos=0;
    int rt=parse();
    for(int i=1;i<=linecnt;i++){
        vec p1,p2;
        if(B[i]==0){
            p1=vec(-1.*C[i]/A[i],0);
            p2=vec(-1.*C[i]/A[i],100);
        }
        else{
            p1=vec(0,-1.*C[i]/B[i]);
            p2=vec(B[i],-1.*C[i]/B[i]-A[i]);
        }
        vector<vector<vec>> np;
        for(auto poly:p){
            for(auto q:split(poly,p1,p2)){
                np.push_back(q);
            }
        }
        p=np;
    }
    db ans=0;
    for(auto q:p){
        auto cen=cent(q);
        for(int i=1;i<=linecnt;i++){
            if(A[i]*cen.x+B[i]*cen.y+C[i]>0){
                res[i]=1;
            }
            else res[i]=0;
        }
        if(getres(rt))ans+=S(q);
    }
    cout<<fixed<<setprecision(20)<<ans<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--) solve();
    return 0;
}
/*
-5 10-10 5
((!([1,2,-3]&[10,3,-2]))^([-2,3,1]|[5,-2,7]))
*/

这程序好像有点Bug,我给组数据试试?

詳細信息

Test #1:

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

input:

0 1 0 1
([-1,1,0]^[-1,-1,1])

output:

0.50000000000000000000

result:

ok found '0.5000000', expected '0.5000000', error '0.0000000'

Test #2:

score: 0
Accepted
time: 0ms
memory: 14084kb

input:

-5 10 -10 5
((!([1,2,-3]&[10,3,-2]))^([-2,3,1]|[5,-2,7]))

output:

70.45169340463458110269

result:

ok found '70.4516934', expected '70.4516934', error '0.0000000'

Test #3:

score: 0
Accepted
time: 0ms
memory: 14988kb

input:

0 1 -1 1
([1,1,1]&[-1,-1,-1])

output:

0.00000000000000000000

result:

ok found '0.0000000', expected '0.0000000', error '-0.0000000'

Test #4:

score: 0
Accepted
time: 4ms
memory: 15868kb

input:

0 1000 0 1000
(([1,-1,0]&[-1000,999,999])&([1,0,-998]&[0,1,-998]))

output:

0.00050000000000008371

result:

ok found '0.0005000', expected '0.0005000', error '0.0000000'

Test #5:

score: 0
Accepted
time: 0ms
memory: 15484kb

input:

-725 165 643 735
((((!(([22,15,137]|(!([23,-5,-41]^(!([2,25,-515]&[-37,10,487])))))&(!(([25,24,47]^([-24,21,-114]^[19,-7,79]))^[4,20,241]))))^(!((!((!(([30,-1,474]^([14,17,155]^[-31,-6,-153]))|[-15,-15,108]))|(([-26,-11,421]&[-15,-3,-224])&[14,-3,458])))^[9,20,-404])))^(!((!((!(([14,-6,-464]^[-11,8,...

output:

47063.33485244147663806302

result:

ok found '47063.3348524', expected '47063.3348524', error '0.0000000'

Test #6:

score: 0
Accepted
time: 0ms
memory: 14648kb

input:

767 957 738 941
((!(((!([3,-3,507]^[-30,-10,425]))^[-6,7,643])^((!((!([-11,0,450]^[21,17,-65]))&(!([17,0,64]^[-11,0,804]))))|[-31,10,-687])))&((!(([-34,12,-527]^(!([17,-14,-219]^(!([13,-27,-105]^(!([18,-47,-110]&(!([-9,-20,-455]^[-18,26,-228])))))))))^([-4,0,144]^[10,1,396])))^((!((!([35,0,-221]&[-5...

output:

36999.05865566322366788654

result:

ok found '36999.0586557', expected '36999.0586557', error '0.0000000'

Test #7:

score: 0
Accepted
time: 1049ms
memory: 35560kb

input:

-513 213 -733 114
(!((!((!((((!([2,16,-57]|[15,40,-272]))^((!(([0,26,315]|[5,-4,-336])^(!([-12,2,218]&([17,-16,-730]&[-7,3,-263])))))^[18,-7,29]))^[5,30,-126])^((!(((!((([8,9,406]^(!([-26,6,63]^[-38,-25,108])))^(([-9,20,220]^(!([-2,-27,213]^[29,16,-269])))|[-12,-4,-586]))^([30,0,-443]|(!((!([-17,0,3...

output:

295728.60810361067620988251

result:

ok found '295728.6081036', expected '295728.6081036', error '0.0000000'

Test #8:

score: 0
Accepted
time: 13ms
memory: 14812kb

input:

-517 -379 -789 477
(((!((!(([1,-12,191]^(!(((!([32,0,89]^[-35,6,33]))^[-3,6,-293])^[20,-39,77])))^(([16,15,-285]^[15,-7,430])^([20,3,-95]|(!((!(([-15,-27,339]^[-11,-13,221])^[33,28,596]))|([-17,21,402]^[22,16,90])))))))&(!((!((!([12,-1,-279]^[-30,-13,224]))^[-29,24,-33]))^([31,-19,288]^(!((!([-1,26,...

output:

107150.60487969717611633769

result:

ok found '107150.6048797', expected '107150.6048797', error '0.0000000'

Test #9:

score: 0
Accepted
time: 6ms
memory: 15484kb

input:

-477 275 -266 519
(!((!((!((!([-1,3,162]|[-32,16,269]))&(!(((((([-31,7,114]^([-12,7,-163]^[23,-10,159]))|(!(([0,-16,114]^[-33,15,-190])|(!([1,-22,308]^[-31,13,316])))))^((!([-12,29,-22]^(([23,15,-8]^[0,15,46])^[6,15,356])))^[22,13,-163]))^([18,17,487]^[28,23,143]))|(!(((!((!(([7,-45,-583]&([31,2,-22...

output:

335169.31051751586574027897

result:

ok found '335169.3105175', expected '335169.3105175', error '0.0000000'

Test #10:

score: 0
Accepted
time: 0ms
memory: 15284kb

input:

175 624 -835 683
(!(((!(([-32,30,-478]^[23,4,-120])^[28,33,413]))|(!((!((!((!([-15,-5,0]^(!((!(((!([0,-32,90]^[-9,-22,-7]))^[-10,-35,344])|(!([1,11,-235]|[-31,-6,-344]))))^(!((!([-15,0,-90]|[-17,-10,-153]))^[-1,6,-8]))))))^(!([8,-6,302]^[-2,4,91]))))|([13,28,-70]^[16,-11,-74])))^(((((!((!((([-5,8,45...

output:

411470.35850494345470451663

result:

ok found '411470.3585049', expected '411470.3585049', error '0.0000000'

Test #11:

score: 0
Accepted
time: 154ms
memory: 20376kb

input:

-1000 1000 -1000 1000
([1,0,-1000]^([0,1,-1000]^([1,0,-980]^([0,1,-980]^([1,0,-960]^([0,1,-960]^([1,0,-940]^([0,1,-940]^([1,0,-920]^([0,1,-920]^([1,0,-900]^([0,1,-900]^([1,0,-880]^([0,1,-880]^([1,0,-860]^([0,1,-860]^([1,0,-840]^([0,1,-840]^([1,0,-820]^([0,1,-820]^([1,0,-800]^([0,1,-800]^([1,0,-780]^...

output:

2000000.00000000004069988790

result:

ok found '2000000.0000000', expected '2000000.0000000', error '0.0000000'

Test #12:

score: 0
Accepted
time: 163ms
memory: 19612kb

input:

-500 500 -500 500
([2,-3,-1000]^([2,3,-1000]^([2,-3,-980]^([2,3,-980]^([2,-3,-960]^([2,3,-960]^([2,-3,-940]^([2,3,-940]^([2,-3,-920]^([2,3,-920]^([2,-3,-900]^([2,3,-900]^([2,-3,-880]^([2,3,-880]^([2,-3,-860]^([2,3,-860]^([2,-3,-840]^([2,3,-840]^([2,-3,-820]^([2,3,-820]^([2,-3,-800]^([2,3,-800]^([2,-...

output:

539999.99999999999323563316

result:

ok found '540000.0000000', expected '540000.0000000', error '0.0000000'

Test #13:

score: 0
Accepted
time: 23ms
memory: 15584kb

input:

-1000 1000 -1000 1000
([-57,281,0]^([478,81,0]^([-362,995,0]^([-339,614,0]^([491,769,0]^([673,486,0]^([-637,374,0]^([-204,383,0]^([-509,859,0]^([-973,757,0]^([-707,648,0]^([-792,409,0]^([-944,621,0]^([446,21,0]^([-553,473,0]^([795,704,0]^([-821,992,0]^([89,47,0]^([771,332,0]^([-845,259,0]^([271,867,...

output:

1823923.89715295019504992524

result:

ok found '1823923.8971530', expected '1823923.8971530', error '0.0000000'

Test #14:

score: 0
Accepted
time: 0ms
memory: 15760kb

input:

-1000 1000 -1000 1000
(([-27,-20,-237]^((([31,17,247]^[-4,-23,-917])^(![8,21,-342]))^((([-17,2,-281]&[-26,-31,186])|[31,-21,-697])|[-18,8,-512])))&[-5,19,-104])

output:

420530.73454094051041352031

result:

ok found '420530.7345409', expected '420530.7345409', error '0.0000000'

Test #15:

score: 0
Accepted
time: 472ms
memory: 28664kb

input:

-1000 1000 -1000 1000
((((!(((([31,17,247]^[-4,-23,-917])^(![8,21,-342]))^((([-17,2,-281]&[-26,-31,186])|[31,-21,-697])|[-18,8,-512]))^((!((!(!((([12,23,237]|[913,22,925])^[-14,11,-956])^[-9,-10,818])))|((([3,1,-213]^[-296,-13,171])&(!(!((!((!([-10,6,636]^[17,19,-546]))^([28,28,-698]|[-14,-4,-295]))...

output:

1479667.44078596619704057957

result:

ok found '1479667.4407860', expected '1479667.4407860', error '0.0000000'

Test #16:

score: 0
Accepted
time: 1166ms
memory: 38024kb

input:

-1000 1000 -1000 1000
(((((((((((([-15,-2,9]^[-168,-28,507])^[-31,-23,293])^[23,-1,-290])^(([26,-4,869]^(([24,2,522]^[-10,5,-918])^[-22,5,50]))^[16,-827,-276]))^(([-1,-24,-651]^([16,15,-332]^[-722,29,-330]))^([-19,-23,14]^[12,-18,289])))^(((([6,-29,803]^[8,-8,50])^((([9,-7,-112]^([23,-29,-827]^[-12,...

output:

1945479.95743987042476419447

result:

ok found '1945479.9574399', expected '1945479.9574399', error '0.0000000'

Test #17:

score: 0
Accepted
time: 8ms
memory: 15568kb

input:

0 1000 0 1000
(((((((([85,-100,0]^[21,-100,0])^[55,-100,0])^([29,-100,0]^([47,-100,0]^([78,-100,0]^([13,-100,0]^([100,-11,0]^[86,-100,0]))))))^(([48,-100,0]^[35,-100,0])^((([39,-100,0]^[98,-100,0])^([9,-100,0]^[100,-14,0]))^[100,-79,0])))^([12,-100,0]^[100,-100,0]))^((([20,-100,0]^([100,-64,0]^([100...

output:

500000.00000000000000000000

result:

ok found '500000.0000000', expected '500000.0000000', error '0.0000000'

Test #18:

score: 0
Accepted
time: 141ms
memory: 19592kb

input:

0 100 0 100
(((([-85,1,0]^((([-21,1,0]^([-55,1,0]^(([-29,1,0]^[-47,1,0])^([-78,1,0]^[-13,1,0]))))^(([11,1,-100]^[-86,1,0])^[-48,1,0]))^([-35,1,0]^((((([-39,1,0]^([-98,1,0]^[-9,1,0]))^((([14,1,-100]^[79,1,-100])^[-12,1,0])^[100,1,-100]))^((([-20,1,0]^[64,1,-100])^(([60,1,-100]^([-1,1,0]^[41,1,-100]))...

output:

4987.31485497431416042957

result:

ok found '4987.3148550', expected '4987.3148550', error '0.0000000'

Test #19:

score: 0
Accepted
time: 602ms
memory: 25652kb

input:

-500 1000 -500 1000
((((((([2,-1,37]^[2,-1,1])^(([2,1,-55]^(([2,1,-29]^[2,1,-47])^[2,1,-78]))^([2,1,-13]^[0,1,-11])))^(((([2,1,-86]^([2,1,-48]^[2,-1,100]))^[2,-1,95])^[2,1,-98])^([2,1,-9]^([0,1,-14]^[0,1,-79]))))^([2,-1,88]^[0,1,-100]))^(([2,1,-20]^(([0,1,-64]^([2,-1,85]^[2,1,-1]))^(([2,-1,65]^([0,1...

output:

145000.00000000000000000000

result:

ok found '145000.0000000', expected '145000.0000000', error '0.0000000'

Test #20:

score: 0
Accepted
time: 0ms
memory: 16320kb

input:

0 1000 0 1000
(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!(!...

output:

623640.00000000000000000000

result:

ok found '623640.0000000', expected '623640.0000000', error '0.0000000'

Test #21:

score: 0
Accepted
time: 151ms
memory: 19444kb

input:

-300 300 -300 300
((([-199,200,0]&[299,-300,0])&([-1,-300,300]&[1,200,-200]))&([-1,-215,215]^((((([-1,-279,279]^[-1,-245,245])^(((((([-1,-271,271]^[-1,-253,253])^([-1,-222,222]^([-1,-287,287]^[289,-290,0])))^([-1,-214,214]^[-1,-252,252]))^(([-1,-265,265]^[-1,-261,261])^([-1,-202,202]^((([-1,-291,291...

output:

0.00000138891685755056

result:

ok found '0.0000014', expected '0.0000014', error '0.0000000'

Test #22:

score: 0
Accepted
time: 0ms
memory: 15964kb

input:

0 1000 0 1000
(([-998,999,0]&[999,-1000,0])&[-1,-1,3])

output:

0.00000112725366188335

result:

ok found '0.0000011', expected '0.0000011', error '0.0000000'

Extra Test:

score: 0
Extra Test Passed