3518. Smallest Palindromic Rearrangement II hard

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1435

Problem TLDR

K-th palindrome rearrangement

Intuition

Didn’t solved (even after yesterday preparation)
```j
// i looked at this problem yesterday
// let’s see if i could solve it today...
//
// btw yesterday acceptance rate in leetcode was 14%, now it is 30%
//
// this is a hard math statistics problem
// first take the half of the frequencies
//
// now we have to construct it letter by letter from ‘a’ to ‘z’
// to take a letter the count of possible permutations of leftovers f’s
// should be less than k
//
// now the hard part is to count how many permutations we have
//
// p = n!/f!(n-f)! n - total count, f - frequency we take
//
// and we need to take entire leftover frequencies, meaning it is
// p1*p2*p3
//
// n!/f!(n-f)! is calculated with Pascal’s Triangle
// new row = previus left + right
//
// 26 minute: wrong answer
// 40 minute: MLE (pascal triangle n^2)
```
* count frequencies - the problem now is the K-th permutation of frequencies (halved)
* construct string letter by letter; consider each letter in ‘a’..’z’, take the first where the *suffix* permutations count of remaining frequency is bigger or equal than K

Approach

* number of permutations of remaining frequency is just taking each letter indifidually n!/f[c]!(n-f[c])! and muliplying, then adjust n -= f[c]
* n!/f!(n-f)! could be computed as res *= n-i+1/i without pascal triangle because we can and should stop when reaching the K

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun smallestPalindrome(s: String, k: Int): String {
        var K = 1L*k; val max = K+1; val f = IntArray(26); for (c in s) ++f[c-'a']
        if (f.count { it%2 > 0} > 1) return ""; val mid = (0..25).firstOrNull { f[it]%2 > 0}
        fun C(n: Int, r: Int) = (1..min(r,n-r)).fold(1L){ a,i -> min(max, a*(n-i+1)/i) }
        fun P() = f.fold(1L to f.sum()) {(res,n), v -> min(max, res*C(n,v)) to  n - v}.first
        for (i in 0..25) f[i] /= 2; if (K > P()) return ""
        val half = buildString {
            for (step in 1..s.length/2) for (c in 0..25) if (f[c]>0) {
                --f[c]; val cnt = P(); if (cnt >= K){append('a'+c);break}; ++f[c]; K -= cnt
            }
        }
        return half + (mid?.let{'a'+it}?:"") + half.reversed()
    }

    pub fn smallest_palindrome(s: String, k: i32) -> String {
        let (mut K, M, mut f, mut h)=(k as i64, k as i64+1, [0i64;26], vec![]);  
        for b in s.bytes() { f[(b-97)as usize]+=1}; let mid = (0..26).find(|&i|f[i]%2>0);
        if f.iter().map(|v|v%2).sum::<i64>()>1 { return "".into()}; for v in &mut f {*v/=2}
        let C=|n:i64,r:i64|(1..=r.min(n-r)).fold(1,|a,i|M.min(a*(n-i+1)/i));
        let P=|f:&[i64]|f.iter().fold((1,f.iter().sum()),|(r,n),&v|(M.min(r*C(n,v)),n-v)).0;
        if K > P(&f) { return "".into()}
        for _ in 0..s.len()/2 { for i in 0..26 { if f[i] > 0 {
            f[i]-=1; let cnt = P(&f); if cnt>=K {h.push(97+i as u8);break};f[i]+=1; K-=cnt }}}
        let mut res = h.clone(); if let Some(i) = mid { res.push(97+i as u8)}
        res.extend(h.into_iter().rev()); String::from_utf8(res).unwrap()
    }

3517. Smallest Palindromic Rearrangement I medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1434

Problem TLDR

Smallest palindrome rearrangement

Intuition

Take first half and sort it.

Approach

* tip: prepare yourself for the k-th rearrangement

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun smallestPalindrome(s: String) = run {
        val h = s.take(s.length/2).map{it}.sorted().joinToString("")
        h + (if (s.length%2>0) s[s.length/2] else "") + h.reversed()
    }

    pub fn smallest_palindrome(s: String) -> String {
        let n = s.len(); let h = s[..n/2].chars().sorted();
        h.clone().chain(s[n/2..(n+1)/2].chars()).chain(h.rev()).collect()
    }

