input: [10, 20, 30, 40]
instruction: Írj programot egy egész számokból álló tömb RMQ értékének meghatározására.
output: Íme egy Python implementáció a Segment Tree adatszerkezetet használva, amelynek időbonyolultsága mind a felépítés, mind a lekérdezés esetén O(log n):
  
  ```python
  class SegmentTree:
      def __init__(self, arr):
          self.arr = arr
          self.n = len(arr)
          # Létrehoz egy listát a szegmensfa csomópontjainak tárolására.
          self.tree = [None] * (4 * self.n)
          self.build(0, 0, self.n - 1)
  
      def build(self, node, start, end):
          if start == end:
              # levélcsomópont tárolja az egyes elemek értékét.
              self.tree[node] = self.arr[start]
          else:
              mid = (start + end) // 2
              # rekurzívan felépítjük a bal és jobb részfát
              self.build(2 * node + 1, start, mid)
              self.build(2 * node + 2, mid + 1, end)
              # tároljuk a bal és jobb részfa minimális értékét
              self.tree[node] = min(self.tree[2 * node + 1], self.tree[2 * node + 2])
  
      def query(self, node, start, end, left, right):
          if left > end vagy right < start:
              # az az eset, amikor a lekérdezési tartomány teljesen kívül esik az aktuális szegmensen.
              return float('inf')
          if left <= start és right >= end:
              # eset, amikor a lekérdezési tartomány teljesen átfedi az aktuális szegmenst.
              return self.tree[node]
          mid = (start + end) // 2
          # rekurzívan végigmegy a bal és jobb részfán és visszaadja a minimális értéket.
          return min(self.query(2 * node + 1, start, mid, left, right),
                     self.query(2 * node + 2, mid + 1, end, left, right))
  
  # használati példa
  arr = [10, 20, 30, 40]
  tree = SegmentTree(arr)
  print(tree.query(0, 0, tree.n - 1, 1, 2)) # kimenet: 20
  ```
  
  A fenti kódban a `SegmentTree` osztály két metódussal rendelkezik: `build` a szegmensfa rekurzív felépítéséhez, és `query` a minimális érték kereséséhez egy adott tartományon belül. A `build` metódusban az alapeset az, amikor a kezdő- és a végindex megegyezik, ami azt jelenti, hogy elértünk egy levélcsomópontot. Ellenkező esetben a tömböt két részre osztjuk, és rekurzívan létrehozzuk a bal és jobb részfát. Az egyes csomópontok minimális értéke a két gyermeke csomópontjainak a minimuma. A `query` metódusban többféle forgatókönyvet kell figyelembe vennünk: ha a lekérdezési tartomány teljesen kívül esik az aktuális szegmensen, adjuk vissza a végtelent; ha a lekérdezési tartomány teljesen átfedi az aktuális szegmenst, adjuk vissza az aktuális csomópontnál lévő értéket; egyébként rekurzívan menjünk a bal és jobb részfához, és adjuk vissza a kettő minimális értékét. Végül inicializáljuk a `SegmentTree` osztály egy példányát a bemeneti tömbtel, és meghívjuk a `query` metódust egy adott tartományban, hogy megtaláljuk a tömb RMQ értékét.