Problem:
パーティー
問題
あなたはクリスマスパーティーに学校内の自分の友達と，自分の友達の友達を招待することにした．
あなたの通う学校の生徒数は n 人であり，それぞれの生徒には 1 から n までの番号が割り振られている．
あなたの番号は 1 である．
あなたの手元には，誰と誰が友達であるかを記したリストがある．
このリストをもとに，
あなたがクリスマスパーティーに招待する生徒数を求めるプログラムを作成せよ．
入力
入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．
データセットの1 行目には学校の生徒数 n （2 ≤ n ≤ 500）が，
2 行目にはリストの長さ m （1 ≤ m ≤ 10000）が書かれている．
入力は全部で 2+m 行からなる．2+i 行目（1 ≤ i ≤ m）には 2 つの整数 a
i
と b
i
（1 ≤ a
i
< b
i
≤ n）が空白区切りで書かれており，番号 a
i
と番号 b
i
の生徒が友達同士であることを表す．
3 行目から 2+m 行目には同じ友達関係を表す行が重複して現れることはない．
n, m がともに 0 のとき入力の終了を示す.データセットの数は 5 を超えない．
出力
データセットごとに，あなたがクリスマスパーティーに招待する生徒数を1 行に出力する．
入出力例
入力例
6
5
1 2
1 3
3 4
2 3
4 5
6
5
2 3
3 4
4 5
5 6
2 5
0
0
出力例
3
0
1つ目の入力例 において，あなたの友達は番号 2 と番号 3 の生徒の 2 人である．
また，番号 3 と番号 4 の生徒は友達同士であるので，
番号 4 の生徒はあなたの友達の友達である．
番号 5 と番号 6 の生徒はあなたの友達でもなく，あなたの友達の友達でもない．
したがって，あなたは番号 2,3,4 の 3 人の生徒をクリスマスパーティーに招待する．
2つ目の入力例  において，あなたには友達はいない．
したがって，あなたがクリスマスパーティーに招待する生徒数は 0 人である．
上記問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>

//    #include <boost/multiprecision/cpp_int.hpp>
 #define int long long
 #define inf  1000000007
 #define pa pair<int,int>
 #define ll long long
 #define pal pair<double,double>
 #define ppap pair<pa,int>
//  #define PI 3.14159265358979323846
  #define paa pair<int,char>
  #define  mp make_pair
  #define  pb push_back
  #define EPS (1e-10)
                                          
    int dx[8]={0,-1,0,1,1,1,-1,-1};
    int dy[8]={1,0,-1,0,-1,1,1,-1};
                                            using namespace std;
                                   			class pa3{
                                            	public:
                                            	int x,y,z;
                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
                                            	bool operator < (const pa3 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		 return z<p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                   				bool operator > (const pa3 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		 return z>p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa3 &p) const{
                                            		return x==p.x && y==p.y && z==p.z;
                                            	}
                                            		bool operator != (const pa3 &p) const{
                                            			return !( x==p.x && y==p.y && z==p.z);
                                            	}
                                            
                                            };
                                            
                                            class pa4{
                                            	public:
                                            	double x;
                                            	int y,z,w;
                                            	pa4(double x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
                                            	bool operator < (const pa4 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		if(z!=p.z)return z<p.z;
                                            		return w<p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator > (const pa4 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		if(z!=p.z)return z>p.z;
                                            		return w>p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa4 &p) const{
                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;
                                            	}
                                            		
                                            
                                            };
                                            class pa2{
                                            	public:
                                            	int x,y;
                                            	pa2(int x=0,int y=0):x(x),y(y) {}
                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
                                            	bool operator < (const pa2 &p) const{
                                            		return y != p.y ? y<p.y: x<p.x;
                                            	}
                                            	bool operator > (const pa2 &p) const{
                                            		return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa2 &p) const{
                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;
                                            	}
                                            	bool operator != (const pa2 &p) const{
                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
                                            	}
                                            		
                                            
                                            };
                                            
/*
                                            class Point{
                                            	public:
                                            	double x,y;
                                            	Point(double x=0,double y=0):x(x),y(y) {}
                                            	Point operator + (Point p) {return Point(x+p.x,y+p.y);}
                                            	Point operator - (Point p) {return Point(x-p.x,y-p.y);}
                                            	Point operator * (double a) {return Point(x*a,y*a);}
                                            	Point operator / (double a) {return Point(x/a,y/a);}
                                            	double absv() {return sqrt(norm());}
                                            	double norm() {return x*x+y*y;}
                                            	bool operator < (const Point &p) const{
                                            		return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const Point &p) const{
                                            		return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
                                            	}
                                            };
                                            typedef Point Vector;
                                     #define pl pair<int,pas>
                                            struct Segment{
                                            Point p1,p2;
                                            };
                                             double dot(Vector a,Vector b){
                                            	return a.x*b.x+a.y*b.y;
                                            }
                                            double cross(Vector a,Vector b){
                                            	return a.x*b.y-a.y*b.x;
                                            }
                                        
                bool parareru(Point a,Point b,Point c,Point d){
                //	if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
                	return abs(cross(a-b,d-c))<EPS;
                }
                double distance_ls_p(Point a, Point b, Point c) {
                  if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
                  if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
                  return abs(cross(b-a, c-a)) / (b-a).absv();
                }
                bool is_intersected_ls(Segment a,Segment b) {
                	if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
                	if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&&parareru((a.p2),(a.p1),(a.p1),(b.p1))){
                //		cout<<"sss"<<endl;
                		if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
                		if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
                		if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
                		if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
                		return false;
                	}
                  else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
                }
                 
                double segment_dis(Segment a,Segment b){
                	if(is_intersected_ls(a,b))return 0;
                	double r=distance_ls_p(a.p1, a.p2, b.p1);
                	r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
                	r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
                	r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
                	return r;
                }
                Point intersection_ls(Segment a, Segment b) {
                  Point ba = b.p2-b.p1;
                  double d1 = abs(cross(ba, a.p1-b.p1));
                  double d2 = abs(cross(ba, a.p2-b.p1));
                  double t = d1 / (d1 + d2);
                 
                  return a.p1 + (a.p2-a.p1) * t;
                }
 */                
                                string itos( int i ) {
                                ostringstream s ;
                                s << i ;
                                return s.str() ;
                                }
                                 
                                int gcd(int v,int b){
                                	if(v>b) return gcd(b,v);
                                	if(v==b) return b;
                                	if(b%v==0) return v;
                                	return gcd(v,b%v);
                                }
                 
                                double distans(double x1,double y1,double x2,double y2){
                                	double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
                                	return sqrt(rr);
                                	
                                }
                                int mod;
                                
                int pr[500010];
                int inv[500010];
                
                int beki(int wa,int rr,int warukazu){
                	if(rr==0) return 1%warukazu;
                	if(rr==1) return wa%warukazu;
                	if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
                	int zx=beki(wa,rr/2,warukazu);
                	return (zx*zx)%warukazu;
                }
    double bekid(double w,int r){
    	if(r==0) return 1.0;
    	if(r==1) return w;
    	if(r%2) return bekid(w,r-1)*w;
    	double f=bekid(w,r/2);
    	return f*f;
    }
                
    			int comb(int nn,int rr){
    				int r=pr[nn]*inv[rr];
    				r%=mod;
    				r*=inv[nn-rr];
    				r%=mod;
    				return r;
    			}
                
                void gya(int ert){
                	pr[0]=1;
                	for(int i=1;i<ert;i++){
                		pr[i]=(pr[i-1]*i)%mod;
                	}
                	for(int i=0;i<ert;i++) inv[i]=beki(pr[i],mod-2,mod);
                	
                }
                
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
                                         //----------------kokomade tenpure------------
                //vector<double> ans(100000000),ans2(100000000)
      

  signed main(){
    	       cin.tie(0);
    			ios::sync_with_stdio(false);
  while(1){
      
  
  int n,m;
  	cin>>n>>m;
  	if(n==0&&m==0) return 0;
  	int a[510][510];
  	for(int i=1;i<=n;i++)for(int j=1;j<=n;j++){
  		if(i==j) a[i][j]=0;
  		else a[i][j]=inf;
  	}
  	for(int i=0;i<m;i++){
  		int y,yy;
  		cin>>y>>yy;
  		a[y][yy]=1;
  		a[yy][y]=1;
  	}
  	for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)for(int k=1;k<=n;k++){
  		a[j][k]=min(a[j][k],a[j][i]+a[i][k]);
  	}

  	int ans=0;
  	for(int i=2;i<=n;i++)if(a[i][1]<=2) ans++;
  cout<<ans<<endl;
  }
  	return 0;
    }
accuracy: 1
time_ms: 110
memory_kb: 5096
final_rank: 6

code_snippet: //https://onlinejudge.u-aizu.ac.jp/challenges/sources/JOI/Prelim/0545?year=2010

#include <bits/stdc++.h>

using namespace std;

const auto INF = (long long) 1e9;

int main() {
    int n, m;

    while (cin >> n >> m, n | m) {

        // Warshall–Floyd
        int dp[510][510];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i == j) {
                    dp[i][i] = 0;
                } else {
                    dp[i][j] = INF;
                }
            }
        }

        for (int i = 0; i < m; ++i) {
            int a, b;
            cin >> a >> b;
            a--;
            b--;
            dp[a][b] = 1;
            dp[b][a] = 1;
        }

        for (int k = 0; k < n; ++k) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
                }
            }
        }

        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (dp[0][i] == 1 or dp[0][i] == 2) ans++;
        }
        cout << ans << endl;
    }
    return 0;
}

/*
 * ワーシャル・フロイド。
 * 自分からの距離が1か2の人を数える。
 *
 */
accuracy: 1
time_ms: 110
memory_kb: 4068
final_rank: 4