1464. Maximum Product of Two Elements in an Array easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1433

Problem TLDR

Max product in array

Intuition

Brute-force: iterate in a nested ‘for’ loops. Accepted.

Approach

* we can sort and take two max values
* we can scan and find two max values

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun maxProduct(n: IntArray) =
    n.sorted().run{(last()-1)*(get(n.size-2)-1)}

    pub fn max_product(n: Vec<i32>) -> i32 {
        n.iter().map(|&x|x-1).k_largest(2).product::<i32>()
    }

628. Maximum Product of Three Numbers easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1432

Problem TLDR

Max product of 3 numbers

Intuition

Take 3 largest and compare with taking two smallest and a one largest.

Approach

* Rust itertools has k_largest, s_smallest (the results are sorted differently)

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun maximumProduct(n: IntArray) = run { n.sort()
    val l = n.size-1; max(n[0]*n[1]*n[l], n[l]*n[l-1]*n[l-2])}

    pub fn maximum_product(n: Vec<i32>) -> i32 {
        let (a,b) = n.iter().copied().k_smallest(2).collect_tuple().unwrap();
        let (z,y,x) = n.iter().copied().k_largest(3).collect_tuple().unwrap();
        (a*b*z).max(x*y*z)
    }

3536. Maximum Product of Two Digits easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1431

Problem TLDR

Product of two largest digits in n

Intuition

Convert to string. Sort.

Approach

* Rust itertools has k_largest

Complexity

• Time complexity: O(logn*log log n)

• Space complexity: O(logn)

Code

    fun maxProduct(n: Int) = 
    "$n".map{it-'0'}.sorted().takeLast(2).let{it[0]*it[1]}

    pub fn max_product(n: i32) -> i32 {
        format!("0{n}").bytes().k_largest(2).map(|b| b as i32 - 48).product()
    }

3514. Number of Unique XOR Triplets II medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1430

Problem TLDR

Uniq xor of tripplets in array

Intuition

The number of uniq xors is very compressable, we can assume that converting n^2 pairwise to set gives a small colleciton

Approach

* to speed up more use boolean array/bitset

Complexity

• Time complexity: O(n^2)

• Space complexity: O(n^2)

Code

    fun uniqueXorTriplets(n: IntArray) = buildSet { 
        for (x in buildSet { for (x in n) for (y in n) add(x xor y) }) 
            for (y in n) add(x xor y) }.size

    pub fn unique_xor_triplets(mut n: Vec<i32>) -> i32 {
        n.sort_unstable(); n.dedup();
        let mut s = [false; 1 << 12]; let mut t = s.clone();
        for i in 0..n.len() { for j in i..n.len() { s[(n[i] ^ n[j]) as usize] = true }}
        for x in 0..s.len() { if s[x] { for &v in &n { t[x ^ v as usize] = true }}}
        t.iter().filter(|&&b| b).count() as _
    }

3513. Number of Unique XOR Triplets I medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1429

Problem TLDR

Uniq xor of tripplets of 1..n

Intuition

```j
// for xor order doesnt matter
// nums are the same 1..n
// 1 xor 1 = 0
// 1 ^ 0 = 1
// 1 ^ 0 ^ 1 = 0
// 1 ^ 0 ^ 0 = 1
// 1 ^ 1 ^ 1 = 1
// 1 ^ 1 ^ 0 = 0
// uniq?
```
Order doesnt matter. The maximum value 0b1xxxxx allows to construct any intermediate value by taking 1 xor 1 xor n[i] plus tail bits can construct any value of up to 2*max.

Approach

* simulate and see the results, then derive whats happening

Complexity

• Time complexity: O(logn)

• Space complexity: O(1)

Code

    fun uniqueXorTriplets(n: IntArray) =
    if (n.size <3) n.size else 2*n.size.takeHighestOneBit()

    pub fn unique_xor_triplets(n: Vec<i32>) -> i32 {
        let l = n.len() as i32; if l < 3 { l } else { 1 << (32 - l.leading_zeros()) }
    }

3501. Maximize Active Section with Trade II hard

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1428

