結果

問題 No.1319 最強とんがりコーン
ユーザー 👑 KazunKazun
提出日時 2021-07-16 18:34:43
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 802 ms / 2,000 ms
コード長 4,309 bytes
コンパイル時間 1,133 ms
コンパイル使用メモリ 82,048 KB
実行使用メモリ 76,672 KB
最終ジャッジ日時 2024-07-06 05:27:06
合計ジャッジ時間 37,773 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 741 ms
76,160 KB
testcase_01 AC 740 ms
76,160 KB
testcase_02 AC 493 ms
76,416 KB
testcase_03 AC 358 ms
76,032 KB
testcase_04 AC 739 ms
76,288 KB
testcase_05 AC 678 ms
76,288 KB
testcase_06 AC 525 ms
76,288 KB
testcase_07 AC 392 ms
76,032 KB
testcase_08 AC 545 ms
76,288 KB
testcase_09 AC 692 ms
76,288 KB
testcase_10 AC 253 ms
76,672 KB
testcase_11 AC 421 ms
76,544 KB
testcase_12 AC 576 ms
76,268 KB
testcase_13 AC 453 ms
76,288 KB
testcase_14 AC 289 ms
76,288 KB
testcase_15 AC 452 ms
76,160 KB
testcase_16 AC 299 ms
76,416 KB
testcase_17 AC 759 ms
76,544 KB
testcase_18 AC 324 ms
76,288 KB
testcase_19 AC 742 ms
76,160 KB
testcase_20 AC 736 ms
76,288 KB
testcase_21 AC 734 ms
76,288 KB
testcase_22 AC 802 ms
76,288 KB
testcase_23 AC 726 ms
76,416 KB
testcase_24 AC 731 ms
76,544 KB
testcase_25 AC 729 ms
76,416 KB
testcase_26 AC 733 ms
76,288 KB
testcase_27 AC 747 ms
76,544 KB
testcase_28 AC 738 ms
76,544 KB
testcase_29 AC 730 ms
76,032 KB
testcase_30 AC 735 ms
76,288 KB
testcase_31 AC 734 ms
76,416 KB
testcase_32 AC 522 ms
76,160 KB
testcase_33 AC 741 ms
76,672 KB
testcase_34 AC 726 ms
76,288 KB
testcase_35 AC 726 ms
76,160 KB
testcase_36 AC 721 ms
76,416 KB
testcase_37 AC 739 ms
76,416 KB
testcase_38 AC 728 ms
76,288 KB
testcase_39 AC 740 ms
76,032 KB
testcase_40 AC 428 ms
76,416 KB
testcase_41 AC 252 ms
76,288 KB
testcase_42 AC 299 ms
76,288 KB
testcase_43 AC 259 ms
76,284 KB
testcase_44 AC 287 ms
76,416 KB
testcase_45 AC 241 ms
76,544 KB
testcase_46 AC 664 ms
76,544 KB
testcase_47 AC 263 ms
76,416 KB
testcase_48 AC 420 ms
76,032 KB
testcase_49 AC 274 ms
76,160 KB
testcase_50 AC 268 ms
76,032 KB
testcase_51 AC 255 ms
76,288 KB
testcase_52 AC 254 ms
76,584 KB
testcase_53 AC 233 ms
76,672 KB
testcase_54 AC 307 ms
76,344 KB
testcase_55 AC 282 ms
76,160 KB
testcase_56 AC 261 ms
76,348 KB
testcase_57 AC 248 ms
76,672 KB
testcase_58 AC 242 ms
76,160 KB
testcase_59 AC 229 ms
76,032 KB
testcase_60 AC 147 ms
76,160 KB
testcase_61 AC 148 ms
76,288 KB
testcase_62 AC 151 ms
76,096 KB
testcase_63 AC 153 ms
75,904 KB
testcase_64 AC 525 ms
76,032 KB
testcase_65 AC 550 ms
76,544 KB
testcase_66 AC 154 ms
76,160 KB
testcase_67 AC 720 ms
76,288 KB
testcase_68 AC 726 ms
76,544 KB
testcase_69 AC 722 ms
76,288 KB
testcase_70 AC 270 ms
76,160 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

from math import sqrt,sin,cos,tan,asin,acos,atan2,pi,floor

def compare(x,y,ep):
    """ x,y の大小比較をする. ただし, ep の誤差は同一視する.

    [Input]
    x,y: float
    ep: float

    [Output]
    x>y: 1
    x=y: 0
    x<y: -1
    """

    if x-y>ep: return 1
    elif x-y<-ep: return -1
    else: return 0

