POJ 1696 向量的点乘

题意：有个东西，要吃地图上的点，但是只能直走或者向左拐，而且不能与之前的路线相交，问最多能吃多少

思路：向左拐的话开始以为是叉乘，后来天真的乱写错了之后看题解，发现最多能吃多少完全是坑，因为能全吃完= =，其实画一画完全能发现，就是从最下面的点开始，然后绕着圈吃嘛。。于是这道题也是这么解的，先找到最下面的点，然后找到偏转角度最小的点，就这样走下去就可以。。三点共线的时候开始没考虑也A了，后来想了想应该是取距离相对最小的那个点（然后就可以接着走向下一个点了）

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cmath>
#include<queue>
#include<list>
using namespace std;
const double INF = 1e200;
const double EP = 1e-8;
const int maxn = 4000;
const double PI = acos(-1);
struct POINT{///点 定义
    double x;
    double y;
    int id;
    POINT(double a = 0,double b = 0){x = a;y = b;}
};
struct SEGMENT{///line segment///线段 定义
    POINT s;
    POINT e;
    SEGMENT(POINT a,POINT b){s = a;e = b;}
    SEGMENT(){}
};
struct LINE{///ax + by + c = 0&&a >= 0///一般式
    double a;
    double b;
    double c;
    LINE(double da,double db,double dc){a = da;b = db;c = dc;}
    LINE(double x1,double y1,double x2,double y2){///根据两个点求出一般式
        a = y1 - y2;b = x2 - x1;c = x1*y2 - x2*y1;
        if(a < 0){a*=-1;b*=-1;c*=-1;}
    }
};
double multiply(POINT sp,POINT ep,POINT op){///向量op->sp X op->ep的叉乘，小于0：ep在op->sp顺时针方向//大于0：0：ep在op->sp逆时针方向//等于0：三点共线
    return ((sp.x - op.x)*(ep.y - op.y) - (ep.x - op.x)*(sp.y - op.y));
}
double dotmultiply(POINT p1,POINT p2,POINT p0){
    return ((p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y));
}
bool online(SEGMENT l,POINT p){///判断点是否在线段上
    return ((multiply(l.e,p,l.s) == 0)&&(((p.x-l.s.x)*(p.x-l.e.x))<= 0)&&(((p.y-l.s.y)*(p.y-l.e.y)) <= 0));
}
bool intersect(SEGMENT u,SEGMENT v){///两线段相交（包括端点），返回true
    return ((max(u.s.x,u.e.x) >= min(v.s.x,v.e.x))&&
            (max(v.s.x,v.e.x) >= min(u.s.x,u.e.x))&&
            (max(u.s.y,u.e.y) >= min(v.s.y,v.e.y))&&
            (max(v.s.y,v.e.y) >= min(u.s.y,u.e.y))&&
            (multiply(v.s,u.e,u.s)*multiply(u.e,v.e,u.s) >= 0)&&
            (multiply(u.s,v.e,v.s)*multiply(v.e,u.e,v.s) >= 0));
}
bool intersect_a(SEGMENT u,SEGMENT v){///两线段相交（不包括端点）
    return ((intersect(u,v))&&
            !online(u,v.s)&&
            !online(u,v.e)&&
            !online(v,u.e)&&
            !online(v,u.s));
}
int lineintersect(LINE l1,LINE l2,POINT &p){///求两直线交点,有交点返回1和交点，没有返回0，重合返回2
    double d = l1.a*l2.b-l2.a*l1.b;
    double d2 = l1.a*l2.c-l2.a*l1.c;
    double d3 = l1.b*l2.c-l2.b*l1.c;
    if(fabs(d) < EP&&fabs(d2) < EP&&fabs(d3) < EP)return 2;
    p.x = (l2.c*l1.b-l1.c*l2.b)/d;
    p.y = (l2.a*l1.c-l1.a*l2.c)/d;
    if(fabs(d) < EP)return 0;
    return 1;
}
double point_dis(POINT a,POINT b){///求两点距离
    return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}
///************************************************************************************************************************************
POINT point[60];
int n;
int ans;
bool vis[60];
int turn[60];
bool cmp(POINT a,POINT b){
    if(a.y == b.y)return a.x < b.x;
    else return a.y < b.y;
}
double dis(POINT a,POINT b){
    double x = a.x - b.x;
    double y = a.y - b.y;
    return sqrt(x*x+y*y);
}
void dfs(POINT pre,POINT now,int t){
    vis[now.id] = 1;
    turn[t] = now.id;
    double mul = -2;
    int next;
    double disa = dis(pre,now);
    double last_dis;
    for(int i = 0;i < n;i ++){
        if(vis[point[i].id] == 0){
            double disb = dis(now,point[i]);
            POINT tt(point[i].x - (now.x - pre.x),point[i].y - (now.y - pre.y));
            double tmp = dotmultiply(tt,now,pre)/(disa*disb);
            if(fabs(tmp - mul) < EP){
                if(disb < last_dis){
                    next = i;
                    last_dis = disb;
                }
            }
            else if(tmp > mul){
                mul = tmp;
                next = i;
                last_dis = disb;
            }
        }
    }
    if(mul != -2){
        dfs(now,point[next],t+1);
    }
}
int main(){
    //freopen("in.txt","r",stdin);
    int T;
    cin>>T;
    while(T --){
        cin>>n;
        for(int i = 0;i < n;i ++){
            int a,b,c;
            cin>>a>>b>>c;
            point[i].x = b;
            point[i].y = c;
            point[i].id = i+1;
        }
        memset(vis,0,sizeof(vis));
        sort(point,point+n,cmp);
        dfs((POINT){0,point[0].y},point[0],1);
        cout<<n;
        for(int i = 1;i <= n;i ++){
            cout<<' '<<turn[i];
        }
        cout<<endl;
    }
    return 0;
}