# Virtual Array - Google Top Interview Questions

### Problem Statement :

Implement a virtual array which implements the following methods:

void set(int start, int end) which sets the values in the array from [start, end] inclusive to true.

boolean get(int idx) which returns true if it is set, otherwise false.

Bonus: solve using \mathcal{O}(k)O(k) space total where k is the number of disjoint intervals.

Constraints

0 ≤ start ≤ end < 2 ** 31

0 ≤ n ≤ 100,000 where n is the number of calls to set and get

Example 1

Input

methods = ["constructor", "set", "get", "set", "get", "get"]

arguments = [[], [2, 5], [4], [8, 9], [6], [8]]

Output

[None, None, True, None, False, True]

Explanation

va = VirtualArray()

va.set(2, 5)

va.get(4) == True

va.set(8, 9)

va.get(6) == False

va.get(8) == False

Example 2

Input

methods = ["constructor", "set", "set", "get"]

arguments = [[], [10, 100], [6, 100], [9]]

Output

[None, None, None, True]

Explanation

va = VirtualArray()
va.set(10, 100)

va.set(6, 100)

va.get(9) == True

### Solution :

                        Solution in C++ :

class VirtualArray {
const long long A = 1LL << 32;
unordered_map<long long, int> a;

public:
VirtualArray() {
}

void upd(long long x, int d) {
++x;
while (x < A) a[x] += d, x += x & -x;
}

int qry(long long x) {
++x;
int y = 0;
while (x > 0) y += a[x], x -= x & -x;
return y;
}

void set(int start, int end) {
upd(start, 1);
upd(end + 1, -1);
}

bool get(int idx) {
return qry(idx) > 0;
}
};


                        Solution in Java :

import java.util.*;

class VirtualArray {
private final TreeMap<Integer, Integer> truth = new TreeMap<>();

public void set(int start, int end) {
Map.Entry<Integer, Integer> entry = truth.floorEntry(start);
{
if (entry != null && entry.getValue().intValue() >= start) {
truth.remove(entry.getKey());
start = Math.min(start, entry.getKey());
end = Math.max(end, entry.getValue());
}
}
{
while (true) {
entry = truth.ceilingEntry(start);
if (entry == null || entry.getKey().intValue() > end)
break;
truth.remove(entry.getKey());
end = Math.max(end, entry.getValue());
}
}
truth.put(start, end);
}

public boolean get(int idx) {
Map.Entry<Integer, Integer> entry = truth.floorEntry(idx);
return (entry != null && entry.getValue() >= idx);
}
}


                        Solution in Python :

class VirtualArray:
__slots__ = "start", "end", "mid", "_left", "_right", "state"

def __init__(self, start=0, end=2 ** 31):
self.start = start
self.end = end
self.mid = start + end >> 1
self._left = self._right = None
self.state = 0

@property
def left(self):
if not self._left:
self._left = VirtualArray(self.start, self.mid)
return self._left

@property
def right(self):
if not self._right:
self._right = VirtualArray(self.mid + 1, self.end)
return self._right

def set(self, s, e):
if s <= self.start and self.end <= e:
self.state = 1
elif e <= self.mid:
self.left.set(s, e)
elif s > self.mid:
self.right.set(s, e)
else:
self.left.set(s, e)
self.right.set(s, e)

def get(self, index):
if self.state == 1:
return True
elif self._left is self._right is None:
return False
elif index <= self.mid:
return self.left.get(index)
else:
return self.right.get(index)


## Pair Sums

Given an array, we define its value to be the value obtained by following these instructions: Write down all pairs of numbers from this array. Compute the product of each pair. Find the sum of all the products. For example, for a given array, for a given array [7,2 ,-1 ,2 ] Note that ( 7 , 2 ) is listed twice, one for each occurrence of 2. Given an array of integers, find the largest v

## Lazy White Falcon

White Falcon just solved the data structure problem below using heavy-light decomposition. Can you help her find a new solution that doesn't require implementing any fancy techniques? There are 2 types of query operations that can be performed on a tree: 1 u x: Assign x as the value of node u. 2 u v: Print the sum of the node values in the unique path from node u to node v. Given a tree wi

## Ticket to Ride

Simon received the board game Ticket to Ride as a birthday present. After playing it with his friends, he decides to come up with a strategy for the game. There are n cities on the map and n - 1 road plans. Each road plan consists of the following: Two cities which can be directly connected by a road. The length of the proposed road. The entire road plan is designed in such a way that if o

## Heavy Light White Falcon

Our lazy white falcon finally decided to learn heavy-light decomposition. Her teacher gave an assignment for her to practice this new technique. Please help her by solving this problem. You are given a tree with N nodes and each node's value is initially 0. The problem asks you to operate the following two types of queries: "1 u x" assign x to the value of the node . "2 u v" print the maxim

## Number Game on a Tree

Andy and Lily love playing games with numbers and trees. Today they have a tree consisting of n nodes and n -1 edges. Each edge i has an integer weight, wi. Before the game starts, Andy chooses an unordered pair of distinct nodes, ( u , v ), and uses all the edge weights present on the unique path from node u to node v to construct a list of numbers. For example, in the diagram below, Andy

## Heavy Light 2 White Falcon

White Falcon was amazed by what she can do with heavy-light decomposition on trees. As a resut, she wants to improve her expertise on heavy-light decomposition. Her teacher gave her an another assignment which requires path updates. As always, White Falcon needs your help with the assignment. You are given a tree with N nodes and each node's value Vi is initially 0. Let's denote the path fr