Question

彼得有N个球，编号从1到N。

没有两个球重一样。您想找到最重的球，但您不知道它是哪一个，Peter也不想只把它给您。因此，他决定和你一起玩游戏。

您最多可以问Peter Q = 4 + N / 2个问题。在每个问题中，您都必须给Peter五个不同球的数量，Peter会告诉您其中三个最重的球的数量。找到最重的球的编号！

互动： 首先，您应该读取一行，该行包含一个表示测试用例数量的整数T。对于每个测试用例，您应该从读取包含单个整数N的行开始。要提出一个问题，您应该打印一行包含字符'？'，一个空格和五个以空格分隔的整数i1，i2，i3，i4和i5：五个不同的球的数量（以任意顺序）。

然后，您必须读取一行，其中包含两个以空格分隔的整数：第3个和第4个最重的球的编号。

要完成测试用例的求解，请打印包含字符“！”，空格和整数im的行：最重的球的编号（1≤im≤N）。

别忘了在打印每行之后刷新输出！

约束：

1≤T≤1,000
6≤N≤100

示例：

You               Grader
                  1
                  6
? 1 2 3 4 5
                  3 4
? 1 2 3 4 6
                  3 4
? 1 2 3 5 6
                  3 5
? 1 2 4 5 6
                  4 5
? 1 3 4 5 6
                  4 5
? 2 3 4 5 6
                  4 5
! 6

说明：

这些球按重量的降序排列。

这是在Codechef竞赛中对问题的解释，其解释是因为原始问题陈述不是很清楚。

这是我的代码（n> 6）：

我知道它不是很有效，我一直在编辑它以查找错误

（C ++）

Answer 1

整个问题归结为找到六个最大的元素，您已经4 + 6/2 = 7尝试了。对于六个以上的元素，每次尝试时，您都要筛选出其中的两个（这是您已经做过的），因此公式4 + N/2来自...

前五个测试（实际上，我们需要/可以做的所有事情）将是：

(6) 12345  34   // one of 1235 must be heavier than 34
(5) 12346  34   // one of 1236 must be heavier than 34
(4) 12356  35   // ...
(3) 12456  45
(2) 13456  45
(1) 23456  45

现在我们可以确定3、4和5不能最重，剩下的1、2、6

现在让我们仔细看看：

从集合中删除5或6导致在第三和第四相同的位置两次。从集合结果中删除4将导致第3和第4组合仅出现一次。从集合中删除1、2或3的结果分别在第3和第4位上三遍。

我们现在感兴趣的是这两个集合，它们的第3和第4个正好发生两次：

1、2、3、4、5和1、2、3、4、6。从中我们知道5或6必须最大；结合最初的观察结果（排除3、4、5），仅剩6个。

实际上，我们甚至了解更多：

从两次出现（5，6）的集合中未选择的一个（5）是第二最重的，第三次/ 4th（4）的单个出现显示第三最重，而最初排除的其余一个（3）（3、4、5）是第四重的。

仅第5位和第6位无法区分...

编辑： 过滤剩余值：

您可以稍微简化一下代码：

int t;
std::cin >> t;
while(t--) // sparse you another variable...
{
    int n = 12;
    --n; // exclude highest value!
    int ar[] = {1, 2, 3, 4, 5}; // just *always* maintain the values in the array...
    // note: the array is one larger as you had initially!
    for (int i = 6; i < n; i = i + 2) // prefer local scope for i!
    //           ^ can start at a later point of time, we'll be replacing AFTERWARDS
    {
        std::cout << '?';
        for(auto a : ar)            // loop might or not be more elegant
            std::cout << '\t' << a; // performance: most likely, compiler unrolls
                                    // anyway...
        std::cout << std::endl;
        int x, y; // scope as local as possible...
        std::cin >> x >> y;
        // OK, I don't want to modify the loop variable, so I now use a duplicate...
        int ii = i;
        for(auto& a : ar) // I like the range based for loops...
        //      ^ reference this time is important, though!
        {
            if(a == x || a == y)
                a = ii++;
        }
    }
    if((n & 1) == 0)
    {
        // for even n, we have done one test too few!
        // instead of duplicating the code, you might write a common function for...
        std::cout << '?';
        for(auto a : ar)
            std::cout << '\t' << a;
        std::cout << std::endl;
        int x, y; // scope as local as possible...
        std::cin >> x >> y;

        for(auto& a : ar)
        {
            if(a == x || a == y)
            {
                a = n;
                break; // just replace one!!!
            }
        }
    }
}

上面的

代码将产生5个要检查的元素。还记得我们排除了最高值（--n;）吗？现在，我们将还原：

++n;

除了数组中剩余的五个值之外，

n现在将是要检查的第六个值（如果您不喜欢递增和递减，那么当然也可以维护两个变量）。您可以使用std::swap来交换数组的一个值。

旁注：我个人更喜欢类似C ++的std::array<int, 5> ar({1, 2, 3, 4, 5});而不是原始数组，但这不是一个大问题。但是，如果您从重复的代码中创建一个数组，则使传递数组使其更容易运行：

void f(std::array<int, 5> const& ar); // or non-const, if you want to replace inside, too
// or in more generic form:
template <size_t N>
void f(std::array<int, N> const& ar);

// vs.:

void f(int const(&ar)[5]);
// the more generic form:
template <size_t N>
void f(int const(&ar)[N]);
// or classical (and better known) pointer variant:
void f(int const* ar, size_t length);

最后的注释：

您无需在用户输入后检查流。如果用户输入任何内容，这将破坏您的流，从而破坏整个代码。在这种特定情况下可能没有必要，但是总的来说，从一开始就习惯（例如if(!cin >> x >> y) { /* appropriate error handling */ }之类的东西，这也许是个好主意，甚至可能以后再检查有效范围（例如，错误， x和y相等或不完全匹配数组中的一个值-对于后者，我们必须注意不要与已替换的值匹配。）
据我所知，负值是没有意义的，因此（一致地）我更喜欢unsigned int作为数据类型。但这不是什么大问题，所以请自行决定...

最大元素印刷指数

1 个答案: