Problem:


西暦20XX 年，学校対抗魔法競技大会が開かれていた．大会もいよいよ，最終競技を残すのみとなった．あなたはその競技の選手の1 人である．

あなたが出場する競技は，空間内に配置された青いオブジェをすべて破壊するまでの時間を競うというものである．選手は競技用の銃の持込が許可されている．空間内には複数の青いオブジェと同じ数の赤いオブジェ，そして複数の障害物が配置されている．青いオブジェと赤いオブジェは1 対1 に対応しており，赤いオブジェが配置されている座標から青いオブジェに弾を撃つことで青いオブジェを破壊しなければならない．空間内に配置されている障害物は球状であり，少しずつ組成が異なっているが，通常の弾であれば障害物に触れると弾はその場に止まってしまう．

競技に使われる弾はMagic Bullet という特殊な弾である．この弾は魔力をため込むことができ，弾が障害物に接触した際に自動的に魔力を消費し，弾が貫通する魔法が発動する．障害物の組成の違いから，貫通するために必要な魔法やその発動のために消費する魔力の量は異なっている．このため，ある障害物に対する魔法が発動した後であっても，別の障害物を貫通するためには新たに別の魔法を発動する必要がある．また，弾が複数の障害物に同時に接触した場合は同時に魔法が発動する．弾に込められた魔力の量は魔法の発動のたびに減少する．

障害物の位置や大きさ，貫通する魔法の発動に必要な魔力の量はすでに公開されているのに対し，赤いオブジェ，青いオブジェの位置は公開されていない．しかし，過去の同一競技の情報から，ある程度オブジェの位置を予想することができた．魔力を弾にこめることは非常に体力を消耗してしまうため，あなたは魔力をできるだけ節約したいと考えた．そこで，赤いオブジェとそれに対応する青いオブジェの位置を仮定して，そのときに弾にこめるべき必要な魔力の最小量，つまり，青いオブジェに到達している時点で弾に残っている魔力が0 になる魔力の量を求めよう．

Input

入力はすべて整数である．それぞれの数は1 つの空白により区切られる．

N Q
x1 y1 z1 r1 l1
:
xN yN zN rN lN
sx1 sy1 sz1 dx1 dy1 dz1
:
sxQ syQ szQ dxQ dyQ dzQ

 N は障害物の個数であり，Q は仮定した青いオブジェと赤いオブジェの座標の組の個数である．

 xi, yi, zi はそれぞれ i 個目の障害物の中心の位置を表す x 座標，y 座標，z 座標である．

 ri は i 個目の障害物の半径である．

 li は i 個目の障害物を貫通するための魔法で消費する魔力の量である．

 sxj, syj, szj はそれぞれ j 番目の仮定における赤いオブジェの位置を表す x 座標，y 座標，z 座標である．

 dxj, dyj, dzj はそれぞれ j 番目の仮定における青いオブジェの位置を表す x 座標，y 座標，z 座標である．

Constraints

 0 ≤ N ≤ 50 

 1 ≤ Q ≤ 50

 -500 ≤ xi, yi, zi ≤ 500

 1 ≤ ri ≤ 1,000

 1 ≤ li ≤ 1016

 -500 ≤ sxj, syj, szj ≤  500

 -500 ≤ dxj, dyj, dzj ≤ 500

 障害物が他の障害物にめり込んでいることはない

 オブジェの座標は障害物の内部，表面にはない

 それぞれの仮定において，赤いオブジェと青いオブジェの座標は一致しない

Output

それぞれ1 組の赤いオブジェとそれに対応する青いオブジェの位置の仮定において，空間中に障害物と赤いオブジェと青いオブジェ1 対とのみがあるものとして，弾にこめるべき魔力の量を1 行に出力せよ．弾は赤いオブジェの位置から青いオブジェの位置まで一直線に飛ぶものとし，弾の大きさは非常に小さいので点として扱う．

Sample Input 1

5 1
0 10 0 5 2
0 20 0 5 12
0 30 0 5 22
0 40 0 5 32
0 50 0 5 42
0 0 0 0 60 0

Output for the Sample Input 1

110

Sample Input 2

1 1
10 5 0 5 9
0 0 0 9 12 0

Output for the Sample Input 2

9

Sample Input 3

5 5
-38 -71 -293 75 1
-158 -38 -405 66 1
-236 -303 157 266 1
316 26 411 190 1
207 -312 -27 196 1
-50 292 -375 -401 389 -389
460 278 409 -329 -303 411
215 -220 -200 309 -474 300
261 -494 -87 -300 123 -463
386 378 486 -443 -64 299

Output for the Sample Input 3

