算法设计与分析 ------最近对问题与8枚硬币问题

 利用减治法实现8枚硬币问题：

参考资料：http://blog.csdn.net/wwj_748/article/details/8863503    算法设计--八枚硬币问题

#include "stdafx.h"
#include <iostream>
#include <stdio.h>
using namespace std;


void eightcoin(int arr[]);
void compare(int a,int b,int real,int index1,int index2);//这句话是为了在两个当中比较谁真，谁假。
void print(int jia,int zhen,int i);//这句话是为了输出在某个位置的假硬币的信息。
int main()
{
    int arr[8];
    //分别输入8枚硬币的重量
    while(1)
    {
        for(int i=0; i<8; ++i)
        {
            cin >> arr[i];
        }
        eightcoin(arr);
    }    
    return 0;
}
void eightcoin(int arr[])
{
    int abc = arr[0] + arr[1] + arr[2];
    int def = arr[3] + arr[4] + arr[5];
    int a = arr[0];
    int b = arr[1];
    int c = arr[2];
    int d = arr[3];
    int e = arr[4];
    int f = arr[5];
    int g = arr[6];
    int h = arr[7];

    if (abc > def) //6枚硬币必有一枚假币，g,h为真币 
    {
        if ((a+e) > (d+b))//去掉c,f，且b，e互换后，没有引起天平变化，说明假币必然是a，d中的一个  
        {
            compare(a,d,g,0,3);
        }
        else if ((a+e) == (d+b))
        {
            compare(c,f,g,2,5);
        }
        else 
        {
            compare(b,e,g,1,4);
        }
    }
    else if (abc == def)
    {
            compare(g,h,a,6,7);   
    }
    else
    {
        if ((a+e) > (d+b))
        {
            compare(b,e,g,1,4);
        }
        else if ((a+e) == (d+b))
        {
            compare(c,f,g,2,5);
        }
        else 
        {
            compare(a,d,g,0,3);
        }
    }
}



void compare(int a,int b,int real,int index1,int index2)
{
    if( a > real)
        print(a,real,index1);
    else
        print(b,real,index2);
}
void print(int jia,int zhen,int i)
{
    if (jia > zhen)
    {
        cout << "位置在："<< i+1 << "是假币" << "且较重！" << endl;
    }
    else
    {
        cout << "位置在："<< i+1 << "是假币" << "且较轻！" << endl;
    }
}

利用蛮力法与分治法实现最近对问题：

参考资料：http://wenku.baidu.com/link?url=49Zq90UzxulQCJTtKfgum_6lAohBWHnynyr7jbHlXrT0z1SGIFLkJZYEPkuKrZ9aMjJLf0EZQfvjrL3b9QksbFKO6hsist_HDOT1gV72nVe

http://blog.sina.com.cn/s/blog_6364615e0100o67v.html

 参考了我前面的一篇日志，sort的用法。

// ClosestPoints.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <time.h>
#include <math.h>
#include <iostream>
#include <algorithm>
using namespace std;
typedef struct Point   //定义数据结构
{
   long x;
   long y;
} Point;
Point points[200],P1[100],P2[100];
const long MAX = 6000000;

int cmp(Point a, Point b)   //对平面内的坐标进行有规则的排序
{
   if (a.x != b.x)
   {
       return a.x < b.x;
   }
   else
   {
       return a.y < b.y;
   }
}

int cmp2(Point a, Point b)   //升序排列
{
    return a.y < b.y;
}
long Distance(Point a,Point b)
{
    long dist = (a.x - b.x)*(a.x - b.x) + (a.y - a.y)*(a.y - b.y);
    return dist;
}

//int min1(int a,int b)
//{
//    if (a>b)
//    {
//        return b;
//    }
//    else
//    {
//        return a;
//    }
//}
//蛮力法，每个都找一遍，两两寻找
long ClosestPoints(Point points[],int n,int *index1,int *index2)
{
    long minDist = MAX;
    long Dist = 0;
    for (int i=0; i<n; ++i)
   {
       for (int j=i+1; j<n; ++j)
       {
           Dist = Distance(points[i],points[j]);
           if (Dist < minDist)
           {
               minDist = Dist;
               *index1 = i;
               *index2 = j;
           }
       }
   }
    return minDist;
}


