最近点对问题

 

开始

划分点集为：左点集S1，右点集S2

构造点集

判断点集的点个数是否小于4

左点集S1，右点集S2

开始

划分点集为：左点集S1，右点集S2

构造点集

判断点集的点个数是否小于4

左点集S1，右点集S2

//点结构

typedef    struct Pair

{

       int           x ;

       int           y ;

} Pair ;

//最近点对结构

typedef    struct Closest_Pair

{

       Pair  pair_a ,pair_b ;

       double            distance ;

} Closest_Pair ;

//点对结构

typedef    struct Points

{

       Pair*       p_pair ;

       int           pair_nums ;//点对数目

} Points

 

//蛮力法：分别计算每一对点之间的距离，然后找距离最小的那一对

bool Brute_Force(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)

{

       for(int i=from ;i<=to ;++i)

       {

              for(int j=i+1;j<=to ;++j)

              {

                     double     next= Account_Distance_2(points.p_pair[i] ,points.p_pair[j]) ;                 if(closest_pair.distance > next )

                     {

                            closest_pair.pair_a = points.p_pair[i] ;

                            closest_pair.pair_b = points.p_pair[j] ;

                            closest_pair.distance = next ;

                     }

              }

       }           

       return      true ;

}

//分治法：遵循分治方法，利用递归求出左子集和右子集的最近点对，然后再对两子集之间点对进一步分析比较，最后求出整个点集最近点对。

void Divide_and_Conquer(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)

{

       if( (to-from+1) <4 )

       {

                     Brute_Force(points ,closest_pair ,from ,to ) ;

                     cout << "<4    " << closest_pair.distance << endl  ;

                     //system("pause") ;

       }

       else

       {

              int           mid = (from+to)/2 ;

              int           mid_value = points.p_pair[mid].x ;

 

              Divide_and_Conquer(points ,closest_pair ,from ,mid) ;

              Divide_and_Conquer(points ,closest_pair ,mid+1 ,to) ;

              Comp_CP(points ,closest_pair ,mid ,mid_value) ;             

       }

      

       return      ;

}

 

#include "Head.h"

 //---------------------------------------------------------------------------

typedef int             RedType ;

typedef    struct Pair

{

       int           x ;

       int           y ;

} Pair ;

typedef    struct Closest_Pair

{

       Pair  pair_a ,pair_b ;

       double            distance ;

} Closest_Pair ;

typedef    struct Points

{

       Pair*       p_pair ;

       int           pair_nums ;//点对数目

} Points ;

 //---------------------------------------------------------------------------

 

Points     points ;   

Closest_Pair    closest_pair ; 

//int         pair_nums ;

 //---------------------------------------------------------------------------

double            Account_Distance_2(const Pair& A ,const Pair& B )

{

 

       return             ( (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y) ) ;

}

 //---------------------------------------------------------------------------

void Print_Points(ostream& outs ,const Points& points ,const Closest_Pair&   closest_pair )

{

       outs << "/n/n/n       随机产生点对如下：/n"  ;

       for(int i=0 ;i<points.pair_nums ;++i)

       {

              outs << "   (" << points.p_pair[i].x << " , " << points.p_pair[i].y << " ) "  ;

              if((i+1)%5==0)

              {

                     outs << endl ;

              }

       }

       outs << "/n/n  由以上点对可得最近点对为： ( "

               << closest_pair.pair_a.x << " , " << closest_pair.pair_a.y << " ) ,( "

               << closest_pair.pair_b.x << " , " << closest_pair.pair_b.y << " ) " ;

       outs << "/n     该点对距离为：" << closest_pair.distance << endl ;

}

 //---------------------------------------------------------------------------

bool Brute_Force(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)

{

       for(int i=from ;i<=to ;++i)

       {

              for(int j=i+1;j<=to ;++j)

              {

                     double            next = Account_Distance_2(points.p_pair[i] ,points.p_pair[j]) ;//sqrt(  )

                     if(closest_pair.distance > next )

                     {

                            closest_pair.pair_a = points.p_pair[i] ;

                            closest_pair.pair_b = points.p_pair[j] ;

                            closest_pair.distance = next ;

                     }

              }

       }    

      

       return      true ;

}

 //--------------------------------------------------------------------------

// 对顺序表L作归并排序。

 void Merge(char sign ,Pair SR[] ,Pair TR[] ,long i ,long m ,long n)

 { // 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]

   //int j,k,l;

   for(int j=m+1,k=i;i<=m&&j<=n;++k) // 将SR中记录由小到大地并入TR

   {    

          if(sign=='x')

          {

                 if ( SR[i].x < SR[j].x )

                            TR[k]=SR[i++];

                 else

                            TR[k]=SR[j++];

          }

          else

          {

                 if ( SR[i].y < SR[j].y )

                            TR[k]=SR[i++];

                 else

                            TR[k]=SR[j++];

          }      

   }

   if(i<=m)

   {

     for(int l=0;l<=m-i;l++)

        {

       TR[k+l]=SR[i+l]; // 将剩余的SR[i..m]复制到TR        

        }

   }

   else

   {

     for(int l=0;l<=n-j;l++)

        {

       TR[k+l]=SR[j+l]; // 将剩余的SR[j..n]复制到TR

        

        }

   }  

 }

 //---------------------------------------------------------------------------

 void MSort(char sign ,Pair SR[] ,Pair TR1[] ,long s , long t)

 { // 将SR[s..t]归并排序为TR1[s..t].

      

       if(s==t)

       {

              TR1[s] = SR[s];

       }

       else

       {

              //int         m ;

              int           length = t-s+1 ;//

              Pair* TR2 = new           Pair[points.pair_nums];

              long m = (s+t)/2; // 将SR[s..t]平分为SR[s..m]和SR[m+1..t]

              MSort(sign ,SR,TR2,s,m) ; // 递归地将SR[s..m]归并为有序的TR2[s..m]

              MSort(sign ,SR,TR2,m+1,t) ; // 递归地将SR[m+1..t]归并为有序的TR2[m+1..t]

              Merge(sign ,TR2,TR1,s,m,t) ; // 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]

 

              delete[]    TR2 ;

       }

      

       //            cout << " Hello       " ;

      

 }

 //---------------------------------------------------------------------------

 

void Comp_CP(const Points& points ,Closest_Pair& closest_pair ,int       mid ,int mid_value)

{

       int           i , j ;

       int           distance = sqrt( closest_pair.distance ) ;

       i = mid ;

       while( i >= 0 && points.p_pair[i].x > (mid_value-distance) )

       {

              j = mid ;

              while( points.p_pair[++j].x < (mid_value+distance) && j < points.pair_nums )

              {

                     if( points.p_pair[j].y > (points.p_pair[i].y+distance) ||

                            points.p_pair[j].y < (points.p_pair[i].y-distance) )

                            //判断在y轴是否出界

                            continue ;

                     double            next = Account_Distance_2( points.p_pair[i] ,points.p_pair[j]);//sqrt( ) 

                     if(closest_pair.distance > next )

                     {

                            closest_pair.pair_a = points.p_pair[i] ;

                            closest_pair.pair_b = points.p_pair[j] ;

                            closest_pair.distance = next ;                     

                            cout << "Comp_CP:      " << closest_pair.distance << endl  ;

                     }

             

              }

              i-- ;

       }

}

 //---------------------------------------------------------------------------

void Divide_and_Conquer(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)

{

       if( (to-from+1) <4 )

       {

                     Brute_Force(points ,closest_pair ,from ,to ) ;

                     cout << "<4    " << closest_pair.distance << endl  ;

                     //system("pause") ;

       }

       else

       {

              int           mid = (from+to)/2 ;

              int           mid_value = points.p_pair[mid].x ;

 

              Divide_and_Conquer(points ,closest_pair ,from ,mid) ;

              Divide_and_Conquer(points ,closest_pair ,mid+1 ,to) ;

              Comp_CP(points ,closest_pair ,mid ,mid_value) ;             

       }

      

       return      ;

}

 //---------------------------------------------------------------------------

void main()

{

       time_t t;

    srand((unsigned) time(&t));

              char c ;

       do

       {

              system("cls") ;

 

              cout << "/n/n  请输入你要随机产生点对的对数： " ;

              cin >> points.pair_nums ;

              points.p_pair = new Pair[points.pair_nums] ;

 

              for(int i=0 ;i<points.pair_nums ;++i)

              {

                     points.p_pair[i].x= rand()%101 ;

                     points.p_pair[i].y= rand()%101 ;

              }

              //分治法求解，先排序

              MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;

       /*//

                     */

              //蛮力法求解

              closest_pair.distance = 32676 ;//MAX_SIZE

              Brute_Force(points ,closest_pair ,0 ,points.pair_nums-1 ) ;

              closest_pair.distance = sqrt( closest_pair.distance ) ;

              Print_Points( cout , points ,closest_pair ) ;

 

              //分治法求解，先排序

              //MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;

 

              //分治法求解        

              closest_pair.distance = 32676 ;//MAX_SIZE

              Divide_and_Conquer(points ,closest_pair ,0 ,points.pair_nums-1 ) ;

              closest_pair.distance = sqrt( closest_pair.distance ) ;

              Print_Points( cout , points ,closest_pair ) ;

 

              //MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;

 

       //     Print_Points( cout , points ,closest_pair ) ;

             

              cout << "/n/n  !!!按任意键继续，Esc退出程序!!!" << endl ;

 

       }while( (c=getch())!=27 ) ;

       return      ;

}

 //---------------------------------------------------------------------------

 

