<< Попередня

Завдяки спільноті PPCG Санта зараз збалансував свої візки для зберігання. Тепер йому потрібно перемістити їх у транспортні доки, щоб їх можна було відправити до завантажувальних відсіків. На жаль, сліди для пересування візків - це безлад, і йому потрібно придумати, як їх обійти, не врізавшись разом!

Виклик

Вам будуть надані доріжки для кожної з візків як списки "міток" (або станцій). Візки повинні бути переміщені таким чином, щоб у будь-який час не було жодної візки на одній етикетці / станції. По суті, візки пересуваються між положеннями, кожен з яких має унікальну етикетку.

Завдання

Враховуючи доріжки для кожного з візків як список списків етикеток (які є усіма натуральними цілими числами), визначте, коли кожен візок повинен бути відпущений, щоб в найкоротші терміни надійно відправити всі візки до місця призначення.

Ось пояснення того, як працює вся система треків. Скажімо, візок iвипускається вчасно t_iна доріжку з мітками T_i_1, T_i_2, ..., T_i_n. Тоді, під час t_1до t_i-1, кошик iне знаходиться на сітці, і його можна ігнорувати.

У часові рамки t_iкошик розміщений на етикетці T_i_1, і для кожного часового інтервалу t_kвід t_iдо t_i+n(напів включно) візок знаходиться на етикетці T_i_k+1.

За всі часові рамки після та включення t_i+n, візок знаходиться за призначенням і більше не знаходиться в сітці.

Загальний проміжок часу t_T- це останній часовий кадр, коли візок все ще знаходиться на доріжці в системі.

Технічні умови

Враховуючи систему треків, поверніть перелік часових рамків, [t_1, t_2, ..., t_n]де iпочинається в той час візок t_i, таким чином, щоб жодне інше розташування не дозволило б візкам безпечно дістатися до місця призначення з меншою загальною кількістю часу.

З точки зору «безпечно», якщо в будь-який момент часу кадр з t_1к t_Tє більш ніж один візок на будь-який ярлик, то вони стикаються і розташування не було «безпечним». Зауважте, що два візки можуть рухатись із a, bмісця b, aта залишатися "безпечними", оскільки доріжки є двосторонніми.

Технічні характеристики форматування

Введення подається у вигляді матриці натуральних чисел у будь-якому розумному форматі. Вихід повинен бути поданий у вигляді списку натуральних чисел у будь-якому розумному форматі. Ви можете дати вихід у нульові індексовані часові рамки, тож результат буде списком негативних цілих чисел у будь-якому розумному форматі.

Правила

• Застосовуються стандартні лазівки
• Це кодовий гольф, тому найкоротша відповідь у байтах виграє
• Відповідь не буде прийнято

Випробування

Input -> Output
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> [1, 1, 1]
[[1, 2, 3], [1, 2, 3]] -> [1, 2]
[[1, 2, 3], [3, 2, 1]] -> [1, 2]
[[1, 2, 3, 4], [4, 3, 2, 1]] -> [1, 1]
[[1, 1, 1], [1, 1, 1]] -> [1, 4]
[[1, 2, 3, 4], [2, 4, 3, 1]] -> [2, 1]
[[1, 2, 3, 4, 5, 6, 7], [2, 3, 3, 4], [5, 4, 3]] -> [1, 3, 4]
[[1, 2, 3, 4, 4], [1, 2, 3, 5, 4], [1, 2, 3, 4, 5]] -> [2, 3, 1]

^{Примітка: Натхнення для цієї серії викликів я черпав з Advent Of Code . Я не маю приналежності до цього сайту}

Ви можете переглянути список усіх викликів у серії, переглянувши розділ "Пов'язані" першого виклику тут .

Щасливого гольфу!

JavaScript (ES7), 172 байти

Повертає масив 0-індексованих часових кадрів.

a=>(g=k=>a.map((a,i)=>[l=a.length+1,i,a,L=L<l?l:L]).sort(([a],[b])=>a-b).every(([,n,b],i)=>b.every((c,t)=>o[t+=A[n]=k/L**i%L|0]&1<<c?0:o[t]|=1<<c),o=[],A=[])?A:g(k+1))(L=0)

Примітка . Це може працювати лише з мітками в [0-31]. Це обмеження JS, а не межа алгоритму.

Тестові справи

let f =

a=>(g=k=>a.map((a,i)=>[l=a.length+1,i,a,L=L<l?l:L]).sort(([a],[b])=>a-b).every(([,n,b],i)=>b.every((c,t)=>o[t+=A[n]=k/L**i%L|0]&1<<c?0:o[t]|=1<<c),o=[],A=[])?A:g(k+1))(L=0)

console.log(JSON.stringify(f([[1, 2, 3], [4, 5, 6], [7, 8, 9]])))                   // -> [0, 0, 0]
console.log(JSON.stringify(f([[1, 2, 3], [1, 2, 3]])))                              // -> [0, 1] or [1, 0]
console.log(JSON.stringify(f([[1, 2, 3], [3, 2, 1]])))                              // -> [0, 1] or [1, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4], [4, 3, 2, 1]])))                        // -> [0, 0]
console.log(JSON.stringify(f([[1, 1, 1], [1, 1, 1]])))                              // -> [0, 3] or [3, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4], [2, 4, 3, 1]])))                        // -> [1, 0]
console.log(JSON.stringify(f([[1, 2, 3, 4, 5, 6, 7], [2, 3, 3, 4], [5, 4, 3]])))    // -> [0, 2, 3]
console.log(JSON.stringify(f([[1, 2, 3, 4, 4], [1, 2, 3, 5, 4], [1, 2, 3, 4, 5]]))) // -> [1, 2, 0]

Прокоментував

a => (                         // given a = array of tracks
  g = k =>                     // g = recursive function taking k = counter
    a.map((t, i) => [          // map each track t in a to a new entry made of:
      l = t.length + 1,        //   - its length + 1 (l)
      i,                       //   - its original index in the input array
      t,                       //   - the original track data
      L = L < l ? l : L        //   and update the maximum track length L
    ])                         // end of map()
    .sort(([a], [b]) =>        // let's sort the tracks from shortest to longest
      a - b                    // so that solutions that attempt to delay short
    )                          // tracks are tried first
    .every(([, n, b],          // for each track b with an original position n,
                      i) =>    // now appearing at position i:
      b.every((c, t) =>        //   for each label c at position t in b:
        o[t += A[n] =          //     add to t the time frame A[n] corresponding
          k / L**i % L | 0     //     to this position (i) and this combination (k)
        ] & 1 << c ?           //     if the station c is already occupied at time t:
          0                    //       make every() fail
        :                      //     else:
          o[t] |= 1 << c       //       mark the station c as occupied at time t
      ),                       //   end of inner every()
      o = [],                  //   start with: o = empty array (station bitmasks)
      A = []                   //               A = empty array (time frames)
    ) ?                        // end of outer every(); if successful:
      A                        //   return A
    :                          // else:
      g(k + 1)                 //   try the next combination
)(L = 0)                       // initial call to g() + initialization of L