0
2
1
3
0



Sample input:
5 1
0 10 0 5 2
0 20 0 5 12
0 30 0 5 22
0 40 0 5 32
0 50 0 5 42
0 0 0 0 60 0


Sample output:
110

Submission status: Wrong Answer

Solution code:
N, Q = map(int, raw_input().split())
obj = [map(int, raw_input().split()) for i in xrange(N)]

for loop in xrange(Q):
    sx, sy, sz, dx, dy, dz = map(int, raw_input().split())
    vx, vy, vz = dx - sx, dy - sy, dz - sz
    cost = 0
    for x, y, z, r, l in obj:
        t = 1.0 * (vx * (x - sx) + vy * (y - sy) + vz * (z - sz)) / (vx * vx + vy * vy + vz * vz)
        tx, ty, tz = sx + vx * t, sy + vy * t, sz + vz * t
        d = (x - tx) ** 2 + (y - ty) ** 2 + (z - tz) ** 2
        if d <= r * r:
            cost += l
    print cost

Submission status: Wrong Answer

Solution code:
def dist2(ax, ay, az, bx, by, bz):
    return (ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2

def judge(d1, d2, d3):
    d1, d2, d3 = sorted([d1, d2, d3])
    return d1 + d2 <= d3
    
N, Q = map(int, raw_input().split())
obj = [map(int, raw_input().split()) for i in xrange(N)]

for loop in xrange(Q):
    sx, sy, sz, dx, dy, dz = map(int, raw_input().split())
    vx, vy, vz = dx - sx, dy - sy, dz - sz
    d1 = dist2(sx, sy, sz, dx, dy, dz)
    cost = 0
    for x, y, z, r, l in obj:
        d2, d3 = dist2(x, y, z, sx, sy, sz), dist2(x, y, z, dx, dy, dz)
        if not judge(d1, d2, d3): continue
        t = 1.0 * (vx * (x - sx) + vy * (y - sy) + vz * (z - sz)) / (vx * vx + vy * vy + vz * vz)
        tx, ty, tz = sx + vx * t, sy + vy * t, sz + vz * t
        d = dist2(x, y, z, tx, ty, tz)
        if d <= r * r:
            cost += l
    print cost

Submission status: Wrong Answer

Solution code:
from math import sqrt
def dist2(ax, ay, az, bx, by, bz):
    return (ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2

def judge(d1, d2, d3):
    e1, e2, e3 = sqrt(d1), sqrt(d2), sqrt(d3)
    cos1 = (d1 + d2 - d3) / (2 * e1 * e2)
    cos2 = (d1 + d3 - d2) / (2 * e1 * e3)
    return (0 <= cos1 and 0 <= cos2)
    
N, Q = map(int, raw_input().split())
obj = [map(int, raw_input().split()) for i in xrange(N)]

for loop in xrange(Q):
    sx, sy, sz, dx, dy, dz = map(int, raw_input().split())
    vx, vy, vz = dx - sx, dy - sy, dz - sz
    d1 = dist2(sx, sy, sz, dx, dy, dz)
    cost = 0
    for x, y, z, r, l in obj:
        d2, d3 = dist2(x, y, z, sx, sy, sz), dist2(x, y, z, dx, dy, dz)
        if not judge(d1, d2, d3): continue
        t = 1.0 * (vx * (x - sx) + vy * (y - sy) + vz * (z - sz)) / (vx * vx + vy * vy + vz * vz)
        tx, ty, tz = sx + vx * t, sy + vy * t, sz + vz * t
        d = dist2(x, y, z, tx, ty, tz)
        if d <= r * r:
            cost += l
    print cost

Submission status: Wrong Answer

Solution code:
from math import sqrt
def dist2(ax, ay, az, bx, by, bz):
    return (ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2

N, Q = map(int, raw_input().split())
obj = [map(int, raw_input().split()) for i in xrange(N)]

for loop in xrange(Q):
    sx, sy, sz, dx, dy, dz = map(int, raw_input().split())
    d1 = dist2(sx, sy, sz, dx, dy, dz)
    vx, vy, vz = dx - sx, dy - sy, dz - sz
    cost = 0
    for x, y, z, r, l in obj:
        d2, d3 = dist2(x, y, z, sx, sy, sz), dist2(x, y, z, dx, dy, dz)
        if not d2 + d3 <= d1: continue
        t = 1.0 * (vx * (x - sx) + vy * (y - sy) + vz * (z - sz)) / (vx * vx + vy * vy + vz * vz)
        tx, ty, tz = sx + vx * t, sy + vy * t, sz + vz * t
        d = dist2(x, y, z, tx, ty, tz)
        if d <= r * r + 1e-9:
            cost += l
    print cost

Submission status: Wrong Answer

Solution code:
from math import sin, acos
N, Q = map(int, input().split())
obs = [tuple(map(int, input().split())) for _ in range(N)]
def dist(v):
    return sum(x ** 2 for x in v)

def cos(v1, v2):
    return sum(x * y for x, y in zip(v1, v2)) / pow(dist(v1), 0.5) / pow(dist(v2), 0.5)


for _ in range(Q):
    sx, sy, sz, dx, dy, dz = map(int, input().split())
    v_oa = (dx - sx, dy - sy, dz - sz)
    ans = 0
    for x, y, z, r, l in obs:
        v_or = (x - sx, y - sy, z - sz)
        # print(pow(dist(v_or), 0.5), sin(acos(cos(v_or, v_oa))), abs(pow(dist(v_or), 0.5) * sin(acos(cos(v_or, v_oa)))), r + 1e-9)
        if abs(pow(dist(v_or), 0.5) * sin(acos(cos(v_or, v_oa)))) <= r + 1e-9:
            ans += l
    print(ans)

Submission status: Wrong Answer

Solution code:
from math import sin, acos
N, Q = map(int, input().split())
obs = [tuple(map(int, input().split())) for _ in range(N)]
def dist(v):
    return sum(x ** 2 for x in v)

def cos(v1, v2):
    return sum(x * y for x, y in zip(v1, v2)) / pow(dist(v1), 0.5) / pow(dist(v2), 0.5)


for _ in range(Q):
    sx, sy, sz, dx, dy, dz = map(int, input().split())
    v_oa = (dx - sx, dy - sy, dz - sz)
    ans = 0
    for x, y, z, r, l in obs:
        v_or = (x - sx, y - sy, z - sz)
        # print(pow(dist(v_or), 0.5), sin(acos(cos(v_or, v_oa))), abs(pow(dist(v_or), 0.5) * sin(acos(cos(v_or, v_oa)))), r + 1e-9)
        if cos(v_or, v_oa) >= 0 and abs(pow(dist(v_or), 0.5) * sin(acos(cos(v_or, v_oa)))) <= r + 1e-9:
            ans += l
    print(ans)

Submission status: Accepted

Solution code:
from math import sqrt
def dist2(ax, ay, az, bx, by, bz):
    return (ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2

def judge(d1, d2, d3):
    e1, e2, e3 = sqrt(d1), sqrt(d2), sqrt(d3)
    cos1 = (d1 + d2 - d3) / (2 * e1 * e2)
    cos2 = (d1 + d3 - d2) / (2 * e1 * e3)
    return (0 <= cos1 and 0 <= cos2)
    
N, Q = map(int, raw_input().split())
obj = [map(int, raw_input().split()) for i in xrange(N)]

for loop in xrange(Q):
    sx, sy, sz, dx, dy, dz = map(int, raw_input().split())
    vx, vy, vz = dx - sx, dy - sy, dz - sz
    d1 = dist2(sx, sy, sz, dx, dy, dz)
    cost = 0
    for x, y, z, r, l in obj:
        d2, d3 = dist2(x, y, z, sx, sy, sz), dist2(x, y, z, dx, dy, dz)
        if not judge(d1, d2, d3): continue
        t = 1.0 * (vx * (x - sx) + vy * (y - sy) + vz * (z - sz)) / (vx * vx + vy * vy + vz * vz)
        tx, ty, tz = sx + vx * t, sy + vy * t, sz + vz * t
        d = dist2(x, y, z, tx, ty, tz)
        if d <= r * r + 1e-9:
            cost += l
    print cost

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n,q = LI()
    a = [LI() for _ in range(n)]
    b = [LI() for _ in range(q)]
    rr = []

    def k(a,b):
        return sum([(a[i]-b[i]) ** 2 for i in range(3)]) ** 0.5

    def f(a,b,c,r):
        ab = k(a,b)
        ac = k(a,c)
        bc = k(b,c)
        if ac <= r or bc <= r:
            return True
        at = (ac ** 2 - r ** 2)
        bt = (bc ** 2 - r ** 2)
        t = max(at,0) ** 0.5 + max(bt,0) ** 0.5
        return ab >= t - eps

    for x1,y1,z1,x2,y2,z2 in b:
        tr = 0
        ta = (x1,y1,z1)
        tb = (x2,y2,z2)
        for x,y,z,r,l in a:
            if f(ta,tb,(x,y,z),r):
                tr += l
        rr.append(tr)

    return '\n'.join(map(str,rr))


print(main())

Submission status: Accepted

Solution code:
eps = 1.0 / 10**10
def LI(): return [int(x) for x in input().split()]

def main():
    n,q = LI()
    na = [LI() for _ in range(n)]
    qa = [LI() for _ in range(q)]
    rr = []

    def k(a,b):
        return sum([(a[i]-b[i]) ** 2 for i in range(3)]) ** 0.5

    def f(a,b,c,r):
        ab = k(a,b)
        ac = k(a,c)
        bc = k(b,c)
        if ac <= r or bc <= r:
            return True
        at = (ac ** 2 - r ** 2) ** 0.5
        bt = (bc ** 2 - r ** 2) ** 0.5
        return ab >= at + bt - eps

    for x1,y1,z1,x2,y2,z2 in qa:
        tr = 0
        for x,y,z,r,l in na:
            if f((x1,y1,z1),(x2,y2,z2),(x,y,z),r):
                tr += l
        rr.append(tr)

    return '\n'.join(map(str,rr))


print(main())

Submission status: Accepted

Solution code:
import math

def sub(a, b):
    return [x-y for x,y in zip(a,b)]

def dot(a, b):
    return sum(x*y for x,y in zip(a,b))

def cross(a, b):
    return [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]]

def abs2(a):
    return sum([x*x for x in a])

def deg(a, b):
    return (math.acos(dot(a,b)/math.sqrt(abs2(a)*abs2(b))))

N,Q = map(int,input().split())
ls = [list(map(int,input().split())) for i in range(N)]

for i in range(Q):
    sx,sy,sz,dx,dy,dz = map(int,input().split())
    cost = 0
    s = [sx,sy,sz]
    d = [dx,dy,dz]
    sd = sub(d,s)
    ds = sub(s,d)
    for v in ls:
        if abs(deg(sub(v[:3],s),sd)) < math.pi/2 and abs(deg(sub(v[:3],d), ds)) < math.pi/2:
            if abs2(cross(sub(v[:3],s),sd)) <= abs2(sd)*v[3]**2:
                cost += v[4]
        else:
            if min(abs2(sub(v[:3],s)), abs2(sub(v[:3],d))) <= v[3]**2:
                cost += v[4]
    print(cost)

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LS()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    n = I()
    s = 0
    ans = "YES"
    for i in range(n):
        k = input()
        if k == "Un":
            s -= 1
        else:
            s += 1
        if s < 0:
            ans = "NO"
    if s:
        print("NO")
    else:
        print(ans)
    return

#B
def B():
    return

#C
def C():
    n,q = LI()
    p = LIR(n)
    for _ in range(q):
        x0,y0,z0,s,t,u = LI()
        a,b,c = (s-x0,t-y0,u-z0)
        ans = 0
        su = a**2+b**2+c**2
        for xr,yr,zr,r,l in p:
            x = (su-a**2)/su*x0-a/su*(b*y0+c*z0-a*xr-b*yr-c*zr)
            y = (su-b**2)/su*y0-b/su*(a*x0+c*z0-a*xr-b*yr-c*zr)
            z = (su-c**2)/su*z0-c/su*(b*y0+a*x0-a*xr-b*yr-c*zr)
            if min(x0,s)-1e-4 <= x <= max(x0,s)+1e-4 and min(y0,t)-1e-4 <= y <= max(y0,t)+1e-4 and min(z0,u)-1e-4 <= z <= max(z0,u)+1e-4:
                x -= xr
                y -= yr
                z -= zr
                r2 = x**2+y**2+z**2
                if r2 <= r**2+1e-4:
                    ans += l
        print(ans)
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#I
def I_():
    return

#J
def J():
    return

#Solve
if __name__ == "__main__":
    C()

Submission status: Accepted

Solution code:
N, Q = map(int, input().split())
x = [None] * N
y = [None] * N
z = [None] * N
r = [None] * N
l = [None] * N
for i in range(N):
    x[i], y[i], z[i], r[i], l[i] = map(int, input().split())

for _ in range(Q):
    ans = 0
    sx, sy, sz, dx, dy, dz = map(int, input().split())
    vx = dx - sx
    vy = dy - sy
    vz = dz - sz
    for i in range(N):
        t = 0
        t += vx * (x[i] - sx)
        t += vy * (y[i] - sy)
        t += vz * (z[i] - sz)
        t /= vx**2 + vy**2 + vz**2
        len2 = 0
        len2 += (sx + vx * t - x[i])**2
        len2 += (sy + vy * t - y[i])**2
        len2 += (sz + vz * t - z[i])**2
        if 0 < t < 1 and len2 <= r[i]**2 + 1e-9:
            ans += l[i]
    print(ans)