Problem:
Problem G:
天体観測
2012年のある日のこと。
北の田舎町に住むあなたは、愛娘を連れて展望台で星見をすることにした。
この町は都会と違って街明かりが少なく、空気も澄んでいるので、晴れた日は満天の星空が広がっている。
天文にそこそこ詳しいあなたは季節ごとの有名な星や星座、それにまつわる神話ぐらいは知っているのだが、
なにせここは星降る町、名前のわからない星座もたくさん見えている。
この前の星見のときにそういった星々に関する娘の質問に答えられなかったあなたは、
星見の時刻にいったいどの星座が見えるのかを調べたいと思った。
特定の日時にどの星が見えるのかを知るには、星座早見盤というアイテムが有用である。
最近では携帯端末のGPSと連携した星座早見盤アプリも提供されている。
だが、あいにくあなたの手元には星座早見盤がなく、携帯は七年前の機種で、最新のアプリが動くわけがなかった。
詰んだと思ったあなたが最後の望みをかけてハードディスクを漁ったところ、
なんと2012年1月1日の午前零時時点での各星座を構成する星々の位置を記したファイルを発見した。
これがあれば任意の日時の星の位置がわかるはず！
あなたは急いでどの星座が見えるのかを出力するプログラムを書くことにした。
星々の情報は、観測者を中心とした天球上の座標群として与えられている。
座標は方位角と高度のペアで表されている。
方位角は真北を0度、真東を90度というように時計回りに測った0度以上360度未満の角度であり、
高度は地平線上を0度、天頂を90度度、天底を-90度とした-90度以上90度以下の角度である。
各天体は北極星と観測者を結ぶ直線を回転軸として、天球上を一定速度で反時計回りに回転している。
その回転速度は24時間あたり(1+1/365.24)×360度である。
北極星は真北方向の高度43.2度の点にある。
ある星座が見えるとは、その星座を構成するすべての星が地平線より上にあることをいう。
テストデータにおいて、当該時刻に地平線から高度±0.01度以内に星があることはないとしてよい。
なお、地軸のズレ、天体との距離などは考えなくてよい。
また、2012年は閏年であることに注意せよ。
Input
入力は以下のような形式で与えられる。
mon
/
day
hh
:
mm
n
name
1
m
1
a
11
h
11
a
12
h
12
...
a
1m
1
h
1m
1
name
2
m
2
a
21
h
21
...
一行目には星見をする2012年のある日時が24時制で与えられる。
二行目の
n
は見えるかどうか判定したい星座の数を表す。
残りの行はその
n
個の星座の2012年1月1日 00:00時点での位置情報である。
各星座の情報の先頭行には、星座名
name
i
と星座を構成する星の数
m
i
が与えられる。
続く
m
i
行に、各星の方位角
a
ij
と高度
h
ij
が与えられる。
これらの二つの数値は小数点以下三桁まで記述された浮動小数点数である。
入力の数値は、1 ≤
n
≤ 1000、1 ≤
m
i
≤ 1000、0.000 ≤
a
ij
< 360.000、-90.000 ≤
h
ij
≤ 90.000を満たす。
また、星座名はアルファベットの大文字小文字からなり、長さが50文字を超えることはない。
サンプルにあるとおり、「夏の大三角」や「北斗七星」など、88星座に入っていないものが与えられることもある。
なお、時刻は日没後の時刻とはかぎらないが、気にせず星が見えるものとしてよい。
Output
入力に与えられた順に、指定された日時に見える星座の一覧を出力せよ。
一つも星座が見えないようなテストデータはないと仮定してよい。
Notes on Test Cases
上記入力形式で複数のデータセットが与えられます。
入力の1行目にデータセットの数Tが与えられます。
各データセットに対して上記出力形式で出力を行うプログラムを作成して下さい。
Sample Input
3
7/7 18:30
3
Aquila 8
359.216 -32.936
358.624 -49.913
352.155 -43.404
346.852 -35.279
345.110 -36.796
342.448 -44.407
343.088 -38.981
336.070 -43.369
Cygnus 11
357.838 6.615
355.808 5.107
353.475 -18.553
348.868 -10.771
347.949 1.298
344.907 -4.637
342.909 1.163
338.483 -9.293
338.854 -1.786
338.515 1.304
331.752 -10.737
Lyra 4
5.063 -7.812
2.708 -13.386
1.327 -2.841
0.815 -14.109
9/3 02:40
3
SevenStars 7
40.483 50.729
48.968 50.637
50.421 42.796
44.855 40.960
43.493 35.637
42.111 31.430
44.997 25.256
SummerTriangle 3
342.909 1.163
345.110 -36.796
5.063 -7.812
WinterTriangle 3
165.368 51.176
207.400 51.262
184.960 31.381
7/7 19:00
91
Andromeda 25
300.224 10.559
313.114 22.235
304.593 17.311
305.145 18.508
299.557 18.169
295.825 15.561
296.928 16.703
290.573 13.699
304.020 24.766
300.872 24.287
296.636 24.636
304.470 32.153
303.783 32.893
298.697 32.261
306.181 35.986
296.619 37.096
301.005 41.728
319.394 10.944
323.303 16.879
313.853 10.187
313.295 13.504
317.463 18.294
315.012 16.124
315.502 17.165
316.369 19.322
Antila 5
150.199 5.822
143.663 11.282
144.808 2.868
138.069 2.334
136.680 -6.080
Apus 6
159.498 -45.403
165.358 -47.196
157.404 -51.717
166.529 -52.133
167.065 -52.812
162.765 -60.430
Aquarius 28
318.790 -48.408
321.209 -45.287
318.270 -46.509
310.269 -47.366
305.6
...(truncated)

Submitted solutions:

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e18;
const double PI = acos(-1);

bool epsleq(const double &a, const double &b){
    return a +EPS < b;
}
bool epseq(const double &a, const double &b){
    return abs(a-b) < EPS;
}

struct Point{
    double x,y,z;
    Point(double x, double y, double z):x(x), y(y), z(z){}
    Point(){}
    Point &operator +=(const Point &a){ x+=a.x; y+=a.y; z+=a.z; return *this; }
    Point &operator -=(const Point &a){ x-=a.x; y-=a.y; z-=a.z; return *this; }
    Point &operator *=(const double &a){ x*=a; y*=a; z*=a; return *this; }
    Point operator +(const Point &a) const{ return Point(x+a.x, y+a.y, z+a.z); }
    Point operator -(const Point &a) const{ return Point(x-a.x, y-a.y, z-a.z); }
    Point operator *(const double &a) const{ return Point(a*x, a*y, a*z); }
    Point operator -() { return Point(-x, -y, -z); }
    bool operator <(const Point &a) const{
        return !epseq(x, a.x)? x < a.x: !epseq(y, a.y)? y < a.y: epsleq(z, a.z);
    }
    bool operator ==(const Point &a) const{
        double dx=x-a.x, dy=y-a.y, dz=z-a.z;
        return sqrt(dx*dx +dy*dy +dz*dz) < EPS;
    }
};

double dot(const Point &a, const Point &b){
    return a.x*b.x +a.y*b.y +a.z*b.z;
}
Point cross(const Point &a, const Point &b){
    return Point(a.y*b.z -a.z*b.y, a.z*b.x -a.x*b.z, a.x*b.y -a.y*b.x);
}
double abs(const Point &a){
    return sqrt(dot(a, a));
}
Point unit(const Point &a){
    return a *(1/abs(a));
}

Point rotate(const Point &p, const Point &axis, double angle){
    Point n = unit(axis);
    double SIN = sin(angle), COS = cos(angle);
    double vec[3] = {p.x, p.y, p.z};
    double mat[3][3] = {{COS +n.x*n.x*(1-COS), n.x*n.y*(1-COS) -n.z*SIN, n.x*n.z*(1-COS) +n.y*SIN},
                        {n.x*n.y*(1-COS) +n.z*SIN, COS +n.y*n.y*(1-COS), n.y*n.z*(1-COS) -n.x*SIN},
                        {n.x*n.z*(1-COS) -n.y*SIN, n.y*n.z*(1-COS) +n.x*SIN, COS +n.z*n.z*(1-COS)}};
    double ret[3] = {};
    for(int i=0; i<3; i++){
        for(int j=0; j<3; j++){
            ret[i] += mat[i][j] *vec[j];
        }
    }
    return Point(ret[0], ret[1], ret[2]);
}