Problem TLDR

Queries l..r of max ones after replacing surrounding zeros in range

Intuition

Didn’t solve.
```j
// 10 minute: how to shrink the sliding window and update max?
// 16 minute: no idea, lets look at hints - segment tree, no hope for that
```
Sort ranges by R. Scan string, track current zeros group and previous zeros group start and lengths.
BIT answers the question what is the max value in the suffix from L. We are filling the BIT by current position so it is always the range L..R.
Update BIT at start of the left group with value of both group sizes.
Query BIT by L of the query.

Corner case: BIT misses the first group if L happens to be at zeros. To overcome, track zeros counts and next zeros position for each position suffixes.

Approach

* threre are segment tree and sparse table solution which i didn’t get yet.

Complexity

• Time complexity: O(nlogn)

• Space complexity: O(n)

Code

    fun maxActiveSectionsAfterTrade(s: String, q: Array<IntArray>) = run {
        val n = s.length; val ones = s.count { it == '1' }; val bit = IntArray(n + 2)
        fun up(i: Int, v: Int) { var x = i + 1; while (x > 0) { bit[x] = max(bit[x], v); x -= x and -x } }
        fun qu(i: Int)=run{ var x = i + 1; var v = 0; while (x <= n + 1) { v = max(v, bit[x]); x += x and -x };v}
        val z = IntArray(n + 1); val nxt = IntArray(n + 1) { n }; val byR = q.indices.groupBy { q[it][1] }
        for (j in n - 1 downTo 0) if (s[j] == '0') { z[j] = 1 + z[j + 1]; nxt[j] = j } else nxt[j] = nxt[j + 1]
        val res = IntArray(q.size); var pStart = 0; var pLen = 0; var cLen = 0
        for (i in s.indices) {
            if (s[i] == '0') { cLen++; if (pLen > 0) up(pStart, pLen + cLen) }
            else if (cLen > 0) { pStart = i - cLen; pLen = cLen; cLen = 0 }
            byR[i]?.forEach { qi ->
                val l = q[qi][0]; val g2 = if (s[l] == '0') nxt[l + z[l]] else n
                val g = if (g2 <= i) minOf(z[l], i - l + 1) + minOf(z[g2], i - g2 + 1) else 0
                res[qi] = ones + maxOf(qu(l), g)
            }
        }; res
    }

3499. Maximize Active Section with Trade I medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1427

Problem TLDR

Max ones after replacing surrounding zeros

Intuition

Count max of surrounding zeros plus total ones.

Approach

* only 4 variables necessary, but we can count ones in the same loop, that adds variables

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun maxActiveSectionsAfterTrade(s: String): Int {
        var pp = 0; var p = 0; var c = 0; var ch = '1'
        return s.count {it=='1'}+s.maxOf { x ->
            if (x == ch) c++  else { pp = p; p = c; c = 1; ch = x }
            if (x == '0' && p>0 && pp>0) pp+c else 0
        }
    }

    pub fn max_active_sections_after_trade(s: String) -> i32 {
        let (mut pp, mut p, mut c, mut k) = (0, 0, 0, 0);
        s.bytes().filter(|&b| b == 49).count() as i32 + s.bytes().map(|b| {
            if b == k { c += 1 } else { (pp, p, c, k) = (p, c, 1, b) }
            if b == 48 && pp > 0 { pp + c } else { 0 }
        }).max().unwrap_or(0) 
    }

1260. Shift 2D Grid easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1426

Problem TLDR

Shift right 2d grid

Intuition

Flatten, rotate, chunk.

Approach

* don’t forget % size

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun shiftGrid(g: Array<IntArray>, k: Int) = g.flatMap{it.asList()}
    .run{(takeLast(k%size) + dropLast(k%size)).chunked(g[0].size)}

    pub fn shift_grid(g: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
        let mut v = g.concat(); let k = k as usize % v.len(); v.rotate_right(k);
        v.chunks(g[0].len()).map(|c|c.to_vec()).collect()
    }

1081. Smallest Subsequence of Distinct Characters medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1425

Problem TLDR

Smallest uniq-chars subsequence

Intuition

Didn’t solve. Stack-based algorightm was a little bit unexpected for me.
```j
// 46 minute TLE, n^3 algo, full search dp
// 26^26 = 6*10^36
// basically i give up at 1:28
// the solution is stack-based
// remove from stack if we find a better variant and stack peek
// can be found forward
```
Greedily take every char.
If current is better than the last taken, consider popping the last if there is the same in the suffix.

Approach

* hashset is not necessary, the result is less than 26

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun smallestSubsequence(s: String) = buildString {
        val lastPos = IntArray(26); for (i in s.indices) lastPos[s[i]-'a'] = i
        for (i in s.indices) if (s[i] !in this) {
            while (length > 0 && last() > s[i] && lastPos[last()-'a'] > i)
                setLength(lastIndex)
            append(s[i])
        }
    }

    pub fn smallest_subsequence(s: String) -> String {
        let (mut last, mut res) = ([0; 128], String::new());
        for (i, b) in s.bytes().enumerate() { last[b as usize] = i; }
        for (i, b) in s.bytes().enumerate() { if !res.contains(b as char) {
            while res.bytes().last().map_or(false, |l| l > b && last[l as usize] > i) {
                res.pop();
            }
            res.push(b as char);
        }} res
    }

1979. Find Greatest Common Divisor of Array easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1424

Problem TLDR

GCD of min & max

Intuition

Iterate and find the min, max, then the gcd.

Approach

* remember gcd: ab bab means a/b b should not be 0, then the recursive call of b,a%b
* Rust: sort gives the shortest code; also there is a minmax from itertools
* Kotlin: make the entire solution recursive

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun findGCD(n: IntArray, a:Int=n.max(), b:Int=n.min()):Int=
        if(b==0)a else findGCD(n, b,a%b)

    pub fn find_gcd(n: Vec<i32>) -> i32 {
        let (mut b, mut a) = n.into_iter().minmax().into_option().unwrap();
        while b > 0 { (a, b) = (b, a % b) } a
    }

3312. Sorted GCD Pair Queries hard

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1423

Problem TLDR

Queries of position of gcd of every pair in a sorted order

Intuition

Didn’t solved
```j
// 5:30 - have no idea
// dp[i] = how many gcds are up to i
// sort numbers, 1 2 4 4
// i ?
// 8: 00 look for hints: number of pair that have some gcd=g
// again, no idea how
// inclusion-exclusion: ?
// 11:38 gave up
```
Count number of gcds by computing for each gcd how many multipliers we have. Precompute the multipliers with frequency.
Subtract overcounted results of gcd[2*a],[3*a] and so on.
Binary search in a prefix sum of gcds count.

Approach

* computing multipliers in a forward way to find all gcds count is a clever idea

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun gcdValues(n: IntArray, q: LongArray) = run {
        val m = n.max(); val c = IntArray(m+1); for (x in n) ++c[x]; val g = LongArray(m+1)
        for (a in m downTo 1) g[a] = (a..m step a)
            .sumOf{c[it]}.let { 1L*it*(it-1)/2}-(a*2..m step a).sumOf {g[it]}
        for (i in 1..m) g[i] += g[i - 1]
        q.map { v -> g.asList().binarySearch { if (it <= v) -1 else 1 }.inv() }
    }

    pub fn gcd_values(n: Vec<i32>, q: Vec<i64>) -> Vec<i32> {
        let m = *n.iter().max().unwrap() as usize; let mut f = vec![0u64; m + 1]; 
        let mut g = f.clone(); for n in n { f[n as usize] += 1 };
        for i in (1..=m).rev() {
            let k: u64 = (i..=m).step_by(i).map(|j| f[j]).sum();
            g[i] = k * (k - 1) / 2 - (i * 2..=m).step_by(i).map(|j| g[j]).sum::<u64>();
        }
        for i in 1..=m { g[i] += g[i - 1] }
        q.iter().map(|&x| g.partition_point(|&v| v <= x as u64) as i32).collect()
    }

3867. Sum of GCD of Formed Pairs medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1422

Problem TLDR

Sum of gcd(min,max) of gcd(x, prefix max)

Intuition

The entire algorithm is give, just implement.

Approach

* remember gcd as `a/b, bab`

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun gcdSum(n: IntArray) = run {
        var max = 0; fun gcd(a: Int, b: Int): Int = if (b==0)a else gcd(b,a%b)
        val g = n.map { max=max(max,it);gcd(max, it) }.sorted()
        (0..<g.size/2).sumOf { i -> 1L*gcd(g[i],g[g.size-1-i]) }
    }

    pub fn gcd_sum(n: Vec<i32>) -> i64 {
        let g = |mut a, mut b| { while b != 0 { (a, b) = (b, a % b); } a };
        let mut m = 0;
        let s: Vec<_> = n.iter().map(|&x| { m = m.max(x); g(m, x) }).sorted().collect();
        (0..s.len() / 2).map(|i| g(s[i], s[s.len() - 1 - i]) as i64).sum()
    }

3658. GCD of Odd and Even Sums easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1421

Problem TLDR

Gcd of odds and evens

Intuition

Calculate sums, calculate gcd.
Or.. return `n`: sum of odds is n^2, sum of evens is n(n+1).

Approach

* remember gcd as `a/b, bab`

Complexity

• Time complexity: O(n)

• Space complexity: O(1)

Code

    fun gcdOfOddEvenSums(n: Int) = run{
        fun gcd(a: Int, b: Int): Int = if (b==0)a else gcd(b,a%b)
        gcd((1..2*n step 2).sum(), (2..2*n step 2).sum())
    }

    pub fn gcd_of_odd_even_sums(n: i32) -> i32 { n }

3336. Find the Number of Subsequences With Equal GCD hard

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

Problem TLDR

Equal gcd subsequencies

Intuition

```j
// 200 length and 200 max
// the gcd can be fixed?
// 6 minute: i have no idea, go for hints: dp[i][gcd1][gcd2]
// 21 minute: wrong answer 615/622 test case
```
Used the hint.
* dp [i] [gcd1] [gcd2] take to the first or take to the second or skip

Approach

* the bottom up: flatten the gcd1xgcd2 table, use only the previous table, result is a diagonal sum

Complexity

• Time complexity: O(n^3)

• Space complexity: O(n^2)

Code

    fun subsequencePairCount(n: IntArray): Long {
        val dp = HashMap<Int, Long>(); val M = 1000000007L
        fun gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
        fun f(i: Int, x: Int, y: Int): Long = if (i == n.size)
            if (x == y) 1L else 0L else dp.getOrPut(i*40401+x*201+y) {
            (f(i+1, gcd(n[i],x), y) + f(i+1, x, gcd(n[i],y)) + f(i+1, x, y)) % M }
        return (f(0, 0, 0) - 1 + M) % M
    }

    pub fn subsequence_pair_count(n: Vec<i32>) -> i32 {
        let (mut dp, M) = ([0i64; 201*201], 1_000_000_007); dp[0] = 1;
        let g = |mut a: usize, mut b: usize| { while b > 0 {(a,b)=(b,a%b)} a };
        for v in n { let mut nxt = dp;
            for i in 0..201*201 { if dp[i] > 0 {
                let g1 = g(i/201, v as usize) * 201 + i%201;
                let g2 = i/201 * 201 + g(i%201, v as usize);
                nxt[g1] = (nxt[g1] + dp[i]) % M;
                nxt[g2] = (nxt[g2] + dp[i]) % M
            }} dp = nxt }
        ((1..201).map(|i| dp[i * 201 + i]).sum::<i64>() % M) as i32
    }

1291. Sequential Digits medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1419

Problem TLDR

Increasing digit numbers in a range

Intuition

The possible set of numbers is very small. Generate all then filter and sort.

Approach

* iterate over lengths, sliding window over string in an inner loop

Complexity

• Time complexity: O(log^2(n))

• Space complexity: O(log^2(n))

Code

    fun sequentialDigits(l: Int, h: Int) = 
    (2..9).flatMap{"123456789".windowed(it)}.map{it.toInt()}.filter{it in l..h}

    pub fn sequential_digits(l: i32, h: i32) -> Vec<i32> {
        (2..10).flat_map(|w|(1..11-w).map(move |x| (x..x+w).fold(0,|r,t|r*10+t)))
               .filter(|&x|l<=x&&x<=h).collect()
    }

