Question

问题如下：输入：

3 10

1 2 3

12 11 101

其中3（n）是男孩和女孩的数量10（k）被接受的高度差接下来的2行分别是女孩和男孩的高度

1 2 3是3个男孩的身高

和12 11 101是3个女孩的高度

现在我们必须找到一对一女孩和一男孩的最大对数使它们的高度差小于或等于k。

假设：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
    Map<Integer,List<Integer>> boyGirlsPair= new HashMap<Integer,List<Integer>>();
    Map<Integer,List<Integer>> girlBoysPair= new HashMap<Integer,List<Integer>>();
    int dancingPairsCount = 0;
    int count = 0;
    Scanner scan = new Scanner(System.in);
    int N = scan.nextInt();
    long K = scan.nextLong();
    long[] boysHeightList = new long[N];
    long[]  girlsHeightList = new long[N];
    scan.nextLine();
    while (count<N) {
        boysHeightList[count]=scan.nextLong();
        count++;
    }
    scan.nextLine();
    count =0;
    while (count<N) {
    girlsHeightList[count]=scan.nextLong();
    count++;
    }
    scan.close();
    for (Integer boysHeightListIter =0;boysHeightListIter<N;boysHeightListIter++) {
        for (Integer girlsHeightListIter=0;girlsHeightListIter<N;girlsHeightListIter++) {
            if (Math.abs(boysHeightList[boysHeightListIter] - girlsHeightList[girlsHeightListIter]) <= K) {
                if(boyGirlsPair.containsKey(boysHeightListIter))
                {
                    List<Integer> pairValue = boyGirlsPair.get(boysHeightListIter);
                    pairValue.add(girlsHeightListIter);
                    boyGirlsPair.put(boysHeightListIter,pairValue);
                }
                else
                {
                    List<Integer> pairValue = new ArrayList<Integer>();
                    pairValue.add(girlsHeightListIter);
                    boyGirlsPair.put(boysHeightListIter,pairValue); 
                }
                if(girlBoysPair.containsKey(girlsHeightListIter))
                {
                    List<Integer> pairValue = girlBoysPair.get(girlsHeightListIter);
                    pairValue.add(boysHeightListIter);
                    girlBoysPair.put(girlsHeightListIter,pairValue);
                }
                else
                {
                    List<Integer> pairValue = new ArrayList<Integer>();
                    pairValue.add(boysHeightListIter);
                    girlBoysPair.put(girlsHeightListIter,pairValue);
                }   
            }
        }
    }
   if(girlBoysPair.size()<=boyGirlsPair.size())
   {
       System.out.println(girlBoysPair.size());
   }
   else
   {
       System.out.println(boyGirlsPair.size());
   }
 }
}

一个女孩不能与一个男孩跳舞，反之亦然

   <div class="para">
   <p>paragraph</p>
   </div>

 .para>p{    
    color:red;
 }

我使用的基本算法是2个hashMaps，其中一个是键，男孩和值是他们可以跳舞的女孩的列表，另一个是关键字，女孩和值是男孩，他们可以跳舞。最小的2个哈希图是可以形成的最大对。这通过了比赛的基本测试用例，但是对于所有其他情况都失败了。想知道一个我的算法无法工作的情况，如果可能的话，还有其他解决方案。

Answer 1

使用两指针方法可以很容易地解决这个问题。

我将尝试用一个问题的例子来描述这个方法。

给定两个按升序排序的数组（A和B）和一个整数x。我们需要找到i和j，这样a [i] + b [j]等于X. 我和我们的指针，在第一步，我指向a的第一个元素，j指向b的最后一个元素。

i = 0; j = b.size() - 1;

通过数组a逐个移动第一个指针，并在需要时更正第二个指针的位置

while (i < a.size())
{
   while(a[i] + b[j] > X && j > 0) j--;
   if (a[i] + b[j] == X) writeAnswer(i, j);
   i++;
}

在这里，我们可以使用贪婪的方法。在这个问题中，我们需要对两个高度数组进行排序。我们为男孩和女孩保留了两个指数。

这是一个c ++实现 -

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <cassert>
#include <algorithm>
using namespace std;

#define sint long long int

int main() {
    sint n,k;
    cin>>n>>k;
    assert(1<=n && n<= 100000);
    assert(1<=k && k <=1000000000);
    sint a[n];
    sint b[n];
    for(sint i =0 ; i< n  ; i++)
    {
            cin>>a[i];
            assert(1<=a[i] && a[i] <=1000000000);
    }
    for(sint i =0 ; i< n ; i++)
    {
            cin>>b[i];
            assert(1<=b[i] && b[i] <=1000000000);
    }
    sint i = 0;
    sint j = 0;
    sort(a,a+n);
    sort(b,b+n);
    sint value = 0;
    while(i < n && j < n)
    {
        if(abs(a[i] - b[j]) <= k)
        {
            i++;
            j++;
            value++;
        }
        else if(a[i] < b[j])
            i++;
        else
            j++;
    }
    cout<<value<<endl;
    return 0;
}

我们还讨论问题的O（N ^ 2）方法 -

创建一个二分图，两个部分都将包含N个顶点。在第一部分中，每个顶点都代表一个男孩。类似地，第二部分中的每个顶点将代表一个女孩。如果他们的身高之间的差异小于或等于K，那么男孩和女孩之间会有一个优势。给定图表中的最大双分配将是我们的答案。

Answer 2

假设男孩和女孩要么矮，要么高，而且唯一有效的对是短身高身高。如果有10个短女孩和1个矮个子女孩和1个高个子女孩和10个高个子男孩，那么这个矮个子男孩和一个矮个子女孩一起跳舞，高个子女孩和一个高个子男孩共舞，没有人跳舞，总共2对，虽然所有11个女孩和所有11个男孩都有可以跳舞的人，所以你的算法会返回11。

舞蹈对算法（来自编程竞赛）

2 个答案: