hdu1435 稳定婚姻问题

题意：

Stable Match

Special Judge

Problem Description

Network 公司的BOSS 说现在他们公司建立的信号发射站和接收站经常出现信号发送接收不稳定的问题,信号的稳定度被定义为发射点到接收点的距离,距离越大,越不稳定,所以发射点跟接收点在可能的情况下应越近越好.

BOSS给8600的任务就是：:建立一个匹配表,使得一个发射点对应一个接收点,对于某一个发射点来说,它的接收点离它越近那么就会更稳定,同样对于接收点也是一样的情况. 匹配的目标是使得整个网络变得稳定。,对于某2个匹配,比如,( a ---- 1) ,(b----2) ,如果发射点a 离接收点2 比 1要近,而且2 也离 发射点a要比 b 近, 那么 a 就很有可能把信号发到 2中,我们就说这个搭配是不 稳定的。同样如果发射点b 离接收点1 比 2 要近,而且1 也离 发射点b要比 a 近 ,也会出现不稳定的情
况. 而且每个点都有一个容量值,如果对于一个发射点到2个接收点的距离一样的话,它将首先选择容量大的那个. 所以8600就是要建立一个稳定的匹配,使得每个一个信号发射点对应一个接收点,并且不会出现信号不稳定的情况.

8600苦思冥想也没什么进展,希望你能帮他解决这个难题.

Input

输入数据首先包含一个正整数N,N<=20表示测试实例的个数.每个实例首先是一个整C,C<=200表示有C个信号发射点和C个信号接收点. 接下来的C行表示 C个发射点的编号,容量和坐标,坐标为,x,y,z 3个实数(x,y,z ≥0).最后C行是C个接收点的编号,容量和坐标.

Output

输出建立稳定搭配后各个发射点和接收点的编号,每一行代表一个搭配,前一个整数为发射点的编号，后一个为对应的接收点的编号。如果有多种情况，输出其中一种即可.如果任务不可能完成的话,输出"Impossible".每个实例后请输出一个空行.

Sample Input

1
3
1 1 60.57 57.16 69.27
2 2 26.05 61.06 11.52
3 3 9.04 58.20 56.90
1 2 280.74 12.78 316.14
2 3 305.16 267.15 87.65
3 1 240.72 312.41 217.10

Sample Output

3 1
1 2
2 3

思路：

      稳定婚姻问题，先说明下，这个题目虽然是中文的，读了好几遍才读懂，还有就是题目没有叙述全吧，就是应该加上 如果接受者面临两个距离一样的发射者，那么他要选择权值权值大的发射者，这个没说，整的我以为发射者的权值没用呢，后来排序的时候发现会有问题，自己加上去的，还有就是这个题目不存在 Impossible 的情况，因为稳定婚姻问题肯定有解的，然后就是细微的地方，去处理每个接受者在发射者心中的地位，和每个发射者在接受者心中的地位，然后就是稳定婚姻问题了，下面我粘贴下我刚刚写好的自己对稳定婚姻的理解，本题用到的算法较容易实现，所以我的是我自己手写的，看着不舒服的可以去网上找找正规模板啥的。

稳定婚姻问题就是给你n个男的，n个女的，然后给你每个男生中女生的排名，和女生心目中男生的排名，然后让你匹配成n对，使婚姻稳定，假如a和b匹配,c和d匹配，如果a认为d比b好，同时d也认为a比c好，那么ad就有可能私奔，这样就导致了婚姻的不稳定，稳定婚姻就是找到一种解决方案让婚姻稳定

算法：

      稳定婚姻的解决方法比较简单，通俗易懂，而且还容易实现，具体有没有固定的模板我不知道，没有去找，自己模拟的，在求解的过程中，我们先把所有的男生都加到队列里，队列里的就表示当前还单身的男生，每次从队列里拿出一个男生，然后从她最喜欢的女生开始匹配，如果当前的女生尝试追求过，那么就不用追求了，如果当前的女生没有伴侣，那么可以直接匹配上，如果有伴侣，那么就看看当前这个男生和女生之前的伴侣在那个女生中更喜欢谁，如果更喜欢当先的这个男生，那么当前男生就和这个女生匹配，女生之前匹配过的直接变成单身，被扔回队列，否则，继续找下一个女生，知道找到一个能匹配上的为止，就这样一直到队列空的时候，就已经全部匹配完成了。