code_snippet: #include <iostream>
#include <string>
#include <map>
#include <vector>
#include <utility>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <numeric>

#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define itrep(i,x) for(auto i=(x).begin(); i!=(x).end();i++)
#define Sort(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define vec vector
#define INF (int)1e9
#define INFL 1e18
#define MOD 1000000007
#define pb push_back
#define MP make_pair
#define PI 3.1415926535
#define fcout cout<<fixed<<setprecision(10)
typedef long long int ll;
typedef std::pair<int,int> P;
int D=1;
int dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
//template<typename T>void pp(T x){cout<<x<<endl;}

using namespace std;
template<typename T> void test(vector<T> v){for(int i=0;i<v.size();i++){if(i)cout<<" ";cout<<v[i];}cout<<endl;}

int main(){
    int n,m;
    while(cin>>n&&n){
        cin>>m;
        vector<vector<int>> v(n,vector<int>(n,INF));
        rep(i,0,n)v[i][i]=0;
        rep(i,0,m){
            int a,b;
            cin>>a>>b;
            a--; b--;
            v[a][b]=1;
            v[b][a]=1;
        }

        rep(i,0,n){
            rep(j,0,n){
                rep(k,0,n){
                    v[j][k]=min(v[j][k],v[j][i]+v[i][k]);
                }
            }
        }
        int ans=0;
        rep(i,0,n){
            if(v[0][i]==2||v[0][i]==1)ans++;
        }
        cout<<ans<<endl;
    }
    
    return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 3908
final_rank: 3

code_snippet: #include<stdio.h>
#include<iostream>
using namespace std;
int a[10000],b[10000];
int main(){
	while(1){
		int i,n,m,l=0,s[501]={0},j;
		cin>>n>>m;
		if(n==0&&m==0)break;
		s[1]=3;
		for(i=0;i<m;i++){
		cin>>a[i]>>b[i];
		}
		for(i=0;i<m;i++){
			for(j=0;j<m;j++){
				if(s[a[j]]>0&&s[b[j]]<s[a[j]]-1)s[b[j]]=s[a[j]]-1;
				if(s[b[j]]>0&&s[a[j]]<s[b[j]]-1)s[a[j]]=s[b[j]]-1;
			}
		}
		for(i=2;i<=n;i++){
		if(s[i]!=0)l++;
		}
		cout<<l<<endl;
	}
	return 0;
}
accuracy: 1
time_ms: 180
memory_kb: 3124
final_rank: 5

code_snippet: #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>

using namespace std;

#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define rep(i,n) for(i=0;i<n;i++)
#define loop(i,a,n) for(i=a;i<n;i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)

typedef vector<int> vi;
typedef pair<int,int> pii;

int main()
{
  int i,j,k;
  int n,m;
  while(1){
    cin>>n>>m;
    if(n==0 && m==0)break;
    int v[500][500];
    rep(i,n)rep(j,n)
      if(i==j)v[i][j]=0;
      else v[i][j]=INF;
    rep(i,m){
      int a,b;
      cin>>a>>b;
      a--;b--;
      v[a][b]=1;
      v[b][a]=1;
    }
    rep(k,n)rep(i,n)rep(j,n)
      v[i][j]=min(v[i][j],v[i][k]+v[k][j]);
    int ans=0;
    rep(i,n)
      if(v[0][i]==1 || v[0][i]==2)ans++;
    cout<<ans<<endl;
  }
}
accuracy: 1
time_ms: 100
memory_kb: 3964
final_rank: 2

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

int n, m, a[11234], b[11234];
int my_friends[11234], their_friends[11234];
int ans = 0;
bool cancel = false;

int main(void) {
	while (true) {
		ans = 0;
		scanf("%d%d", &n, &m);
		if (n == 0 && m == 0) { break; }
		for (int i = 0; i < m; ++i) { scanf("%d%d", &a[i], &b[i]); }

		memset(my_friends, -1, sizeof(my_friends));
		memset(their_friends, -1, sizeof(their_friends));
		my_friends[0] = 1, their_friends[0] = 1;
		for (int i = 0; i < m; ++i) {
			if (a[i] == 1) { my_friends[b[i] - 1] = b[i]; ans++; }
		}
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < m; ++j) {
				if (a[i] == my_friends[j]) {
					for (int k = 0; k < n; ++k) {
						if (b[i] == my_friends[k] || b[i] == their_friends[k]) {
							cancel = true;
							break;
						}
					}
					if (cancel == false) { their_friends[b[i] - 1] = b[i]; ans++; }
					cancel = false;
				}
				else if (b[i] == my_friends[j]) {
					for (int k = 0; k < n; ++k) {
						if (a[i] == my_friends[k] || a[i] == their_friends[k]) {
							cancel = true;
							break;
						}
					}
					if (cancel == false) { their_friends[a[i] - 1] = a[i]; ans++; }
					cancel = false;
				}
			}
		}

		printf("%d\n", ans);
	}
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 2724
final_rank: 1