Два элемента в массиве, чье значение является максимальной

игнорируя бит знака, одно из значений должно быть одним из значений с наибольшим значащий бит. Если все значения не имеют этот бит set в этом случае вы переходите на следующий высокий, что не во всех значениях. Таким образом, вы можете сократить возможности для 1-го значения, посмотрев на HSB. Например, если возможности

0x100000
0x100ABC
0x001ABC
0x000ABC

1-е значение максимальной пары должно быть 0x100000 или 0x10ABCD.

@внутренняя ошибка сервера я не думаю, что маленький верна. У меня нет отличной идеи для сокращения 2-го значения. Просто любое значение не в списке возможных значений 1st. В моем примере 0x001ABC или 0x000ABC.

это можно решить в O(NlogN) сложность времени с помощью Trie.

• построить trie. Для каждого целочисленного ключа каждый узел trie будет содержать каждый бит (0 или 1), начиная с самого значительного бита.
• теперь для каждого arr[i] элемент arr[0, 1, ..... N]
  • выполнить запрос, чтобы получить максимальное значение xor для arr[i]. Мы знаем xor различных типов битов (0 ^ 1 или 1 ^ 0) всегда 1. Так во время запроса каждый бит, попробуйте пересечь узел, удерживающий противоположный бит. Это сделает этот конкретный бит 1 результат в максимизации значения xor. Если нет узла с противоположным битом, только тогда пересеките тот же битовый узел.
  • после запроса вставить arr[i] в trie.
  • для каждого элемента следите за максимально возможным значением Xor.
  • во время обхода каждого узла создайте другой ключ, для которого XOR максимизируется.

на N элементы, нам нужен один запрос(O(logN)) и вставки(O(logN)) для каждого элемента. Таким образом, общая сложность времени O(NlogN).

вы можете найти хорошее наглядное объяснение того, как это работает в этой теме.

вот реализация c++ вышеуказанного алгоритма:

const static int SIZE = 2;
const static int MSB = 30;
class trie {
private:
    struct trieNode {
        trieNode* children[SIZE];
        trieNode() {
            for(int i = 0; i < SIZE; ++i) {
                children[i] = nullptr;
            }
        }
        ~trieNode() {
            for(int i = 0; i < SIZE; ++i) {
                delete children[i];
                children[i] = nullptr;
            }
        }
    };
    trieNode* root;
public:
    trie(): root(new trieNode()) {
    }
    ~trie() {
        delete root;
        root = nullptr;
    }

    void insert(int key) {
        trieNode* pCrawl = root;
        for(int i = MSB; i >= 0; --i) {
            bool bit = (bool)(key & (1 << i));
            if(!pCrawl->children[bit]) {
                pCrawl->children[bit] = new trieNode();
            }
            pCrawl = pCrawl->children[bit];
        }
    }

    int query(int key, int& otherKey) {
        int Xor = 0;
        trieNode *pCrawl = root;
        for(int i = MSB; i >= 0; --i) {
            bool bit = (bool)(key & (1 << i));
            if(pCrawl->children[!bit]) {
                pCrawl = pCrawl->children[!bit];
                Xor |= (1 << i);
                if(!bit) {
                    otherKey |= (1 << i); 
                } else {
                    otherKey &= ~(1 << i);
                }
            } else {
                if(bit) {
                    otherKey |= (1 << i); 
                } else {
                    otherKey &= ~(1 << i);
                }
                pCrawl = pCrawl->children[bit];
            }
        }
        return Xor;
    }
};

pair<int, int> findMaximumXorElements(vector<int>& arr) {
    int n = arr.size();
    int maxXor = 0;
    pair<int, int> result; 
    if(n < 2) return result;
    trie* Trie = new trie();
    Trie->insert(0); // insert 0 initially otherwise first query won't find node to traverse
    for(int i = 0; i < n; i++) {
        int elem = 0;
        int curr = Trie->query(arr[i], elem);
        if(curr > maxXor) {
            maxXor = curr;
            result = {arr[i], elem};
        }
        Trie->insert(arr[i]);
    }
    delete Trie;
    return result;
}

очень интересная проблема! Вот моя идея:

• сначала создайте двоичное дерево из всех чисел, используя двоичный представление и сортировка их в дерево самый значительный бит сначала (добавьте ведущие нули, чтобы соответствовать самому длинному числу). Когда каждый путь от корня до любого листа представляет одно число от оригинала набор.
• пусть A и b-указатели на узел дерева и инициализируют их в корне.
• Теперь переместите a и b вниз по дереву, попытка использовать противоположные ребра на каждом шаге, т. е. если a движется вниз по 0-краю, b движется вниз по 1-краю, если это невозможно.

Если a и b достигают листа, он должен указывать на два числа с" очень немногими " одинаковыми битами.

Я только что придумал этот алгоритм и не знаю, правильно ли это или как это доказать. Однако это должно быть во время o(n).

сделать рекурсивную функцию, которая принимает два списка целых чисел, A и B, в качестве своих аргументов. В качестве возвращаемого значения он возвращает два целых числа, одно из A и одно из B, которые максимизируют XOR двух. Если все числа равны 0, возвращает (0,0). В противном случае функция выполняет некоторую обработку и вызывает себя рекурсивно дважды, но с меньшими целыми числами. В одном из рекурсивных вызовов он рассматривает взятие целого числа из списка A для предоставления 1 в бит k, а в другом вызове он рассматривает взятие целое число из списка B для предоставления от 1 до бита k.

У меня нет времени сейчас, чтобы заполнить детали, но, может быть, этого будет достаточно, чтобы увидеть ответ? Кроме того, я не уверен, что время выполнения будет лучше, чем N^2, но это, вероятно, будет.

мы можем найти максимальное число в o (n) времени, а затем цикл через массив, выполняющий xor с каждым элементом. Предполагая, что стоимость операции xor равна O(1), мы можем найти max xor двух чисел в o (n) времени.