1331. Rank Transform of an Array easy

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1418

Problem TLDR

Rank of items in an array

Intuition

Sort. Dedup. Binary search each number.

Approach

* we can use toSortedMap().run { ... headSet(it).size } but leetcode give TLE, still O(nlogn)
* Rust: use itertools and collect tuples to the hashmap

Complexity

• Time complexity: O(nlogn)

• Space complexity: O(n)

Code

    fun arrayRankTransform(a: IntArray) =
    a.toSet().sorted().run { a.map { binarySearch(it) + 1 } }

6

2685. Count the Number of Complete Components medium

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1417

Problem TLDR

Fully connected components

Intuition

1. Union-Find to find connected components
2. Count incoming edges for each node
3. Fully connected group size is the number of edges for each node +1

Approach

* 50 elements can fit into long variable
* adjacency matrix would look the same for each group

Complexity

• Time complexity: O(n)

• Space complexity: O(n)

Code

    fun countCompleteComponents(n: Int, e: Array<IntArray>) = e
        .fold(LongArray(n){1L shl it}){ m, (a, b) -> m[a] += 1L shl b; m[b] += 1L shl a; m }
        .groupBy { it }.count { (k, v) -> v.size == k.countOneBits() }

6

3534. Path Existence Queries in a Graph II hard

https://dmitrysamoylenko.com/leetcode/

Join me on Telegram

https://t.me/leetcode_daily_unstoppable/1416

Problem TLDR

Queries of connected nodes shortest distances

Intuition

Didn’t solved.
```j
// 1 1 1 1 1 1 1 1 1 1 1 from every node to every node dist = 1
// 1 2 . 4 5 6 7 8 9 md=2
// * * .
// 1 1 .
// * . *
// 2 1 . 0
// . * *
// 2 2 . 1 0
// . * * *
// 2 2 . 1 1 0
// 3 2 . 2 1 1 0
// 3 3 . 2 2 1 1 0
// 3 3 . 2 2 2 1 1 0
// 4 3 . 3 2 2 2 1 1 0
// ^
// can be removed, distances stay the same
// so the distance is (a-b)/md

// 1 hr mark: wrong answer: 91, 92, 127, 173, 179, 182 md=51, 91-182 my 2, correct 3
// so this simple formula doesnt work
// 182-91=91; 91/51 = 2
// but 91+51 = 142, so we go to 127
// 127+51 = 178, we have to go to 173
// 173+51=200+ we arrive at 182 at 3 steps
// that means for each number we should track next reachable
// or do dp[current_position][steps_required]=reachable_position
// but this is O(n^2), so let’s give up
// hints: binary jumping (?)

```
* sort the numbers
* use sliding window to find the rightmost jump for every cell: left goest +1, right goes until diff is bigger than max
* prepare binary lifting jump table: u[k][x] = u[k-1][Y] where Y = u[k-1][x]; for each x we prepare all 2^k (0..31) jumps by reusing previous;
* in query: find the left ‘c’ pointer and the right ‘t’ pointer positions
* by moving the left ‘c’ pointer with jump table count the jumps st += 2^k if it is not overshoot the right ‘t’ pointer u[k][c]<t

Approach

* learn the binary lifting

Complexity

• Time complexity: O(nlogn)

• Space complexity: O(n)

Code

    fun pathExistenceQueries(n: Int, ns: IntArray, md: Int, qs: Array<IntArray>)=run{
        val s = ns.sorted(); val u = Array(18){IntArray(n)}; var r = 0
        for (l in 0..<n) { while (r+1<n && s[r+1]-s[l]<=md)++r; u[0][l]=r}
        for (k in 1..17) for (x in 0..<n) u[k][x] = u[k-1][u[k-1][x]]
        qs.map {(a,b) -> if (a==b)return@map 0
            var c = s.binarySearch(min(ns[a],ns[b])); val t = s.binarySearch(max(ns[a],ns[b]))
            if (u[17][c]<t) return@map -1; var st = 1
            for (k in 17 downTo 0) if (u[k][c]<t) {c = u[k][c]; st += 1 shl k }; st
        }
    }