Problem:
Problem B: Carrot Tour

うさぎがある国を旅行している. この国には1 からn の番号がついたn 個の都市があり, うさぎは今都市1にいる. 都市i は座標平面上の1 点(xi, yi) とみなす.

うさぎは以下の条件をみたすように旅をする.

移動経路は折れ線であり, その各部分は異なる2 都市を結ぶ線分でなければならない.

移動経路の全長はr 以下でなければならない. 経路のうち重なった部分も, 通った回数分数える.

移動する方向が変わるとき, 曲がる角度はθ 以下でなければならない. 最初の移動方向に制限はない.

うさぎがある都市から別の都市へ移動をすると, 移動先の都市でニンジンを1 本もらえる. 同じ都市を複数回訪れることは可能であり, 訪れるたびにニンジンをもらえる. うさぎがこの旅で手に入れることのできるニンジンの本数の最大値を求めよ.

Input

入力の一行目には一つの整数n が, 二行目には二つの実数r, θ がスペースで区切られて与えられる.

1 ≤ n ≤ 20

0 < r < 104

0° < θ < 180°

続くn 行には, 整数xi, yi がスペースで区切られて与えられる

-10 000 ≤ xi, yi ≤ 10 000

r, θ を±10−3 以内で変化させても答えは変わらない.

どの2 つの都市の位置も異なる.

Output

うさぎがこの旅で手に入れることのできるニンジンの本数の最大値を一行に出力せよ.

Sample Input 1

5
100.1 90.1
0 0
0 10
5 5
10 0
10 10

Sample Output 1

10

Solution in C++ (judge verdict: Time Limit Exceeded)

#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
#include <iterator>
#include <complex>
 
using namespace std;
 
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
 
int tx[] = {0,1,0,-1};//URDL
int ty[] = {-1,0,1,0};
 
static const double EPS = 1e-8;

bool check(int city,int prev,int old,double limit_rad,
	   const vector<complex<double> >& cities){
  complex<double> src = cities[old];
  complex<double> mid = cities[prev];
  complex<double> dst = cities[city];

  src -= mid;
  dst -= mid;

  return (limit_rad >= M_PI - min(abs(arg(src) - arg(dst)),
				  abs(2.0*M_PI - arg(src) - arg(dst))));
}
class State {
public:
  int carrots;
  int city;
  int prev;
  int old;
  double remaining_distance;
  deque<int> deq;
  State(int _ct,int _p,int _o,int _c,double _r) :
    city(_ct),prev(_p),old(_o), carrots(_c), remaining_distance(_r) {}

  State(int _ct,int _c,double _r,int _d) :
    city(_ct), carrots(_c), remaining_distance(_r) {
    prev = 20;
    old = 20;
  }

  bool operator <(const State& s) const{
    if(carrots == s.carrots){
      return remaining_distance < s.remaining_distance;
    }
    return carrots < s.carrots;
  }
};

bool dp[5001][21][21]; //dp[carrot][prev][now] := remaining distance

int main(){
  int total_cities;
  while(~scanf("%d",&total_cities)){
    double r,theta;
    vector<complex<double> > cities;
    scanf("%lf %lf",&r,&theta);
    double limit_rad = theta * M_PI / 180.0;
    for(int city_idx = 0; city_idx < total_cities; city_idx++){
      int x,y;
      scanf("%d %d",&x,&y);
      cities.push_back(complex<double>(x,y));
    }

    priority_queue<State> que;
    que.push(State(0,0,r,0));
    int max_carrots = 0;
    memset(dp,false,sizeof(dp));

    while(!que.empty()){
      State s = que.top();
      que.pop();
      max_carrots = max(s.carrots,max_carrots);

      if(dp[s.carrots][s.prev][s.city]) continue;
      dp[s.carrots][s.prev][s.city] = true;

      for(int to=0;to<cities.size();to++){
	if(to == s.city) continue;
	double dist = abs(cities[to] - cities[s.city]);
	if(s.remaining_distance - dist <= 0) continue;

	int next_city = to;
	int next_prev = s.city;
	int next_old = s.prev;
	if(next_old != 20){
	  if(!check(next_city,next_prev,next_old,limit_rad,cities)) continue;
	}
	que.push(State(next_city,next_prev,next_old,s.carrots+1,s.remaining_distance - dist));
      }
    }

    printf("%d\n",max_carrots);
  }
}