Алгоритм: найти max Xor в массиве для различных интервалов, заданных N входов, и p, q, где 0 ‹= p‹ = i ‹= q‹ = N

постановка задачи следующая:

Xorq изобрел алгоритм шифрования, который широко использует побитовые операции XOR. Этот алгоритм шифрования использует в качестве ключа последовательность неотрицательных целых чисел x1, x2,… xn. Чтобы реализовать этот алгоритм эффективно, Xorq необходимо найти максимальное значение для (a xor xj) для заданных целых чисел a, p и q, таких что p ‹= j‹ = q. Помогите Xorq реализовать эту функцию.

Вход

Первая строка ввода содержит единственное целое число T (1 ‹= T‹ = 6). Далее следуют T-тестовые примеры.

Первая строка каждого тестового примера содержит два целых числа N и Q, разделенных одним пробелом (1 ‹= N‹ = 100 000; 1 ‹= Q‹ = 50 000). Следующая строка содержит N целых чисел x1, x2,… xn, разделенных одним пробелом (0 ‹= xi‹ 2 ^ 15). Каждая из следующих Q строк описывает запрос, состоящий из трех целых чисел ai, pi и qi (0 ‹= ai‹ 2 ^ 15, 1 ‹= pi‹ = qi ‹= N).

Выход

Для каждого запроса выведите максимальное значение для (ai xor xj) такое, что pi ‹= j‹ = qi в одной строке.

int xArray[100000];
cin >>t; 
for(int j =0;j<t;j++)   
{        
    cin>> n >>q;
    
    //int* xArray = (int*)malloc(n*sizeof(int));
    int i,a,pi,qi;        
    
    for(i=0;i<n;i++)
    {
        cin>>xArray[i];                         
    }
    
    for(i=0;i<q;i++)
    {
      cin>>a>>pi>>qi;
        int max =0;
      for(int it=pi-1;it<qi;it++)
      {
          int t =  xArray[it] ^ a;
          if(t>max)               
              max =t;
          
      }   
      cout<<max<<"\n" ;
    } 

Никакие другие предположения не могут быть сделаны кроме тех, которые указаны в тексте задачи (числа не сортируются). Код функциональный, но недостаточно быстрый; действительно ли чтение из стандартного ввода так медленно или что-то еще мне не хватает?


person Pandrei    schedule 28.11.2013    source источник
comment
Форматированный ввод с cin и operator>> может быть медленным, но также может быть форматированный вывод (cout << ...). Вы, вероятно, обнаружите, что большую часть времени эта функция запускает только с вводом и выводом, а не с битовыми манипуляциями.   -  person the_mandrill    schedule 28.11.2013
comment
Нет, проблема не в чтении со стандартного ввода. Да, вам чего-то не хватает. А именно, реализация глупого, тривиального алгоритма грубой силы не суть этого конкурса. Вы должны придумать более быстрый алгоритм.   -  person n. 1.8e9-where's-my-share m.    schedule 28.11.2013
comment
@Barmar - ни то, ни другое; оттачивание навыков программирования; есть несколько сайтов, которые могут помочь в этом (в том числе TopCoder.com); Обратите внимание, я уже решил проблему, просто не могу ее оптимизировать.   -  person Pandrei    schedule 28.11.2013
comment
хорошо, я склонен с тобой согласиться; Мой подход сейчас O (Q * N) - проблема, с которой я сталкиваюсь, пытаясь найти что-то лучшее, заключается в том, что мне нужны числа между индексами p и q; и числа не отсортированы. Сортировка всех чисел будет означать, что я потеряю порядок, а сортировка Q раз только интересующих чисел на самом деле займет больше времени, чем то, что я делаю сейчас. Я не жду, что кто-то просто напишет за меня решение - я ищу идею, чтобы попробовать.   -  person Pandrei    schedule 28.11.2013
comment
вы делаете слишком много работы в своем внутреннем цикле, поскольку он устарел. Задача только найти max{a xor x_(p-1); a xor x_(q-1)}   -  person ogni42    schedule 28.11.2013
comment
@ ogni42: ключи X не отсортированы, и вы не можете просто предварительно отсортировать все X, потому что вы потеряете информацию об их индексах, которые позже придется сравнивать с Pi-Qi, которые, в свою очередь, различны для каждого отдельного A. Предполагая, что я ' все прочитал правильно;)   -  person quetzalcoatl    schedule 28.11.2013
comment
Пандрей: Я заменил свой предыдущий ответ фактической идеей отказа от брутфорса. Я не очень тщательно обдумывал это, но, возможно, стоит попробовать.   -  person quetzalcoatl    schedule 28.11.2013
comment
Я предлагаю переименовать вопрос в что-то более связанное с проблемой ... битовые манипуляции не являются ключевыми ... возможно, algo: учитывая I [0..n], для изменения a, p, q найти max (a ^ I [i ]), где 0 ‹= p‹ = i ‹= q‹ = n.   -  person Tony Delroy    schedule 28.11.2013
comment
Этот вопрос находится в задаче программирования Twitter: D   -  person Pham Trung    schedule 28.11.2013
comment
Я ничего не знаю об этом - что такое проблема программирования твиттера (я лично нашел это на topcoder)   -  person Pandrei    schedule 28.11.2013


Ответы (2)


XOR переворачивает биты. Максимальный результат XOR - 0b11111111.

Чтобы получить лучший результат

  • если 'a' на i-м месте имеет 1, вам нужно выполнить XOR с ключом, у которого i-й бит = 0
  • если 'a' в i-м месте имеет 0, вам нужно выполнить XOR с ключом, который имеет i-й бит = 1

Проще говоря, для бит B вам нужен! B

Другой очевидный момент заключается в том, что биты более высокого порядка более важны, чем биты более низкого порядка.

То есть:

  • если 'a' на самом высоком месте имеет B, и вы нашли ключ с наивысшим битом =! B
  • то ВСЕ ключи с самым высоким битом =! B хуже этого

Это сокращает ваше количество чисел вдвое "в среднем".

Как насчет того, чтобы построить огромное двоичное дерево из всех ключей и упорядочить их в дереве по их битам, от MSB до LSB. Затем, побитовое сокращение A от MSB до LSB сообщит вам, какую левую-правую ветвь выбрать следующей для получения наилучшего результата. Конечно, это игнорирует ограничения PI / QI, но, безусловно, даст вам лучший результат, поскольку вы всегда выбираете лучший доступный бит на i-м уровне.

Теперь, если вы аннотируете узлы дерева с низкими / высокими диапазонами индексов его подэлементов (выполняется только один раз при построении дерева), то позже при запросе к случаю A-PI-QI вы можете использовать это для фильтрации ветвей, которые не попадают в диапазон индекса.

Дело в том, что если вы упорядочиваете уровни дерева, например, порядок битов MSB-> LSB, тогда решение, выполняемое на «верхних узлах», может гарантировать вам, что в настоящее время вы находитесь в наилучшей возможной ветви, и оно будет сохраняться, даже если все наихудшими оказались подветвления:

Находясь на уровне 3, результат

0b111?????

затем можно расширить до

0b11100000
0b11100001
0b11100010

и так далее, но даже если ????? плохо расширяются, общий результат все равно больше, чем

0b11011111

что было бы наилучшим возможным результатом, если бы вы даже выбрали другую ветку на 3-м уровне.

Я совершенно не знаю, сколько времени будет стоить подготовка дерева, но запрос его для A-PI-QI, который имеет 32 бита, кажется чем-то вроде 32-кратных N-сравнений и прыжков, безусловно, быстрее, чем случайная итерация 0-100000 раз и xor / maxing. А поскольку у вас есть до 50000 запросов, построение такого дерева действительно может быть хорошим вложением, поскольку такое дерево будет построено один раз для каждого набора ключей.

Самое приятное то, что вам не нужно все дерево целиком. Вы можете построить его, например, только из первых двух, четырех или восьми бит, и использовать диапазоны индексов от узлов, чтобы ограничить цикл xor-max меньшей частью. В худшем случае вы получите тот же диапазон, что и PiQi. В лучшем случае это будет всего лишь один элемент.

Но, глядя на максимальное количество ключей N, я думаю, что все дерево действительно может поместиться в пул памяти, и вы можете обойтись без какого-либо цикла xor-maxing.

person quetzalcoatl    schedule 28.11.2013
comment
максимум a ^ xi получается, если xi = not (a), поскольку a ^ not (a) = FFFF; Я могу найти логику для работы с битами. НО для того, чтобы это сработало, числа должны быть отсортированы, иначе я все еще сканирую все входные данные, которые я уже делаю ... - person Pandrei; 28.11.2013
comment
если вы аннотируете узлы дерева с низкими / высокими диапазонами индексов его подэлементов - проблема в том, что на большинстве уровней в дереве - при случайном вводе - доля позиций N значений диапазона стремится к (N-1) / N. .. действительно не очень эффективный фильтр. - person Tony Delroy; 28.11.2013
comment
@TonyD: Я понимаю, что вы имеете в виду, но я сосредоточился в основном на версии ПОЛНОГО дерева и на том, что диапазоны присутствия должны быть согласованы / отфильтрованы по верхним узлам. Это не фильтр, а поиск, который охватывает все N ключей. Т.е. имея ключи 1011, 0111, 1100, 0001 в таком порядке, дерево будет иметь вид / [] = ›{0 / [1..3] = {0 / [3..3] =› X, 1 / [1 ..1] = ›X}, 1 [0..2] = {0 / [0..0] =› X, 1 / [2..2] = ›X}}. Обратите внимание, что диапазоны подузлов ограничены диапазоном их родителей. - person quetzalcoatl; 28.11.2013
comment
Теперь, чтобы найти наилучшее совпадение для A = 1000, P = 1, Q = 3, поиск сначала проверит! '1' в корневом узле, в результате чего будет выбран узел 0 / [1..3], поскольку он 0 и пересекается с диапазоном 1..3. Затем следующим шагом будет поиск! 0 в 0 / [1..3], поэтому будет выбран 0 / [3..3]. И так далее. Если бы не было ключа 0, то выбирался бы 1. Если диапазон ключа 0 выпадет за пределы целевого диапазона PiQi, то снова будет выбран 1. Диапазоны, записанные в родителях, гарантируют, что в дочерних элементах есть некоторые ключи, и используются для направления ходунка к непустому листу. Ветви 0/1 позволяют выбрать следующее лучшее значение. - person quetzalcoatl; 28.11.2013
comment
Переход прекращается, если посещается узел с диапазоном N..N, поскольку это означает, что для двоичного префикса 0101010 этого узла существует ровно один такой ключ, и поскольку в каждом более значимом (бит ) уровень вы взяли лучшую ветку, она должна быть лучшей. И он должен быть в пределах диапазона, поскольку вы всегда выбирали ветвь, диапазон которой пересекался с целевым диапазоном. Последний узел может иметь глубину дерева не более 32, но максимальный размер дерева не 2 ^ 32 (ууу :)!), Поскольку существует ограничение на количество ключей .. - person quetzalcoatl; 28.11.2013
comment
Если вы видите в этом пробелы, поделитесь, пожалуйста! Как я уже сказал, я не анализировал это очень тщательно, но я рассмотрел некоторые базовые проверки работоспособности, и полное дерево, поскольку поиск по префиксу кажется возможным, даже с его пессимистичными 32 прыжками для каждого случая (что является большим отрывом от среднего, поскольку max-keys ‹---------------- 2 ^ 32). - person quetzalcoatl; 28.11.2013
comment
подход бинарного дерева хорош и является одной из лучших идей для решения этой проблемы; однако для этого требуется особый вид BST - построение дерева сегментов и получение результата с помощью запросов диапазона. Безусловно, наиболее проблемной частью является тот факт, что даже несмотря на то, что входной массив один и тот же для всех тестовых примеров Q, для каждого тестового примера a может отличаться, что затрудняет использование предыдущих результатов, поскольку вам нужно вычислить max (a ^ x [ i]), 1 ‹= i‹ = N; - person Pandrei; 29.11.2013
comment
О нет, не поймите меня неправильно. Для каждого большого тестового примера, когда весь набор ключей может измениться, вы должны отказаться от старого и построить новое дерево поиска для этого нового набора ключей. Я не вижу особой выгоды в повторном использовании результатов из предыдущего большого тестового примера, но повторное использование некоторых результатов среди всех небольших Q-тестов в текущем большом тестовом примере является ключевым. Извините, если я не совсем понял это. Я думаю, что повторное использование результатов или структур между тестовыми примерами действительно очень усложнит. Мне кажется, что перестройка дерева через каждые 50 тыс. Запросов вполне подходит и все равно должно приводить к ускорению. - person quetzalcoatl; 29.11.2013

Я потратил некоторое время на поиск в Google этой проблемы, и похоже, что вы можете найти ее в контексте различных соревнований по программированию. Хотя метод грубой силы интуитивно понятен, на самом деле он не решает проблему, так как он слишком медленный. В проблеме есть несколько ограничений, о которых вам нужно подумать, чтобы написать более быстрый алгоритм:

  • the input consists of max 100k numbers, but there are only 32768 (2^15) possible numbers
    • for each input array there are Q, max 50k, test cases; each test case consists of 3 values, a,pi,and qi. Since 0<=a<2^15 and there are 50k cases, there is a chance the same value will come up again.

Я нашел 2 идеи для решения проблемы: splitting the input in sqrt(N) интервалы и building a segment tree (хорошее объяснение этих подходов можно найти здесь)

Самая большая проблема заключается в том, что для каждого тестового примера вы можете иметь разные значения для a, и это сделало бы предыдущие результаты бесполезными, поскольку вам нужно вычислить max (a ^ x [i]) для небольшого количества тестовых примеров. Однако, когда Q достаточно велико и значение a повторяется, возможно использование предыдущих результатов.

Я вернусь с реальными результатами, как только завершу реализацию обоих методов.

person Pandrei    schedule 29.11.2013
comment
Вау, уникальных номеров всего 32к? Как я это пропустил? Я бы действительно пошел на prefix tree. Я не вижу немедленной выгоды от его использования, когда ваш набор элементов постоянен. И, на самом деле, я не вижу никакой выгоды в использовании его для поиска. Я предложил сочетание ядра prefix tree (которое находит вам решение) с аннотацией о «сегментах» (которая отфильтровывает ключи, которые не- из диапазона). - person quetzalcoatl; 29.11.2013
comment
есть только ~ 32k уникальных значений для a, но вам нужно вычислить max (a ^ x [i]); если вы искали только max (x [i]), то вы могли бы построить только одно дерево. - person Pandrei; 29.11.2013
comment
да .. Я вообще не понимаю, о чем ты говоришь, извини. Похоже, что и я, и вы сосредоточены на наших собственных решениях: / Я имею в виду, я не понимаю, почему невозможно построить одно дерево поиска для всех «ключей». Префиксное дерево. Просто чтобы хранить ключи вместо массива. И чтобы позволить ПРОЧИТАТЬ значение, ближайшее к ~A, которое находится в диапазоне Pi-Qi. Дерево префикса / поиска, основанное исключительно на значениях ключей. - person quetzalcoatl; 29.11.2013
comment
Однако с неуникальными ключами я действительно чувствую проблему с тем, как правильно аннотировать префиксное дерево. - person quetzalcoatl; 29.11.2013
comment
любое решение, которое вы выберете (разбиение на интервалы или построение дерева), хорошо, только если оно хранит ^ x [i], в противном случае вам придется вычислять значения каждый раз, и это так же хорошо, как сканирование всего диапазона [pi, qi]. Помните, что входные значения не сортируются, и их сортировка будет означать потерю индексов или необходимость каждый раз искать их. - person Pandrei; 29.11.2013
comment
Как мне каждый раз вычислять значения ?! С самого начала я знаю, что ~ A является лучшим, я вычисляю его один раз, просто отрицая его. И с этого момента я только прохожу по дереву, бит за битом, от MSB к LSB, чтобы проверить, какое наиболее близкое приближение к этому ~ A в пределах диапазона PiQi. Если значения 16 бит, это 16 узлов для посещения. Нет ничего лучше, чем сканировать все X [i] s. - person quetzalcoatl; 29.11.2013
comment
поиск ~ a, потому что это дало бы максимальное или ближайшее к нему значение, которое дало бы максимальный результат, на самом деле не так просто получить; вы не можете просто взять значение ~ a. (a = 10 мы хотим 5, а не 7FF5), поэтому вам придется выполнять некоторые дорогостоящие битовые операции. Я пробовал этот подход вчера вечером, и результат был хуже, чем метод грубой силы. - person Pandrei; 29.11.2013
comment
И именно в этом вам поможет префиксное дерево. Возьмем, что a = 10. Скажем, беззнаковый и 8-битный для простоты. A = 0x0A, поэтому ~ A - 11110101. Допустим, такого ключа, конечно, нет. У нас есть ключи 10110000, 01000101, 11110000, 01110101. Если вы построите для этого префиксное дерево, после вырезания первой «1» из ~ A = [1] 1110101 вы посетите корневой узел дерева и выберите Путь "1". Он направит вас к поддереву 10110000, 11110000. Затем, вырезая следующий бит ~ A = 1 [1] 110101 и заглянув глубже в это поддерево, вы получите 11110000. Это ИТОГ. - person quetzalcoatl; 29.11.2013
comment
Если бы дерево было глубже, вам нужно было бы взять больше бит ~ A и посмотреть глубже. И если бы дерево было аннотировано диапазонами присутствия, вы могли бы пройти вниз по дереву, соблюдая целевые диапазоны PiQi. - person quetzalcoatl; 29.11.2013
comment
Если бы интервал был одинаковым каждый раз, это решение действительно сработало бы; но поскольку интервал варьируется, это означает, что вы придумали бы способ выяснить, действительно ли ~ a находится в диапазоне, а если нет, то какое закрывает число в этом - и что вы не можете использовать подход дерева префиксов - person Pandrei; 29.11.2013
comment
Я только что удалил этот нерелевантный (...) комментарий. Я до сих пор не могу решить, опровергают ли дублирующиеся ключи мою идею или нет. Есть небольшая брешь, которую я не могу распутать. Чем больше я думаю об этом, тем больше думаю, что дублирующиеся ключи не имеют значения при таком подходе, но я где-то чую что-то плохое и не могу понять это. - person quetzalcoatl; 29.11.2013
comment
Пандрей: да. Это потому, что я только сейчас описал часть дерева PREFIX. Пожалуйста, аннотируйте каждый узел дерева диапазоном присутствия, как я описал в моем исходном ответе и комментариях. - person quetzalcoatl; 29.11.2013
comment
Для набора ключей 10110000, 01000101, 11110000, 01110101 дерево присутствия префикса будет [1]/(0..2) -> [subtree] | [0]/(1..3) -> [subtree], где 0..2 указывает на range of presence of keys with MSB=1, а (1..3) указывает на присутствие MSB = 0. - person quetzalcoatl; 29.11.2013
comment
Если вы теперь ищете ~ A = [1] 1110101 в диапазоне PiQi = (3..4), то вы знаете, что НЕ МОЖЕТЕ выбрать лучший левый узел дерева, потому что узел дерева говорит, что он имеет узлы в диапазоне 0..2 и не пересекается с целью 3..4. Следовательно, вы должны выбрать [0] как лучший-доступный-MSB-в-3..4-диапазоне и пойти глубже. - person quetzalcoatl; 29.11.2013
comment
Тогда выбранный таким образом subtree будет [1]/(1..3) -> subsub | [0]/() -> empty, поэтому на этот раз вы выбираете левую. (решение на данный момент: 01 ??????). Следующее поддерево - [0]/(1..1)-> 01000101 | [1]/(3..3) -> 01110101, поэтому вы выбираете правильное, и поэтому путь 011 ????? находит лист 01110101. Обратите внимание, что на последнем шаге я отклонил левое, потому что оно было хуже (было 0 вместо 1) и потому что оно было вне допустимого диапазона: (1..1) вместо (3 .. 4) - person quetzalcoatl; 29.11.2013
comment
хех. и, подумав об этом, я думаю, что дубликаты ключей не опасны. В итоге получился бы диапазон X-Y (X! = Y) в самом низу листа. Если шагающий спускается к этому узлу, это означает, что X-Y пересекается с Pi-Qi, а это означает, что лучшее из возможных решений, которое мы только что нашли, находится в пределах досягаемости. Но мы не знаем, где именно, но эти знания все равно не нужны! Уф. - person quetzalcoatl; 29.11.2013
comment
Извини, мне пора. Думаю, я все равно заспамил вам слишком много текста. Надеюсь, я не допустил никаких ошибок, он был подготовлен на скорую руку (как вы видите из моего удивления при диапазоне значений 32k / 16bit ...). Удачи! - person quetzalcoatl; 29.11.2013
comment
Что ж, это возвращает вас к решению сегментного дерева, только с той особенностью, что вы построили бы только одно дерево вместо Q. Стоит попробовать, я дам вам это :) - person Pandrei; 29.11.2013
comment
Я начал работать над реализацией этого и понял, что может быть проблема: при добавлении префикса-присутствие, потому что дублирующиеся ключи префикс-присутствие может расширяться таким образом, что вы больше не можете выбирать путь, потому что любой путь, который вы выберете, его префикс-присутствие включает интересующий интервал (например) для бита i = 1, у вас есть следующие [0] / (1..15), [1] / (2..13) и PiQi = (6,7 ). Таким образом, в этом случае будет выбрано 1, и это ни к чему не приведет, потому что дальше по строке есть только значения из (1..5) и (10..13). - person Pandrei; 03.12.2013
comment
Если я вас правильно не понял, то это задумано! Я говорю на 8 битах вместо 16. В случае, если вы предоставили, скажем, текущий i = 1 будет 4-м битом. Скажем, лучшее решение - ABC1EFGH (4-е - 1). Поскольку сейчас мы анализируем бит 4, то биты 1..3 уже посещены / решены. Итак, решение пока A'B'C '?????. Теперь, в случае, который вы указали, имея PiQi = (6,7) и лучший бит = 1, вы выбираете [1] / (2..13), поскольку он находится в диапазоне PQ и является лучшим, следующее приближение решения - A 'B'C'1 ???? и мы спускаемся. Теперь мы видим (1..5) и (10..13) против (6..7), и мы хотим E. - person quetzalcoatl; 03.12.2013
comment
В зависимости от значения E мы хотим 0 или 1. Однако из-за ограничения PQ мы не сможем выбрать ЛУЧШЕЕ. Если это так, необходимо выбрать все, что находится в пределах досягаемости. Если мы хотим, чтобы E = 0 и [0] / (1..5), мы ДОЛЖНЫ выбрать другую ветвь - просто потому, что в диапазоне PQ НЕТ номеров с E = 1. Как будто их вообще не было. Следовательно, наше следующее приближенное решение - A'B'C'10 ??? и мы спускаемся дальше вниз, пока полностью не закончим. - person quetzalcoatl; 03.12.2013
comment
Хитрость в том, что PQ-диапазон говорит, что ключей вне диапазона не существует. Итак, если мы должны всегда соблюдать правило спуска-всегда-в-допустимый-диапазон и только потом выбирать лучшее. В противном случае мы должны выбрать другой (который должен быть в пределах диапазона из-за диапазона родительского узла) - потому что больше ничего нет. Итак, лучшая клавиша from-PQ-range должна иметь A'B'C'10 ??? форма, даже если этот 0 не универсально лучший - он лучший в этом диапазоне. - person quetzalcoatl; 03.12.2013
comment
Допустим, это до последних 2 бит (остальные разрешены); ~ a = xxxxxxx01. PiQi = (6,7); Итак, варианты: [0] / (1..15) и [1] / (2..13); Мы выбираем [0], поскольку он соответствует нашему биту. теперь для последнего бита у нас остались [0] / (1..5) и [1] / (8..15) ... и у нас нет выбора. Это правдоподобно (если вы построите пример, то увидите). Кроме того, такая ситуация может произойти с любым из более значимых битов. - person Pandrei; 03.12.2013
comment
Нет, это невозможно. Для того, чтобы это было возможно, у вас должны быть неправильные аннотированные узлы PARENT! - person quetzalcoatl; 03.12.2013
comment
Если вы находитесь на третьем бите с конца, вы находитесь в ситуации ~ a = xxxxxxB ?. Теперь вы выбираете левый / правый узел в зависимости от наличия. Допустим, выбор равен 0, а в Presence указано (1..15), как в этом примере. Итак, вы знаете, что ключ xxxxxx0? СУЩЕСТВУЕТ в диапазоне от 1 до 15. Если он существует, то в нем есть еще несколько бит. Если в нем есть другие биты, то после бита B БУДЕТ либо НУЛЬ, либо ЕДИНИЦА. Итак, в поддереве левая или правая ветвь ДОЛЖНЫ иметь присутствие, покрывающее индексы 6 и 7. - person quetzalcoatl; 03.12.2013
comment
Итак, если у вас есть узел дерева 0 / [1..15], тогда объединение диапазона подузлов должно составлять полные 1..15. В самых последних листьях последний выбор будет соответствовать не пересекающему диапазону. Итак, если у родителя было 1..15, тогда на листе 0 / (1..5) 1 / (6..15) возможно, но 0 / (1..5) 1 / (13..15) ) не является! В противном случае в аннотации родителя будет сказано, что в индексе 6,7,8,9,10,11,12 есть ключи с правильным префиксом и .. никаких других битов. - person quetzalcoatl; 03.12.2013
comment
Извините за использование заглавных букв и полужирного шрифта, но я тороплюсь и не смог придумать, как выделить важные элементы так, чтобы это было приятнее для глаз: / - person quetzalcoatl; 03.12.2013
comment
Один из нас чего-то упускает :) Я говорю, что это может случиться, потому что ввод НЕ ЗАКАЗАН: у вас может быть xArray [5] = xArray [1000] = 3; Поэтому, когда вы добавляете присутствие диапазона в дерево, интервалы могут стать очень широкими. Поскольку идеальный узел ~ a может существовать в массиве, но находится за пределами PiQi, вы можете пойти по неверному пути! - person Pandrei; 03.12.2013
comment
«Широта» интервалов диапазона присутствия считается высокой из-за дублирования. Но все равно, даже если безумно широкий, врать не будет. А вы знаете, что на самом листе он должен быть не пересекающимся, верно? - person quetzalcoatl; 03.12.2013
comment
Я имею в виду, извините, не непересекающиеся, дубликаты, а - person quetzalcoatl; 03.12.2013
comment
позвольте нам продолжить обсуждение в чате - person quetzalcoatl; 03.12.2013
comment
Может я неправильно понял; поправьте меня, если я ошибаюсь, но если xArray [0] = xArray [14] = 3, это означает, что присутствие для узла 0x03 будет (0..14), и то же самое для родителей этого узла, предполагая N = 15; - person Pandrei; 03.12.2013