Have you ever played DOTA? If so, you may know the hero, Invoker. As one of the few intelligence carries, Invoker has 10 powerful abilities. One of them is the Ice Wall: Invoker generates a wall of solid ice directly in front of him, and the bitter cold emanating from it greatly slows nearby enemies and deals damage each second.

Now consider the map as a plane. You are now at point s, and want to move to point t. But Invoker has placed N ice walls on the map. Your moving speed is 1 per second, but you need k seconds to pass an ice wall. Time is precious, you must get to point t as quickly as possible. What's the minimum time you need?

For convenience, you can assume that all ice walls are segments (no width) either parallel to X-axis or to Y-axis. Segments are strictly disjoint (have no common point). Point s and t are not on any segment (have no common point).

You will not be slowed when pass the end point of a segment or walk along a segment.

The input begins with an integer T, indicating the number of test cases. For each case, the first line is two integers N and k (1 <= N <= 500, 0 <= k <= 10^8), indicating the number of segments and the time needed to pass an ice wall. Next N lines, each have four integers x1, y1, x2, y2, indicating two end points of a segment, (x1, y1) and (x2, y2). Next line has two integers xs and ys, representing the coordinates of starting point s. The last line also has two integers xt and yt, representing the coordinates of target point t. For every point, |x| and |y| <= 108.

For each case, output one line containing the minimum time in second needed to get to t from s. The answer should be given within an absolute or relative error of 10−6.

3

1 1

1 0 1 2

0 0

2 0

1 1

1 -2 1 2

0 0

2 0

1 3

1 -2 1 2

0 0

2 0

2.000000

3.000000

