hust 1607 Triangles（经典好题）

题意：给出一定的点，然后再给出哪些点相连，问最后这些相连点的组成多少个三角形，hash的应用

分析：转载牛人的思想

       

题意：给一些点的坐标和里面的点构成的一些线段，求这些线段可以构成多少个三角形；

 

思路：因为的点的个数只有100，所以枚举三个点就可以了，O（n^3）；

 

只不过这里有一些条件：这三个点构成的三条线段必须在前面给的线段里，怎么判断呢？

这里我们可以用hash坐标的方法，把一个点的坐标hash成一个数字，这个很简单，就是把

每个点的x,y坐标加上100000，最后key＝x*200000＋y，因为y不会超过200000，所以

这样就可以保证每个点的坐标不相同了，然后我们再把key和坐标的序号建立一个映射就好了；

 

再然后我们可以为100点建立一个邻接矩阵，开始输入数据的时候，每来一个线段，我们找到

线段两端的坐标得到它的hash值，并用映射关系找到这个点的序号，然后把邻接矩阵里两个序

号对应的位置赋值为1，例如现在线段两个端点的序号是1和2，map[][]为链接矩阵,那么我们

就令map[1][2]=map[2][1]=1,像加了一条边一样，这样我们就得到了所有点与点之间的关系了；

 

接下来我们还要解决一个问题，比如线段ab和bc平行，那么我们就又可以得到一条新的线段也就是ac，

解决这个问题我们可以用点疏松的方法，这个类似于floyd算法，时间复杂度O(n^3)，具体看

 

下面是大神的代码 

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<map>
using namespace std;
struct node {double x,y;};
node point[220];
double yy[220];

map <double,int > pp ;
double get(double x,double y) //点hash
{
//    x+=100000;
//    y+=100000;
    x*=200000;
    x+=y;
    return x;
}
int mp[220][220];

double dis(node a,node b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int judgeline(node a,node b,node c)//判断线段共线 注意垂直的时候斜率为0  要单独判断啊
{
    double x,y,z,t;
    x=a.x-c.x;
    y=a.y-c.y;
    z=b.x-c.x;
    t=b.y-c.y;
    if((t<1e-8&&t>-1e-8)&&(y<1e-8&&y>-1e-8))return 1;
    else
    {
        if((t<1e-8&&t>-1e-8)||(y<1e-8&&y>-1e-8))return 0;
        t=(x/y)-(z/t);
        return (t<1e-8&&t>-1e-8);
    }
}
int subjudge(node a,node b,node c)//判断三角形
{
    double x,y,z;
    x=dis(a,b);
    y=dis(a,c);
    z=dis(b,c);
    if(x+y-z>1e-8&&x+z-y>1e-8&&y+z-x>1e-8)
        return 1;
    else return 0;
}
int judge(int a,int b,int c) //判断3个点的关系是否满足
{
    if(mp[a][b]&&mp[a][c]&&mp[b][c])
        return subjudge(point[a],point[b],point[c]);
    else return 0;
}
int main()
{
    int n,m,a,b,i,j,k,sum;
    double x1,y1,x2,y2;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        pp.clear();//这里清零很重要不要再忘记了
        for(i=0;i<n;i++)
        {
            scanf("%lf%lf",&point[i].x,&point[i].y);
            yy[i]=get(point[i].x,point[i].y); //点hash
            pp[yy[i]]=i; //点与序号的映射
        }
        memset(mp,0,sizeof(mp));
        for(i=0;i<m;i++) //建立邻接矩阵
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            a=pp[get(x1,y1)];
            b=pp[get(x2,y2)];
            mp[a][b]=1;
            mp[b][a]=1;
        }
        for(i=0;i<n;i++) //点疏松
        {
            for(j=0;j<n;j++)
            {
                if(i!=j)
                {
                    for(k=0;k<n;k++)
                    {
                        if(i!=k&&i!=j&&j!=k)
                        {
                            if(!mp[j][k]&&mp[i][j]&&mp[i][k]&&judgeline(point[i],point[j],point[k]))
                                mp[j][k]=1,mp[k][j]=1;
                        }
                    }
                }
            }
        }
        sum=0;
        for(i=0;i<n;i++) //三角形枚举并判断
            for(j=i+1;j<n;j++)
                for(k=j+1;k<n;k++)
                    sum+=judge(i,j,k);
                printf("%d\n",sum);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/zsboy/archive/2013/03/12/2955129.html