class Point():
    __slots__=["x","y","id"]
    ep=1e-9

    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
        self.id=0

    def sign(self,a):
        if a<-self.ep:
            return -1
        elif a>self.ep:
            return 1
        else:
            return 0

    #文字列
    def __str__(self):
        return "({}, {})".format(self.x,self.y)

    __repr__=__str__

    #Bool
    def __bool__(self):
        return self.sign(self.x)!=0 or self.sign(self.y)!=0

    #等号
    def __eq__(self,other):
        return self.sign(self.x-other.x)==0 and self.sign(self.y-other.y)==0

    #不等号
    def __ne__(self,other):
        return not self==other

    #比較(<)
    def __lt__(self,other):
        T=self.sign(self.x-other.x)
        if T:
            return T<0
        else:
            return self.sign(self.y-other.y)<0

    #比較(<=)
    def __le__(self,other):
        return self<other or self==other

    #比較(>)
    def __gt__(self,other):
        return other<self

    #比較(>=)
    def __ge__(self,other):
        return other<=self

    #正と負
    def __pos__(self):
        return self

    def __neg__(self):
        return Point(-self.x,-self.y)

    #加法
    def __add__(self,other):
        return Point(self.x+other.x,self.y+other.y)

    #減法
    def __sub__(self,other):
        return Point(self.x-other.x,self.y-other.y)

    #乗法
    def __mul__(self,other):
        x,y=self.x,self.y
        u,v=other.x,other.y
        return Point(x*u-y*v,x*v+y*u)

    def __rmul__(self,other):
        if isinstance(other,(int,float)):
            return Point(other*self.x,other*self.y)

    #除法
    def __truediv__(self,other):
        if other==0:
            raise ZeroDivisionError
        return Point(self.x/other,self.y/other)

    #絶対値
    def __abs__(self):
        return sqrt(self.x*self.x+self.y*self.y)

    norm=__abs__

    def norm_2(self):
        return self.x*self.x+self.y*self.y

    #回転
    def rotate(self,theta):
        x,y=self.x,self.y
        s,c=sin(theta),cos(theta)
        return Point(c*x-s*y,s*x+c*y)

    def __iter__(self):
        yield self.x
        yield self.y

    def __hash__(self):
        return hash((self.x,self.y))

    def latticization(self,delta=1e-7):
        if abs(self.x-floor(self.x+0.5))<delta and abs(self.y-floor(self.y+0.5))<delta:
            self.x=floor(self.x+0.5)
            self.y=floor(self.y+0.5)

    def normalization(self):
        a=abs(self)
        self.x/=a
        self.y/=a

    def dot(self,other):
        return self.x*other.x+self.y*other.y

    def det(self,other):
        return self.x*other.y-self.y*other.x

    def arg(self):
        return atan2(self.y,self.x)

class Circle():
    __slots__=["P","r","id"]

    ep=1e-9
    def __init__(self,Center:Point,Radius:float):
        """ 2点 P を中心とする半径 r の円を生成する.

        P: Point
        r>=0
        """
        assert Radius>=0

        self.P=Center
        self.r=Radius
        self.id=4

    def __str__(self):
        return "[Circle] Center: {}, Radius: {}".format(self.P,self.r)

    __repr__=__str__

    def __contains__(self,P):
        return abs(abs(P-self.P)-self.r)<self.ep

def Circles_Intersection_Area(C,D):
    """ 2つの円 C, D の共通部分の面積を求める.

    C, D: Circle
    """

    d=abs(C.P-D.P)
    r=C.r; s=D.r
    ep=max(C.ep, D.ep)

    if compare(d,r+s,ep)==1:
        return 0
    if compare(d,abs(r-s),ep)==-1:
        a=min(r,s)
        return pi*a*a

    alpha=acos((d*d+r*r-s*s)/(2*d*r))
    beta =acos((d*d-r*r+s*s)/(2*d*s))

    X=r*r*alpha
    Y=s*s*beta
    Z=d*r*sin(alpha)
    return X+Y-Z
#=================================================
R,H,D=map(float,input().split())

z=0
delta=H*(1e-7)
X=Circle(Point(0,0),0)
Y=Circle(Point(D,0),0)
V=0

while z<H:
    r=R*(1-(2*z+delta)/(2*H))
    X.r=Y.r=r
    V+=Circles_Intersection_Area(X,Y)*delta
    z+=delta

print(V)
0