4.472136
　　
　　这道题还是有些挑战的，可以一眼看出是最短路，但如何处理出点对的直接路径？
　　考虑极角排序，我不会，就用三角函数的sin和cos代替，然后用bit维护，可以做到N²logN。

 #include <algorithm>

 #include <iostream>

 #include <cstring>

 #include <cstdio>

 #include <cmath>

 using namespace std;

 const double eps=1e-;

 const int N=,M=;

 struct Node{int x,y,tp;}point[N],s,t,tmp;

 struct Data{Node t;int id;double k,d;}st[N];

 int hsh[*N],bit[*N],csh,top;double G[N][N];

 double Dis(Node a,Node b){

     return sqrt(1.0*(a.x-b.x)*(a.x-b.x)+1.0*(a.y-b.y)*(a.y-b.y));

 }

 double K1(Node b){return 1.0*(b.x-tmp.x)/Dis(tmp,b);}

 double K2(Node b){return 1.0*(b.y-tmp.y)/Dis(tmp,b);}

 int Rk1(int tp){return tp==?:tp==?:;}

 int Rk2(int tp){return tp==?:tp==?:;}

 bool cmp1(Data p,Data q){

     Node a=p.t,b=q.t;

     if(fabs(p.k-q.k)>)return q.k-p.k>=eps;

     if(a.tp==&&b.tp==)return q.d-p.d>=eps;

     if(a.tp==&&b.tp==)return p.d-q.d>=eps;

     return Rk1(a.tp)<Rk1(b.tp);

 }

 bool cmp2(Data p,Data q){

     Node a=p.t,b=q.t;

     if(fabs(p.k-q.k)>)return p.k<q.k;

     if(a.tp==&&b.tp==)return p.d<q.d;

     if(a.tp==&&b.tp==)return p.d>q.d;

     return Rk2(a.tp)<Rk2(b.tp);

 }

 int Query(int x,int y){int ret=;

     x=lower_bound(hsh+,hsh+csh+,x)-hsh-;

     while(x){ret-=bit[x];x-=x&(-x);}

     y=lower_bound(hsh+,hsh+csh+,y)-hsh;

     while(y){ret+=bit[y];y-=y&(-y);}

     return ret;

 }

 void Add(int x,int d){

     x=lower_bound(hsh+,hsh+csh+,x)-hsh;

     while(x<=csh)bit[x]+=d,x+=x&(-x);

 }

 int tot,n,ice,T;

 void Solve1(int p){

     tmp=point[p];top=;

     for(int i=;i<=tot;i++){

         Node b=point[i];if(tmp.y<=b.y)continue;

         st[++top]=(Data){b,i,K1(b),Dis(tmp,b)};

     }sort(st+,st+top+,cmp1);

     memset(bit,,sizeof(bit));

     for(int i=;i<=top;i++){

         Data b=st[i];Node c=b.t;

         if(c.tp==)Add(c.y,-);

         G[b.id][p]+=ice*Query(c.y,tmp.y);

         G[p][b.id]+=ice*Query(c.y,tmp.y);

         if(c.tp==)Add(c.y,);

     }

 }

 void Solve2(int p){

     tmp=point[p];top=;

     for(int i=;i<=tot;i++){

         Node b=point[i];if(tmp.x<=b.x)continue;

         st[++top]=(Data){b,i,K2(b),Dis(tmp,b)};

     }sort(st+,st+top+,cmp2);

     memset(bit,,sizeof(bit));

     for(int i=;i<=top;i++){

         Data b=st[i];Node c=b.t;

         if(c.tp==)Add(c.x,-);

         G[b.id][p]+=ice*Query(c.x,tmp.x);

         G[p][b.id]+=ice*Query(c.x,tmp.x);

         if(c.tp==)Add(c.x,);

     }

 }

 int vis[N];double dis[N];

 double Dij(int s,int t){

     for(int i=;i<N;i++)

     dis[i]=1e20,vis[i]=;dis[s]=;

     for(int i=,p;i<=tot;i++){p=;

         for(int j=;j<=tot;j++)

             if(!vis[j]&&dis[p]>dis[j])p=j;

         vis[p]=true;

         for(int j=;j<=tot;j++)

             dis[j]=min(dis[j],dis[p]+G[p][j]);

     }

     return dis[t];

 }

 void Initial(){

     memset(G,,sizeof(G));

     tot=csh=;

 }

 int main(){

     scanf("%d",&T);

     while(T--){

         scanf("%d%d",&n,&ice);Initial();

         for(int i=,x1,y1,x2,y2;i<=n;i++){

             scanf("%d%d%d%d",&x1,&y1,&x2,&y2);

             hsh[++csh]=x1;hsh[++csh]=x2;

             hsh[++csh]=y1;hsh[++csh]=y2;

             if(x1==x2&&y1==y2)continue;

             if(x1==x2){

                 if(y1>y2)swap(y1,y2);

                 point[++tot]=(Node){x1,y1,};

                 point[++tot]=(Node){x2,y2,};

             }

             if(y1==y2){

                 if(x1>x2)swap(x1,x2);

                 point[++tot]=(Node){x1,y1,};

                 point[++tot]=(Node){x2,y2,};

             }

         }

         scanf("%d%d",&s.x,&s.y);

         scanf("%d%d",&t.x,&t.y);

         hsh[++csh]=s.x;hsh[++csh]=s.y;

         hsh[++csh]=t.x;hsh[++csh]=t.y;

         sort(hsh+,hsh+csh+);

         csh=unique(hsh+,hsh+csh+)-hsh-;

         point[++tot]=(Node){s.x,s.y,};

         point[++tot]=(Node){t.x,t.y,};

         for(int i=;i<=tot;i++)Solve1(i);

         for(int i=;i<=tot;i++)Solve2(i);    

         for(int i=;i<=tot;i++)

             for(int j=;j<=tot;j++)

                 G[i][j]+=Dis(point[i],point[j]);

         printf("%.6lf\n",Dij(tot-,tot));

     }

     return ;

 }

 #include <algorithm>

 #include <iostream>

 #include <cstring>

 #include <cstdio>

 #include <cstdlib>

 #include <ctime>

 using namespace std;

 int G[][],h[];

 int main(){

     srand(time(NULL));

     int T=,n=,w=;

     printf("%d\n",T);

     while(T--){

         printf("%d %d\n",n,rand()%w);

         int x,y,a,b,l;

         for(int i=;i<w;i++){

             h[i]=rand()*rand()%;

             if(rand()%)h[i]*=-;

         }

         sort(h,h+w);

         memset(G,,sizeof(G));

         for(int i=;i<=n;i++){

             while(true){

                 x=rand()%w;y=rand()%w;

                 while(G[x][y])x=rand()%w,y=rand()%w;

                 if(rand()%){

                     a=x;l=;

                     while(y+l+<=w&&G[x][y+l]==)l++;

                     if(l==)continue;b=y+rand()%(l-)+;

                 }

                 else{

                     b=y;l=;

                     while(x+l+<=w&&G[x+l][y]==)l++;

                     if(l==)continue;a=x+rand()%(l-)+;

                 }

                 for(int j=x;j<=a;j++)

                     for(int k=y;k<=b;k++)

                         G[j][k]=;

                 printf("%d %d %d %d\n",h[x],h[y],h[a],h[b]);

                 break;

             }

         }

         x=rand()%w;y=rand()%w;

         while(G[x][y])x=rand()%w,y=rand()%w;

         printf("%d %d\n",h[x],h[y]);G[x][y]=;

         x=rand()%w;y=rand()%w;

         while(G[x][y])x=rand()%w,y=rand()%w;

         printf("%d %d\n",h[x],h[y]);

     }

     return ;

 }