Smallest distance between pair of points

#include<iostream>
#include<stdio.h>
#include <bits/stdc++.h> 
using namespace std;

//class to declare the point's coordinates 
class Point  
{  
    public: 
    int x, y;  
};  

//sort x coordinates
int sort_x(const void* a, const void* b)  
{  
    Point *p1 = (Point *)a, *p2 = (Point *)b;  
    return (p1->x - p2->x);  
}  
  
//sort y coordinates  
int sort_y(const void* a, const void* b)  
{  
    Point *p1 = (Point *)a, *p2 = (Point *)b;  
    return (p1->y - p2->y);  
}  

//euclidian distance calcualtion
float euclidian_dist(Point p1, Point p2)
{
    
    float dist,x,y;
    x=p1.x-p2.x;
    y=p1.y=p2.y;
	dist = sqrt(pow(x, 2) + pow(y, 2));

	return dist;   
}

//Brute force method
float BF_method(Point P[], int n)  
{  
    int i,j;
    float min;
    min=FLT_MAX;  
    for (i = 0; i < n; i++)  
        for (j = i+1; j < n; j++)  
            if (euclidian_dist(P[i], P[j]) < min)  
                min = euclidian_dist(P[i], P[j]);  
    return min;  
} 

//Finding the minimum value
float min(float x, float y)  
{  
    if (x<y)
        return x;
    else
        return y;
}  

//Finding the closest distance, on the basis of sorting the y-coordinates
float closest_distance(Point R[], int n, float d)  
{  
    int i,j;
    float min;
    
    min=d; 
    qsort(R, n, sizeof(Point), sort_y);  

    for (i = 0; i < n; i++)  
        for (j = i+1; j < n && ((R[j].y - R[i].y) < min); j++)  
            if (euclidian_dist(R[i],R[j]) < min)  
                min = euclidian_dist(R[i], R[j]);  
  
    return min;  
}  

//Choosing and performing the appropriate method
float method(Point P[], int n)
{
    int i,j;
    float d_left, d_right,d;
    
    if(n<=3)
        return BF_method(P, n);
    
    // finding the middle value
    int mid=n/2;
    Point mid_p=P[mid];
    
    d_right=method(P + mid, n - mid);
    d_left=method(P, mid);  
    d=min(d_left,d_right);  
  
    //Array of points that are closer to the middle line within the minimum disatnce d
    Point R[n];  
    j=0;
    for (i = 0; i < n; i++)  
        if (abs(P[i].x - mid_p.x) < d)  
        {    R[j] = P[i];
             j++;
        }
     return min(d, closest_distance(R, j, d) );
}  
  
float closest(Point P[], int n)  
{  
    qsort(P, n, sizeof(Point), sort_x);  
    return method(P, n);  
}  


int main()
{  
    Point P[] = {{1, 3}, {12, 20}, {30, 40}, {4, 2}, {8, 15}, {2, 5}};  
    int n = sizeof(P) / sizeof(P[0]);  
    cout << "Smallest distance: "<<method(P, n);

    return 0;  
}