正确性：

        对于男生来说，每次都是从最喜欢的女生开始匹配的，遇到的第一个没人能抢走的并且稳定的就是自己最终伴侣，也就是说如果之前追求过的女生被别人抢走了，那么他将永远抢不会来，因为对于女生来说，第一次被男士按照自己的意愿选择之后，每次变更匹配对象都是在自己心目中更加喜欢的，所以一旦他放弃了某个男生，那么那个男生就没希望在和他匹配，这样男生是从最优的选的，保证男生不会出轨，女生每次都是在选择她的男生中选择最优的，这样也保证了女生最后没有怨言，这样的话，最后的到的婚姻就是稳定的，至于稳定婚姻，肯定会有稳定方案，这个我暂时证明不了.<1962年，美国数学家
David Gale 和 Lloyd Shapley是这两个人发明的方法，并且证明了稳定婚姻一定会有解>。

#include<queue>
#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>

#define N 200 + 5

using namespace std;

typedef struct
{
   int num ,v;
   double x ,y ,z;
}NODE;

typedef struct
{
   double dis;
   int v ,id;
}ZT;

NODE node1[N] ,node2[N];
ZT zt[N];
int map[N][N] ,G_b[N][N];
int nowb[N] ,nowg[N];
int mark[N][N];

bool camp(ZT a ,ZT b)
{
   return a.dis < b.dis || a.dis == b.dis && a.v > b.v;
}

void Marr(int n)
{
   queue<int>q;
   for(int i = 1 ;i <= n ;i ++)
   q.push(i);
   memset(mark ,0 ,sizeof(mark));
   memset(nowb ,255 ,sizeof(nowb));
   memset(nowg ,255 ,sizeof(nowg));
   while(!q.empty())
   {
      int xin ,tou = q.front();
      q.pop();
      for(int i = 1 ;i <= n ;i ++)
      {
         xin = map[tou][i];
         if(mark[tou][xin]) continue;
         mark[tou][xin] = 1;
         if(nowg[xin] == -1)
         {
            nowg[xin] = tou;
            nowb[tou] = xin;
            break;
         }
         else
         {
            if(G_b[xin][tou] > G_b[xin][nowg[xin]])
            {
               q.push(nowg[xin]);
               nowg[xin] = tou;
               nowb[tou] = xin;
               break;
            }
         }
      }
   }
   return;
}

double get_dis(NODE a ,NODE b)
{
   double xx = (a.x - b.x) * (a.x - b.x);
   double yy = (a.y - b.y) * (a.y - b.y);
   double zz = (a.z - b.z) * (a.z - b.z);
   return xx + yy + zz;
}

int main ()
{
   int t ,n ,i ,j;
   scanf("%d" ,&t);
   while(t--)
   {
      scanf("%d" ,&n);
      for(i = 1 ;i <= n ;i ++)
      scanf("%d %d %lf %lf %lf" ,&node1[i].num ,&node1[i].v ,&node1[i].x ,&node1[i].y ,&node1[i].z);
      for(i = 1 ;i <= n ;i ++)
      scanf("%d %d %lf %lf %lf" ,&node2[i].num ,&node2[i].v ,&node2[i].x ,&node2[i].y ,&node2[i].z);
      for(i = 1 ;i <= n ;i ++)
      {
         for(j = 1 ;j <= n ;j ++)
         {
            zt[j].dis = get_dis(node1[i] ,node2[j]);
            zt[j].v = node2[j].v;
            zt[j].id = j;
         }
         sort(zt + 1 ,zt + n + 1 ,camp);
         for(j = 1 ;j <= n ;j ++)
         map[i][j] = zt[j].id;
      }
      for(i = 1 ;i <= n ;i ++)
      {
         for(j = 1 ;j <= n ;j ++)
         {
            zt[j].dis = get_dis(node2[i] ,node1[j]);
            zt[j].v = node1[j].v;
            zt[j].id = j;
         }
         sort(zt + 1 ,zt + n + 1 ,camp);
         for(j = 1 ;j <= n ;j ++)
         G_b[i][zt[j].id] = n - j + 1;
      }
      Marr(n);
      for(i = 1 ;i <= n ;i ++)
      printf("%d %d\n" ,node1[i].num ,node2[nowb[i]].num);
      puts("");
   }
   return 0;
}