1. #include "Head.h" 
2.  //---------------------------------------------------------------------------
3. typedef int     RedType ;
4. typedef struct Pair
5. {
6.     int     x ;
7.     int     y ;
8. } Pair ;
9. typedef struct Closest_Pair
10. {
11.     Pair    pair_a ,pair_b ;
12.     double      distance ;
13. } Closest_Pair ;
14. typedef struct Points
15. {
16.     Pair*   p_pair ;
17.     int     pair_nums ;//点对数目
18. } Points ;
19.  //---------------------------------------------------------------------------
21. Points  points ;    
22. Closest_Pair    closest_pair ;  
23. //int       pair_nums ;
24.  //---------------------------------------------------------------------------
25. double      Account_Distance_2(const Pair& A ,const Pair& B )
26. {
28.     return      ( (A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y) ) ;
29. }
30.  //---------------------------------------------------------------------------
31. void    Print_Points(ostream& outs ,const Points&   points ,const Closest_Pair& closest_pair )
32. {
33.     outs << "/n/n/n 随机产生点对如下：/n"  ;
34.     for(int i=0 ;i<points.pair_nums ;++i)
35.     {
36.         outs << "   (" << points.p_pair[i].x << " , " << points.p_pair[i].y << " ) "  ;
37.         if((i+1)%5==0)
38.         {
39.             outs << endl ;
40.         }
41.     }
42.     outs << "/n/n   由以上点对可得最近点对为： ( " 
43.          << closest_pair.pair_a.x << " , " << closest_pair.pair_a.y << " ) ,( " 
44.          << closest_pair.pair_b.x << " , " << closest_pair.pair_b.y << " ) " ;
45.     outs << "/n 该点对距离为：" << closest_pair.distance << endl ;
46. }
47.  //---------------------------------------------------------------------------
48. bool    Brute_Force(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)
49. {
50.     for(int i=from ;i<=to ;++i)
51.     {
52.         for(int j=i+1;j<=to ;++j)
53.         {
54.             double      next = Account_Distance_2(points.p_pair[i] ,points.p_pair[j]) ;//sqrt(  )
55.             if(closest_pair.distance > next )
56.             {
57.                 closest_pair.pair_a = points.p_pair[i] ;
58.                 closest_pair.pair_b = points.p_pair[j] ;
59.                 closest_pair.distance = next ;
60.             }
61.         }
62.     }   
63.     
64.     return  true ;
65. }
66.  //--------------------------------------------------------------------------
67. // 对顺序表L作归并排序。
68.  void Merge(char sign ,Pair SR[] ,Pair TR[] ,long i ,long m ,long n)
69.  { // 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 
70.    //int j,k,l;
71.    for(int j=m+1,k=i;i<=m&&j<=n;++k) // 将SR中记录由小到大地并入TR
72.    {     
73.        if(sign=='x')
74.        {
75.            if ( SR[i].x < SR[j].x )
76.                 TR[k]=SR[i++];
77.            else
78.                 TR[k]=SR[j++];
79.        }
80.        else
81.        {
82.            if ( SR[i].y < SR[j].y )
83.                 TR[k]=SR[i++];
84.            else
85.                 TR[k]=SR[j++];
86.        }     
87.    }
88.    if(i<=m)
89.    {
90.      for(int l=0;l<=m-i;l++)
91.      {
92.        TR[k+l]=SR[i+l]; // 将剩余的SR[i..m]复制到TR      
93.      }
94.    }
95.    else
96.    {
97.      for(int l=0;l<=n-j;l++)
98.      {
99.        TR[k+l]=SR[j+l]; // 将剩余的SR[j..n]复制到TR
100.       
101.      }
102.    }   
103.  }
104.  //---------------------------------------------------------------------------
105.  void MSort(char sign ,Pair SR[] ,Pair TR1[] ,long s , long t)
106.  { // 将SR[s..t]归并排序为TR1[s..t].
107.     
108.     if(s==t)
109.     {
110.         TR1[s] = SR[s];
111.     }
112.     else
113.     {
114.         //int       m ;
115.         int     length = t-s+1 ;// 
116.         Pair* TR2 = new     Pair[points.pair_nums];
117.         long    m = (s+t)/2; // 将SR[s..t]平分为SR[s..m]和SR[m+1..t]
118.         MSort(sign ,SR,TR2,s,m) ; // 递归地将SR[s..m]归并为有序的TR2[s..m]
119.         MSort(sign ,SR,TR2,m+1,t) ; // 递归地将SR[m+1..t]归并为有序的TR2[m+1..t]
120.         Merge(sign ,TR2,TR1,s,m,t) ; // 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
122.         delete[]    TR2 ;
123.     }
124.     
125.     //      cout << "   Hello   " ;
126.     
127.  }
128.  //---------------------------------------------------------------------------
130. void    Comp_CP(const Points& points ,Closest_Pair& closest_pair ,int   mid ,int mid_value)
131. {
132.     int     i , j ; 
133.     int     distance = sqrt( closest_pair.distance ) ;
134.     i = mid ;
135.     while( i >= 0 && points.p_pair[i].x > (mid_value-distance) ) 
136.     {
137.         j = mid ;
138.         while( points.p_pair[++j].x < (mid_value+distance) && j < points.pair_nums )
139.         {
140.             if( points.p_pair[j].y > (points.p_pair[i].y+distance) || 
141.                 points.p_pair[j].y < (points.p_pair[i].y-distance) )
142.                 //判断在y轴是否出界
143.                 continue ;
144.             double      next = Account_Distance_2( points.p_pair[i] ,points.p_pair[j]);//sqrt( )  
145.             if(closest_pair.distance > next )
146.             {
147.                 closest_pair.pair_a = points.p_pair[i] ;
148.                 closest_pair.pair_b = points.p_pair[j] ;
149.                 closest_pair.distance = next ;              
150.                 cout << "Comp_CP:   " << closest_pair.distance << endl  ;
151.             }
152.         
153.         } 
154.         i-- ;
155.     } 
156. }
157.  //---------------------------------------------------------------------------
158. void    Divide_and_Conquer(const Points& points ,Closest_Pair& closest_pair ,int from ,int to)
159. {
160.     if( (to-from+1) <4 )
161.     {
162.             Brute_Force(points ,closest_pair ,from ,to ) ;
163.             cout << "<4 " << closest_pair.distance << endl  ;
164.             //system("pause") ;
165.     }
166.     else
167.     {
168.         int     mid = (from+to)/2 ;
169.         int     mid_value = points.p_pair[mid].x ;
171.         Divide_and_Conquer(points ,closest_pair ,from ,mid) ;
172.         Divide_and_Conquer(points ,closest_pair ,mid+1 ,to) ;
173.         Comp_CP(points ,closest_pair ,mid ,mid_value) ;     
174.     }
175.     
176.     return  ;
177. }
178.  //---------------------------------------------------------------------------
179. void    main()
180. {
181.     time_t t;
182.     srand((unsigned) time(&t));
183.         char c ;
184.     do
185.     {
186.         system("cls") ;
188.         cout << "/n/n   请输入你要随机产生点对的对数： " ;
189.         cin >> points.pair_nums ;
190.         points.p_pair = new Pair[points.pair_nums] ;
192.         for(int i=0 ;i<points.pair_nums ;++i)
193.         {
194.             points.p_pair[i].x= rand()%101 ;
195.             points.p_pair[i].y= rand()%101 ;
196.         }
197.         //分治法求解，先排序
198.         MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;
199.     /*//
200.             */
201.         //蛮力法求解
202.         closest_pair.distance = 32676 ;//MAX_SIZE
203.         Brute_Force(points ,closest_pair ,0 ,points.pair_nums-1 ) ;
204.         closest_pair.distance = sqrt( closest_pair.distance ) ;
205.         Print_Points( cout , points ,closest_pair ) ;
207.         //分治法求解，先排序
208.         //MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;
210.         //分治法求解     
211.         closest_pair.distance = 32676 ;//MAX_SIZE
212.         Divide_and_Conquer(points ,closest_pair ,0 ,points.pair_nums-1 ) ;
213.         closest_pair.distance = sqrt( closest_pair.distance ) ;
214.         Print_Points( cout , points ,closest_pair ) ;
216.         //MSort('x' ,points.p_pair ,points.p_pair ,0 ,points.pair_nums-1 ) ;
218.     //  Print_Points( cout , points ,closest_pair ) ;
219.         
220.         cout << "/n/n   !!!按任意键继续，Esc退出程序!!!" << endl ;
222.     }while( (c=getch())!=27 ) ;
223.     return  ;
224. }
225.  //---------------------------------------------------------------------------