//分治法函数
long DivPoints(Point points[],int begin,int end)
{
   int n = end - begin + 1;
   int m = (end + begin)/2;
   if (n == 2)
   {
       return Distance(points[begin],points[end]);
   }
   if (n == 3)   //三者当中找最小
   {
       long d1 = Distance(points[begin],points[begin+1]);
       long d2 = Distance(points[begin],points[end]);
       long d3 = Distance(points[begin+1],points[end]);
       if (d1<=d2 && d1<= d3)
       {
           return d1;
       }
       else if (d2 <= d3)
       {
           return d2;
       }
       else 
           return d3;
   }
   long left = DivPoints(points,begin,m);
   long right = DivPoints(points,m+1,end);
   long d = min(left,right);
   int k1 = 0, k2 = 0;
   for (int i = begin ; i <= m; ++i)      //中位数的左边区域
   {
        if (points[m].x - points[i].x<sqrt((float)d))
        {
            P1[k1].x = points[i].x;
            P1[k1].y = points[i].y;
            k1++;//在有两个以上的变量进行赋值的时候，不能用这个。而用此赋值方法
        }
   }
   for (int i = m + 1 ; i <= end; ++i)   //中位数的右边区域，分割成两个P1与P2数组
   {
        if (points[i].x - points[m].x<(int)sqrt((float)d))
        {
            P2[k2].x = points[i].x;
            P2[k2].y = points[i].y;
                k2++;
        }
   }
   
   //page 90 ，需要依据y进行升序排列，然后两两比较，找出最小
  sort(P1,P1+k1,cmp2);
  sort(P2,P2+k2,cmp2);
  long dist=0;
  long dMin=MAX;
  for (int i = 0; i < k1 ; ++i)    //排序之后找里面最小的，这个部分是合并部分的工作。
  {
      for (int j = 0; j < k2; ++j)
      {
          dist = Distance(P1[i],P2[j]);
          dMin = min(dist,dMin);//递归求最小距离
      }
  }



   //int k,l,flag=0;//k与l分别是记录左右两边<d的点的位置
   ////找到以m为中心与m横坐标距离小于sqrt（d）的点
   //for(int i = begin; i <= end; ++i)
   //{
      // if (flag == 0 && (points[m].x - points[i].x<sqrt(d)))//遍历左半部分
      // {
   //       flag = 1;
   //       k = i;
      // }
      // if (flag == 1 &&(points[i].x - points[m].x<sqrt(d)))//遍历右半部分
      // {
   //       l = i;
      // }
   //}
   //for (i = k ; i <= m; ++i)
   //{
      // for (j=m+1; j<=1 && fabs((points[j].y-points[i].y)<sqrt(d)); ++j)
      // {
         //  if (Distance(points[i],points[j]) <= d)
         //  {
            //   d = Distance(points[i],points[j]);
         //  }
      // }
   //}
   return min(d,dMin);   //比较d与dMin的大小，并返回，合并。
}



int _tmain(int argc, _TCHAR* argv[])
{
    
    LARGE_INTEGER frequency,begin,end;

    while (1)
 {
    int n;
    cout << "随机生成n个点"<<endl;
    cin >> n;
    cout << "随机生成"<<n<<"个点的X与Y坐标如下："<<endl;
    /*
      srand()的功能就是就是设置产生随机数的公式的参数（随机数种子），如果使用相同的种子，
      那么得到的随机数也就是相同的。自然，如果使用不同的种子，得出的随机数序列也是不同的。
      不同的种子会得到 固定 的 不同的随机数序列。
    */
    srand((unsigned int)time(0));//产生不同的随机数
    for (int i=0; i<n;++i)
    {
        points[i].x = rand();
        points[i].y = rand();
        cout << points[i].x << "," << points[i].y <<" ";
    }
    cout << endl;

    int index1 = 0;
    int index2 = 0;
    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&begin);
    long minDist = ClosestPoints(points,n,&index1,&index2);
    QueryPerformanceCounter(&end);
    cout << "蛮力法所用时间为"<< (double)(end.QuadPart - begin.QuadPart)/frequency.QuadPart<<endl;
    cout << "最短距离为"<< minDist <<endl;
    /*cout << points[index1].x << " "<< points[index1].y << endl;
    cout << points[index2].x << " "<< points[index2].y << endl;*/


    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&begin);
    
    sort(points,points+n,cmp);//当成数组
    minDist = DivPoints(points,0,n-1);
    QueryPerformanceCounter(&end);
    cout << "分治法所用时间为"<< (double)(end.QuadPart - begin.QuadPart)/frequency.QuadPart<<endl;
    cout << "最短距离为"<< minDist <<endl;

  }
    return 0;
}