class PriorityQueue
  def initialize(array = [])
    @data = []
    array.each{|a| push(a)}
  end

  def push(element)
    @data.push(element)
    bottom_up
  end

  def pop
    if size == 0
      return nil
    elsif size == 1
      return @data.pop
    else
      min = @data[0]
      @data[0] = @data.pop
      top_down
      return min
    end
  end

  private

  def swap(i, j)
    @data[i], @data[j] = @data[j], @data[i]
  end

  def size
    @data.size
  end

  def parent_idx(target_idx)
    (target_idx - (target_idx.even? ? 2 : 1)) / 2
  end

  def bottom_up
    target_idx = size - 1
    return if target_idx == 0
    parent_idx = parent_idx(target_idx)
    while (@data[parent_idx].first > @data[target_idx].first)
      swap(parent_idx, target_idx)
      target_idx = parent_idx
      break if target_idx == 0
      parent_idx = parent_idx(target_idx)
    end
  end

  def top_down
    target_idx = 0

    # child がある場合
    while (has_child?(target_idx))

      a = left_child_idx(target_idx)
      b = right_child_idx(target_idx)

      if @data[b].nil?
        c = a
      else
        c = @data[a].first <= @data[b].first ? a : b
      end

      if @data[target_idx].first > @data[c].first
        swap(target_idx, c)
        target_idx = c
      else
        return
      end
    end
  end

  # @param Integer
  # @return Integer
  def left_child_idx(idx)
    (idx * 2) + 1
  end

  # @param Integer
  # @return Integer
  def right_child_idx(idx)
    (idx * 2) + 2
  end

  # @param Integer
  # @return Boolent
  def has_child?(idx)
    ((idx * 2) + 1) < @data.size
  end
end

# require 'pry'

N = gets.chomp.to_i
A = gets.chomp.split(' ').map(&:to_i)
B = gets.chomp.split(' ').map(&:to_i)

# print B

def i(i)
  i % N
end

m = B.max
m_idx = B.index{|v| v == m}

new_b = []
B.each_with_index do |v, i|
  new_b << [v*(-1), i]
end

p_b = PriorityQueue.new(new_b)

@ans = 0
while (true)
  if (A[m_idx] < B[m_idx])
    diff = (m - (B[i(m_idx - 1)] + B[i(m_idx + 1)])) 
    if diff > 0
      B[m_idx] = diff
      p_b.pop
      p_b.push([diff*(-1), m_idx])
      tmp_max = p_b.pop
      p_b.push(tmp_max)
      m = tmp_max[0]*(-1)
      m_idx = tmp_max[1]
      # binding.pry
      # binding.pry
      # m = B.max
      # m_idx = B.index{|v| v == m}      
      @ans += 1
    else
      @ans = -1
      break
    end
  else
    break
  end
end

if B == A
  puts @ans
else
  puts -1
end
# binding.pry