int md[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

int main(){
    int ds;
    cin >> ds;
    for(int rep=0; rep<ds; rep++){
        int mon,day,hh,mm;
        scanf("%d/%d %d:%d", &mon, &day, &hh, &mm);
        for(int i=0; i<mon-1; i++){
            day += md[i];
        }
        mm += 60 *(24*(day-1) +hh);
        
        double angle = (1+1/365.24)*360 *mm/24/60 *PI/180;

        vector<string> ans;
        Point pole(cos(43.2/180*PI), 0, sin(43.2/180*PI));
        int n;
        cin >> n;
        for(int i=0; i<n; i++){
            string name;
            int size;
            cin >> name >> size;
            bool canlook = true;
            for(int j=0; j<size; j++){
                double theta, phi;
                cin >> theta >> phi;
                theta *= PI/180;
                phi *= PI/180;
                Point p(cos(theta)*cos(phi), sin(theta)*cos(phi), sin(phi));
                p = rotate(p, pole, angle);
                if(p.z < 0){
                    canlook = false;
                }
            }
            if(canlook){
                ans.push_back(name);
            }
        }
        for(string s: ans){
            cout << s << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3736
final_rank: 8

code_snippet: #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 1000;
const int MAX_M = 1000;

const double NP_DEG = 43.2;
const double RDPM = (1.0 + 1.0 / 365.24) * 360 / (24 * 60);

const double PI = acos(-1.0);
const double DELTA = sin(0.01 * PI / 180);

const int mdays[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

/* typedef */

template <typename T>
struct Pt3D {
  T x, y, z;

  Pt3D() {}
  Pt3D(T _x, T _y, T _z) { x = _x; y = _y; z = _z; }

  bool operator==(const Pt3D<T>& pt) const {
    return x == pt.x && y == pt.y && z == pt.z;
  }

  bool operator<(const Pt3D<T>& pt) const {
    return x < pt.x || (x == pt.x && (y < pt.y || (y == pt.y && z < pt.z)));
  }
  
  Pt3D<T> operator+(const Pt3D<T>& pt) const {
    return Pt3D<T>(x + pt.x, y + pt.y, z + pt.z);
  }

  Pt3D<T> operator-(const Pt3D<T>& pt) const {
    return Pt3D<T>(x - pt.x, y - pt.y, z - pt.z);
  }
  
  Pt3D<T> operator-() const { return Pt3D<T>(-x, -y, -z); }
  Pt3D<T> operator*(const T& t) const { return Pt3D<T>(x * t, y * t, z * t); }
  Pt3D<T> operator/(const T& t) const { return Pt3D<T>(x / t, y / t, z / t); }

  T dot(const Pt3D<T>& v) const { return x * v.x + y * v.y + z * v.z; }

  Pt3D<T> cross(const Pt3D<T>& v) const {
    return Pt3D<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
  }

  T d2() const { return x * x + y * y + z * z; }
  double d() const { return sqrt(d2()); }
  Pt3D<T> normalize() const { return *this / d(); }

  Pt3D<T> rotx(double th) {
    double c = cos(th), s = sin(th);
    return Pt3D<T>(x, c * y - s * z, s * y + c * z);
  }
  
  Pt3D<T> roty(double th) {
    double c = cos(th), s = sin(th);
    return Pt3D<T>(s * z + c * x, y, c * z - s * x);
  }
  
  Pt3D<T> rotz(double th) {
    double c = cos(th), s = sin(th);
    return Pt3D<T>(c * x - s * y, s * x + c * y, z);
  }
  
  void print(string format) {
    printf(("(" + format + ", " + format + ", " + format + ")\n").c_str(),
           x, y, z);
  }
  void print() { print("%.6lf"); }
};

typedef Pt3D<double> pt3d;

/* global variables */

/* subroutines */

int datetime2min(string md, string hm) {
  int m = 0, d = 0, pos = 0;

  while (md[pos] != '/') m = m * 10 + (md[pos++] - '0');
  pos++;
  while (pos < md.length()) d = d * 10 + (md[pos++] - '0');

  int hh = (hm[0] - '0') * 10 + (hm[1] - '0');
  int mm = (hm[3] - '0') * 10 + (hm[4] - '0');
  //printf("%d/%d %02d:%02d\n", m, d, hh, mm);

  int doy = d;
  for (int i = 2; i <= m; i++) doy += mdays[i - 2];
  
  return (((doy - 1) * 24) + hh) * 60 + mm;
}

/* main */

int main() {
  double dth = PI * (90.0 - NP_DEG) / 180;

  int tn;
  cin >> tn;

  while (tn--) {
    string md, hm;
    cin >> md >> hm;

    int min = datetime2min(md, hm);
    double dphi = -PI * RDPM / 180 * min;
    
    int n, m;
    string name;
    cin >> n;

    while (n--) {
      cin >> name >> m;

      bool ok = true;

      while (m--) {
	double d0, d1;
	cin >> d0 >> d1;

	if (ok) {
	  double phi = (90.0 - d0) * PI / 180;
	  double th = d1 * PI / 180;

	  double cp = cos(phi), sp = sin(phi);
	  double ct = cos(th), st = sin(th);

	  pt3d p0(cp * ct, sp * ct, st);
	  pt3d p1 = p0.rotx(dth).rotz(dphi).rotx(-dth);

	  if (p1.z <= DELTA) ok = false;
	  //cout << name << ": ";p1.print();
	}
      }

      if (ok) cout << name << endl;
    }
  }

  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 1244
final_rank: 3

code_snippet: #include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)

using namespace std;

double calc(int m, int d, int hh, int mm) {
    vector<int> days(13, 31);
    days[0] = 0;
    days[2] = 29;
    for(int i : {4, 6, 9, 11}) {
        days[i] = 30;
    }
    for(int i = 2; i <= 12; i++) {
        days[i] += days[i - 1];
    }
    d += days[m - 1];
    return (d - 1) + hh / 24.0 + mm / (24.0 * 60.0);
}

void rotate(double th, double &a, double &b) {
    double na =  cos(th) * a + -sin(th) * b;
    double nb =  sin(th) * a + cos(th) * b;
    a = na;
    b = nb;
}

double to_radian(double degree) {
    return degree / 180.0 * M_PI;
}
void make(double a, double b, double& x, double& y, double& z) {
    x = cos(a);
    y = sin(a);
    z = tan(b);
}

const double EPS = 1e-8;

int main(){
    int T;
    cin >> T;
    for(int casenum = 0; casenum < T; casenum++){
        int mon, day, hh, mm;
        scanf("%d/%d", &mon, &day);
        scanf("%d:%d", &hh, &mm);
        double theta = to_radian( (1.0 + 1.0 / 365.24) * 360.0 * calc(mon, day, hh, mm) );
        const double P = to_radian( 43.2 );
        int n;
        cin >> n;
        for(int i = 0; i < n; i++) {
            string name;
            int m;
            cin >> name >> m;
            bool ok = true;
            // cout << name << endl;
            for(int j = 0; j < m; j++) {
                double a, b;
                cin >> a >> b;
                double x, y, z;
                make(to_radian(a), to_radian(b), x, y, z);
                // printf("(%f, %f, %f)\n", x, y, z);
                rotate(-P, x, z);
                // printf("->(%f, %f, %f)\n", x, y, z);
                rotate(theta, y, z);
                // printf("->(%f, %f, %f)\n", x, y, z);
                rotate(P, x, z);
                // printf("->(%f, %f, %f)\n", x, y, z);
                if(z < 0.0 + EPS) {
                    ok = false;
                }
            }
            if(ok) {
                cout << name << endl;
            }
        }
    }
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 1344
final_rank: 4

code_snippet: #include<cmath>
#include<cstdio>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;

const double PI=acos(-1);

template<class T>
struct point3{
	T x,y,z;
	point3 operator+(const point3 &a)const{ return (point3){x+a.x,y+a.y,z+a.z}; }
};

template<class T>
point3<T> operator*(T c,const point3<T> &a){
	return (point3<T>){c*a.x,c*a.y,c*a.z};
}

template<class T>
T dot(const point3<T> &a,const point3<T> &b){ return a.x*b.x+a.y*b.y+a.z*b.z; }

template<class T>
point3<T> cross(const point3<T> &a,const point3<T> &b){
	return (point3<T>){a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x};
}

// 2012 N 1  1 ú 0:00 ©ç 2012 N mon  day ú hh:mm ÜÅÌoßÔ
double calc_hours(int mon,int day,int hh,int mm){
	const int a[]={-1,31,29,31,30,31,30,31,31,30,31,30,31};
	int d=day-1;
	for(int i=1;i<mon;i++) d+=a[i];
	return 24*d+hh+mm/60.0;
}

// xNg p ð² a ÜíèÉ t [rad] ¾¯ñ]µ½xNgðßé
point3<double> rot(const point3<double> &p,const point3<double> &a,double t){
	return cos(t)*p+(1-cos(t))*dot(p,a)*a+sin(t)*cross(a,p);
}

int n; // ¯Ì
double lat[1000],lon[1000]; // Üx, ox

bool check(double h){
	// x ²³Ìûü 43.2 xÉkÉ¯ª éÆµÄ¢é
	point3<double> a={cos(43.2*PI/180),0,sin(43.2*PI/180)}; // ñ]²
	rep(i,n){
		// ¯ i ÌûüxNg
		point3<double> p={cos(lon[i])*cos(lat[i]),sin(lon[i])*cos(lat[i]),sin(lat[i])};
		if(rot(p,a,(1+1/365.24)*2*PI*h/24).z<0) return false;
	}
	return true;
}

int main(){
	int T; scanf("%d",&T);
	while(T--){
		int mon,day,hh,mm;
		scanf("%d/%d%d:%d",&mon,&day,&hh,&mm);
		double h=calc_hours(mon,day,hh,mm);

		int q; scanf("%d",&q);
		while(q--){
			char name[64];
			scanf("%s%d",name,&n);
			rep(i,n){
				scanf("%lf%lf",lon+i,lat+i);
				lon[i]*=PI/180;
				lat[i]*=PI/180;
			}
			if(check(h)) puts(name);
		}
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 0
final_rank: 1

code_snippet: #include<iostream>
#include<cmath>
#include<complex>
#include<iomanip>
#include<cassert>
#include<vector>
#include<ctime>
#include<string>
#include<cstdio>
 
using namespace std;
 
enum CCW{FRONT=0x01,RIGHT=0x02,BACK=0x04,LEFT=0x08,OVER=0x10};
typedef double elem;
typedef complex<elem> point2, vec2;
typedef pair<point2,point2> line2, seg2;
 
const elem eps = 1e-5;
const elem pi = 2*acos(0);
const elem infty = 1e50;

struct point3{
  elem x,y,z;
  point3(){}
  point3(elem x, elem y, elem z):x(x),y(y),z(z){}
  point3 operator+(const point3 &d)const{
    return point3(x+d.x,y+d.y,z+d.z);
  }
  point3 operator-(const point3 &d)const{
    return point3(x-d.x,y-d.y,z-d.z);
  }
  point3 operator*(elem d)const{
    return point3(x*d,y*d,z*d);
  }
  elem len()const{
    return sqrt(x*x + y*y + z*z);
  }
  point3 unit()const{
    double n = this->len();
    return point3(x/n,y/n,z/n);
  }
  elem dot(const point3 &d)const{
    return x*d.x + y*d.y + z*d.z;
  }
  point3 cross(const point3& d)const{
    return point3(y*d.z-z*d.y,z*d.x-x*d.z,x*d.y-y*d.x);
  }
  point3 rot(const point3 &u, double theta)
  {
    double cs = cos(theta);
    double ss = sin(theta);
    double r11 = cs + u.x * u.x * (1-cs);
    double r12 = u.x * u.y * (1-cs) - u.z * ss;
    double r13 = u.x * u.z * (1-cs) + u.y * ss;
    double r21 = u.y * u.x * (1-cs) + u.z * ss;
    double r22 = cs + u.y * u.y * (1-cs);
    double r23 = u.y * u.z * (1-cs) - u.x * ss;
    double r31 = u.z * u.x * (1-cs) - u.y * ss;
    double r32 = u.z * u.y * (1-cs) + u.x * ss;
    double r33 = cs + u.z * u.z * (1-cs);

    point3 ret;
    ret.x = r11 * x + r12 * y + r13 * z;
    ret.y = r21 * x + r22 * y + r23 * z;
    ret.z = r31 * x + r32 * y + r33 * z;
    return ret;
  }
};

struct Stella{
  string name;
  vector<point3> v;
  void rot(const point3 &u, double theta){
    //cout << name << endl;
    for(int i = 0; i < (int)v.size(); ++i){
      point3 t = v[i].rot(u,theta);
      //cout << t.x << ' ' << t.y << ' ' << t.z << endl;
      v[i] = v[i].rot(u,theta);
    }
  }
  bool visible()const{
    for(int i = 0; i < (int)v.size(); ++i){
      if( v[i].z < 0 ) return false;
    }
    return true;
  }
};

double deg2rad(double deg){return deg/180.0 * pi;}
point2 rot(point2 p, elem theta){ return p * polar((elem)1.0, theta); }
point3 conv(double l,double r)
{
  l = deg2rad(l);
  r = deg2rad(r);
  point3 t(0,1,0); // 0,0
  point3 ret = t.rot(point3(0,0,1),deg2rad(360-l));
  //point3 ret = t.rot(point3(0,0,1),deg2rad(l));
  ret = ret.rot(point3(1,0,0),deg2rad(r));
  return point3(sin(l)*cos(r),sin(l)*sin(r),cos(l));
  //return ret;
}

const double unit24 = (1+1./365.24)*360;

int main()
{
  int T;
  cin >> T;
  for(int tc=1;tc<=T;++tc){
    int mon,day,h,m;
    char dam;
    struct tm time_base;
    struct tm time_cur;
    point3 pole = conv(90-43.2,90);
    
    time_base.tm_year = 2012 - 1900;
    time_base.tm_mon = 1 - 1;
    time_base.tm_mday = 1;
    time_base.tm_hour = 0;
    time_base.tm_min = 0;
    time_base.tm_sec = 0;
    time_base.tm_isdst = -1;
    
    cin >> mon >> dam >> day >> h >> dam >> m;
    // cout << mon << ' ' << day << ' ' << h << ' ' << m << endl;

    time_cur.tm_year = 2012 - 1900;
    time_cur.tm_mon = mon - 1;
    time_cur.tm_mday = day;
    time_cur.tm_hour = h;
    time_cur.tm_min = m;
    time_cur.tm_sec = 0;
    time_cur.tm_isdst = -1;
    
    time_t base1 = mktime(&time_base);
    time_t cur1 = mktime(&time_cur);
    
    double elapsed_days = (cur1-base1)/(3600.*24);
    // cout << elapsed_days << endl;
    
    int n;
    cin >> n;
    vector< Stella > vs;
    for(int i = 0; i < n; ++i){
      Stella s;
      int k;
      cin >> s.name >> k;
      for(int j = 0; j < k; ++j){
        double l,r;
        cin >> l >> r;
        s.v.push_back(conv(90-r,90-l));
      }
      vs.push_back(s);
    }

    //cout << vs.size() << endl;
    double degree = (unit24) * elapsed_days;
    // while(degree>360)degree -= 360;
    for(int i = 0; i < (int)vs.size(); ++i){
      vs[i].rot( pole, -deg2rad(degree) );
    }
    for(int i = 0; i < (int)vs.size(); ++i){
      if( vs[i].visible() ){
        cout << vs[i].name << endl;
      }
    }
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 1100
final_rank: 6

code_snippet: #include<iostream>
#include<cmath>
#include<complex>
#include<iomanip>
#include<cassert>
#include<vector>
#include<ctime>
#include<string>
#include<cstdio>
 
using namespace std;
 
enum CCW{FRONT=0x01,RIGHT=0x02,BACK=0x04,LEFT=0x08,OVER=0x10};
typedef double elem;
typedef complex<elem> point2, vec2;
typedef pair<point2,point2> line2, seg2;
 
const elem eps = 1e-5;
const elem pi = 2*acos(0);
const elem infty = 1e50;

struct point3{
  elem x,y,z;
  point3(){}
  point3(elem x, elem y, elem z):x(x),y(y),z(z){}
  point3 operator+(const point3 &d)const{
    return point3(x+d.x,y+d.y,z+d.z);
  }
  point3 operator-(const point3 &d)const{
    return point3(x-d.x,y-d.y,z-d.z);
  }
  point3 operator*(elem d)const{
    return point3(x*d,y*d,z*d);
  }
  elem len()const{
    return sqrt(x*x + y*y + z*z);
  }
  point3 unit()const{
    double n = this->len();
    return point3(x/n,y/n,z/n);
  }
  elem dot(const point3 &d)const{
    return x*d.x + y*d.y + z*d.z;
  }
  point3 cross(const point3& d)const{
    return point3(y*d.z-z*d.y,z*d.x-x*d.z,x*d.y-y*d.x);
  }
  point3 rot(const point3 &u, double theta)
  {
    double cs = cos(theta);
    double ss = sin(theta);
    double r11 = cs + u.x * u.x * (1-cs);
    double r12 = u.x * u.y * (1-cs) - u.z * ss;
    double r13 = u.x * u.z * (1-cs) + u.y * ss;
    double r21 = u.y * u.x * (1-cs) + u.z * ss;
    double r22 = cs + u.y * u.y * (1-cs);
    double r23 = u.y * u.z * (1-cs) - u.x * ss;
    double r31 = u.z * u.x * (1-cs) - u.y * ss;
    double r32 = u.z * u.y * (1-cs) + u.x * ss;
    double r33 = cs + u.z * u.z * (1-cs);

    point3 ret;
    ret.x = r11 * x + r12 * y + r13 * z;
    ret.y = r21 * x + r22 * y + r23 * z;
    ret.z = r31 * x + r32 * y + r33 * z;
    return ret;
  }
};

struct Stella{
  string name;
  vector<point3> v;
  void rot(const point3 &u, double theta){
    //cout << name << endl;
    for(int i = 0; i < (int)v.size(); ++i){
      point3 t = v[i].rot(u,theta);
      //cout << t.x << ' ' << t.y << ' ' << t.z << endl;
      v[i] = v[i].rot(u,theta);
    }
  }
  bool visible()const{
    for(int i = 0; i < (int)v.size(); ++i){
      if( v[i].z < 0 ) return false;
    }
    return true;
  }
};

double deg2rad(double deg){return deg/180.0 * pi;}
point2 rot(point2 p, elem theta){ return p * polar((elem)1.0, theta); }
point3 conv(double l,double r)
{
  l = deg2rad(l);
  r = deg2rad(r);
  point3 t(0,1,0); // 0,0
  point3 ret = t.rot(point3(0,0,1),deg2rad(360-l));
  //point3 ret = t.rot(point3(0,0,1),deg2rad(l));
  ret = ret.rot(point3(1,0,0),deg2rad(r));
  return point3(cos(l)*cos(r),sin(l)*cos(r),sin(r));
  //return ret;
}

const double unit24 = (1+1./365.24)*360;

int main()
{
  int T;
  cin >> T;
  for(int tc=1;tc<=T;++tc){
    int mon,day,h,m;
    char dam;
    struct tm time_base;
    struct tm time_cur;
    point3 pole = conv(180,43.2);
    
    time_base.tm_year = 2012 - 1900;
    time_base.tm_mon = 1 - 1;
    time_base.tm_mday = 1;
    time_base.tm_hour = 0;
    time_base.tm_min = 0;
    time_base.tm_sec = 0;
    time_base.tm_isdst = -1;
    
    cin >> mon >> dam >> day >> h >> dam >> m;
    // cout << mon << ' ' << day << ' ' << h << ' ' << m << endl;

    time_cur.tm_year = 2012 - 1900;
    time_cur.tm_mon = mon - 1;
    time_cur.tm_mday = day;
    time_cur.tm_hour = h;
    time_cur.tm_min = m;
    time_cur.tm_sec = 0;
    time_cur.tm_isdst = -1;
    
    time_t base1 = mktime(&time_base);
    time_t cur1 = mktime(&time_cur);
    
    double elapsed_days = (cur1-base1)/(3600.*24);
    // cout << elapsed_days << endl;
    
    int n;
    cin >> n;
    vector< Stella > vs;
    for(int i = 0; i < n; ++i){
      Stella s;
      int k;
      cin >> s.name >> k;
      for(int j = 0; j < k; ++j){
        double l,r;
        cin >> l >> r;
        s.v.push_back(conv(180-l,r));
      }
      vs.push_back(s);
    }

    //cout << vs.size() << endl;
    double degree = (unit24) * elapsed_days;
    // while(degree>360)degree -= 360;
    for(int i = 0; i < (int)vs.size(); ++i){
      vs[i].rot( pole, -deg2rad(degree) );
    }
    for(int i = 0; i < (int)vs.size(); ++i){
      if( vs[i].visible() ){
        cout << vs[i].name << endl;
      }
    }
  }
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 1100
final_rank: 6

code_snippet: #include<iostream>
#include<vector>
#include<cmath>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
typedef long long ll;
const ll mod = 1000000;
const double pi = acos(-1);
double polar;

void rotate(double &x,double &y,double theta){
  double tx=x,ty=y;
  x=tx*cos(theta)-ty*sin(theta);
  y=tx*sin(theta)+ty*cos(theta);
}

double getAngle(int month,int day,int hour,int minute){
  static double unit=((1+1/365.24)*360)/(24*60);
  static int daylist[]={31,29,31,30,31,30,31,31,30,31,30,31};
  double daytotal=0;
  rep(i,12){
    if (month == i+1)break;
    daytotal+=daylist[i];
  }
  daytotal+=day-1;
  return (daytotal*60*24+hour*60+minute)*unit;
}

bool isok(vector<double> &x,vector<double> &y,vector<double> &z,double angle){
  int n=x.size();
  rep(i,n){
    rotate(x[i],z[i],pi/2-polar);
  }
  rep(i,n){
    rotate(x[i],y[i],angle);
  }
  rep(i,n){
    rotate(x[i],z[i],-(pi/2-polar));
  }
  //rep(i,n)cout << z[i] <<" ";cout << endl;

  rep(i,n){
    double ang=asin(z[i]);
    if (ang < 0.0)return false;
  }
  return true;
}

main(){
  polar=43.2/180*pi;
  int te;
  cin>>te;
  while(te--){
    int month,day,hour,minute;
    char dummy;
    cin>>month>>dummy>>day>>hour>>dummy>>minute;
    double angle=getAngle(month,day,hour,minute);
    angle=angle/180*pi;
    int n;
    cin>>n;
    rep(i,n){
      string name;int m;
      cin>>name>>m;
      vector<double> x(m),y(m),z(m);
      rep(j,m){
	double ang,h;
	cin>>ang>>h;
	ang=ang;
	ang=ang/180*pi;
	h=h/180*pi;
	z[j]=sin(h);
	x[j]=cos(h)*cos(ang);
	y[j]=cos(h)*sin(ang);
	//cout << sqrt(x[j]*x[j]+y[j]*y[j]+z[j]*z[j]) << endl;
      }
      //cout <<"check " << name << endl;
      if (isok(x,y,z,angle))cout << name << endl;
    }
    //cout <<"tc end " <<  endl << endl;
  }
  return false;
}
accuracy: 1
time_ms: 60
memory_kb: 988
final_rank: 9

code_snippet: #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <valarray>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
const double PI = 3.1415926535;

double rad(double d) {
  return d*PI/180;
}

typedef double number;
typedef valarray<number> point;

point coord(double R, double lon, double lat) {
  point res(3);
  res[0] = R*cos(lon)*sin(lat);
  res[1] = R*sin(lon)*sin(lat);
  res[2] = R*cos(lat);
  return res;
}
number dot(const point& a, const point& b) {
  return (a * b).sum();
}
point cross(const point& a, const point& b) {
  return a.cshift(+1)*b.cshift(-1)
       - a.cshift(-1)*b.cshift(+1);
}
// ツベツクツトツδ仰づ慊づュツづィツづ個嘉アツ転
point rotate(point axis, double ang, point a) {
  return a * cos(ang) + (1.0 - cos(ang)) * dot(a, axis) * axis + cross(axis, a) * sin(ang);
}

bool judge(double a, double h, double ang) {
  return (rotate(coord(1, 0, rad(46.8)), -ang, coord(10,-a,h))[2] >= 0);
}

int main() {
  int month[12] = {31,29,31,30,31,30,31,31,30,31,30,31};
  int T;
  cin >> T;
  while(T--) {
    int mon,day,hh,mm;
    scanf("%d/%d %d:%d",&mon,&day,&hh,&mm);
    int min = 0;
    REP(i, mon-1)
      min += month[i] * 24 * 60;
    min += (day-1) * 24 * 60 + hh * 60 + mm;
    double ang = rad((1.0+1.0/365.24) * 360 * min / (24 * 60));
//    cout << min << " " << ang << endl;
    //ang = mod(ang, (2*PI));
    int n;
    cin >> n;
    REP(i,n) {
      string name;
      cin >> name;
      int m;
      cin >> m;
      bool f = 1;
      REP(j,m) {
        double a,b;
        cin >> a >> b;
        b = 90.0 - b;
        if (!judge(rad(a), rad(b), ang)) {
          f = 0;
        }
      }
      if (f)
        cout << name <<endl;
    }
  }
}
accuracy: 1
time_ms: 60
memory_kb: 1008
final_rank: 10

code_snippet: #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
const double PI = 3.1415926535;

double rad(double d) {
  return d*PI/180;
}
struct P {
  double x,y,z;
  P(double x, double y, double z) :x(x), y(y), z(z) {}
};
// oxÆÜx©çÀWðvZBÌSª´_B
// lon : Ox©çÜíè
// lat : kÉ©çìÉûü
// oxOÜxOûüª²AoXOÜxOª²@kÉª²
double R = 10;
P coord(double lon, double lat) {
  double x = R*cos(lon)*sin(lat);
  double y = R*sin(lon)*sin(lat);
  double z = R*cos(lat);
  return P(x,y,z);
}
// O³Ìñ]sñðp¢½e²ñèÌñ]
P rotatex(P a, double ang) {
  return P(a.x, a.y*cos(ang)-a.z*sin(ang), a.y*sin(ang)+a.z*cos(ang));
}
P rotatey(P a, double ang) {
  return P(a.x*cos(ang)+a.z*sin(ang), a.y, -a.x*sin(ang)+a.z*cos(ang));
}
P rotatez(P a, double ang) {
  return P(a.x*cos(ang)-a.y*sin(ang), a.x*sin(ang)+a.y*cos(ang), a.z);
}
// lon, lat ÍãÆ¯¶
P rotate(P a, double lon, double lat, double ang) {
  P tmp = rotatey(rotatez(a,-lon),-lat);
  tmp = rotatez(tmp, -ang);
  tmp = rotatez(rotatey(tmp, lat), lon);
  return tmp;
}
bool judge(double a, double h, double ang) {
  return (rotate(coord(-a,h), 0, rad(46.8), ang).z >= 0);
}

int main() {
  int month[12] = {31,29,31,30,31,30,31,31,30,31,30,31};
  int T;
  cin >> T;
  while(T--) {
    int mon,day,hh,mm;
    scanf("%d/%d %d:%d",&mon,&day,&hh,&mm);
    int min = 0;
    REP(i, mon-1)
      min += month[i] * 24 * 60;
    min += (day-1) * 24 * 60 + hh * 60 + mm;
    double ang = rad((1.0+1.0/365.24) * 360 * min / (24 * 60));
//    cout << min << " " << ang << endl;
    //ang = mod(ang, (2*PI));
    int n;
    cin >> n;
    REP(i,n) {
      string name;
      cin >> name;
      int m;
      cin >> m;
      bool f = 1;
      REP(j,m) {
        double a,b;
        cin >> a >> b;
        b = 90.0 - b;
        if (!judge(rad(a), rad(b), ang)) {
          f = 0;
        }
      }
      if (f)
        cout << name <<endl;
    }
  }
}
accuracy: 1
time_ms: 50
memory_kb: 1004
final_rank: 5

code_snippet: #include<stdio.h>
#include <math.h>
#include <vector>
#include <string>

std::vector<std::string> ans;

void starCalc(int n,double round){
	int m;
	char name[51];
	double er,nr,x,y,z,x1,y1,z1;
	double c1,s1;
	double c2,s2;
	c1=cos(43.2/180.0*M_PI);
	s1=sin(43.2/180.0*M_PI);
	c2=cos(round/180.0*M_PI);
	s2=sin(round/180.0*M_PI);
	
	bool seeInOK;
	for(int i=0;i<n;i++){
		scanf("%s %d",name,&m);
		seeInOK=true;
		for(int j=0;j<m;j++){
			scanf("%lf %lf",&er,&nr);
			if(seeInOK==false) continue;
			x=cos(nr/180.0*M_PI);
			z=sin(nr/180.0*M_PI);
			y=0;
			
			x1=x*cos(er/180.0*M_PI);
			y1=-x*sin(er/180.0*M_PI);
			z1=z;
			x=x1;y=y1;z=z1;
			
			x1=x*c1+z*s1;
			y1=y;
			z1=-x*s1+c1*z;
			//printf("(a %lf %lf %lf %lf)\n",x1,y1,z1,x1*x1+y1*y1+z1*z1);
			
			x=x1;
			y=y1*c2+z1*s2;
			z=-y1*s2+z1*c2;
			//printf("(b %lf %lf %lf %lf)\n",x,y,z,x*x+y*y+z*z);
			
			//x1=c1*x-s1*z;
			//y1=y;
			z1=s1*x+z*c1;
			//printf("<%lf %lf %lf %lf>\n",x1,y1,z1,x1*x1+y1*y1+z1*z1);
			if(z1<0) seeInOK=false;
		}
		if(seeInOK==true){
			ans.push_back(name);
		}
	}
}


int main(){
	int mon,dd,hh,mm;
	double time,round;
	int mons[12]={0,31,60,91,121,152,182,213,244,274,305,335};
	int n,m;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d/%d %d:%d",&mon,&dd,&hh,&mm);
		scanf("%d",&m);
		time=mons[mon-1]+dd+hh/24.0+mm/(60.0*24.0)-1.0;
		round=time*(1+1/365.24)*360.0;
		starCalc(m,round);
	}
	std::vector<std::string>::iterator it=ans.begin();
	while(it!=ans.end()){
		printf("%s\n",(*it).c_str());
		it++;
	}
}
accuracy: 1
time_ms: 20
memory_kb: 868
final_rank: 2

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>

using namespace std;
typedef long long ll;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

typedef vector<double> Array;
typedef vector<Array> Matrix;

Array mul(const Matrix &matrix, const Array &vect) {
  const int w = matrix[0].size();
  const int h = matrix.size();
  Array ret(h, 0);
  REP(y, h) {
    REP(x, w) {
      ret[y] += matrix[y][x] * vect[x];
    }
  }
  return ret;
}

Matrix mul(const Matrix &matrix1, const Matrix &matrix2) {
  const int in = matrix1[0].size();
  const int h = matrix1.size();
  const int w = matrix2[0].size();
  Matrix ret(h, Array(w, 0));
  REP(y, h) {
    REP(x, w) {
      REP(i, in) {
        ret[y][x] += matrix1[y][i] * matrix2[i][x];
      }
    }
  }
  return ret;
}

Array XRotate(const Array vect, const double rad) {
  Matrix matrix(3, Array(3, 0));
  matrix[0][0] = 1.0;
  matrix[1][1] = cos(rad);
  matrix[1][2] = sin(rad);
  matrix[2][1] = -sin(rad);
  matrix[2][2] = cos(rad);
  return mul(matrix, vect);
}

Array YRotate(const Array vect, const double rad) {
  Matrix matrix(3, Array(3, 0));
  matrix[1][1] = 1.0;
  matrix[0][0] = cos(rad);
  matrix[0][2] = -sin(rad);
  matrix[2][0] = sin(rad);
  matrix[2][2] = cos(rad);
  return mul(matrix, vect);
}

Array ZRotate(const Array vect, const double rad) {
  Matrix matrix(3, Array(3, 0));
  matrix[2][2] = 1.0;
  matrix[0][0] = cos(rad);
  matrix[0][1] = sin(rad);
  matrix[1][0] = -sin(rad);
  matrix[1][1] = cos(rad);
  return mul(matrix, vect);
}

Array normalize(const Array vect) {
  const int n = vect.size();
  double sum = 0;
  Array ret(n, 0);
  REP(i, n) {
    sum += vect[i] * vect[i];
  }
  sum = sqrt(sum);
  REP(i, n) {
    ret[i] = vect[i] / sum;
  }
  return ret;
}

char str[1000];

const int month[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int main() {
int test;
scanf("%d", &test);
while (test--) {
  int m, d, h, minute;
  scanf("%d/%d %d:%d", &m, &d, &h, &minute);
  REP(i, m - 1) {
    d += month[i];
  }
  d--;
  h += d * 24;
  minute += h * 60;
  double rad = (1.0 + 1.0 / 365.24) * 360.0 * minute / 60.0 / 24.0 * 2 * PI / 360.0;
  int n;
  scanf("%d", &n);
  Array star(3);
  REP(i, n) {
    int m;
    scanf("%s %d", str, &m);
    bool see = true;
    REP(j, m) {
      double a, h;
      scanf("%lf %lf", &a, &h);
      a = (90 - a) * PI / 180.0;
      h = h * PI / 180.0;
      star[2] = sin(h);
      double d = sqrt(1 - star[2] * star[2]);
      star[0] = d * cos(a);
      star[1] = d * sin(a);
      star = XRotate(star, -(90.0 - 43.2) * PI / 180.0);
      star = ZRotate(star, rad);
      star = XRotate(star, -(43.2 - 90.0) * PI / 180.0);
      if (star[2] < 0) { see = false; }
    }
    if (see) { printf("%s\n", str); }
  }
}
}
accuracy: 1
time_ms: 70
memory_kb: 952
final_rank: 11