Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], skipTags: ["script","noscript","style","textarea","code"], processEscapes: true }});

Farm Village

There is a village along a road. This village has $N$ houses numbered $1$ to $N$ in order along the road. Each house has a field that can make up to two units of the crop and needs just one unit of the crop. The total cost to distribute one unit of the crop to each house is the summation of carrying costs and growing costs.

The carrying cost: The cost to carry one unit of the crop between the $i$-th house and the ($i+1$)-th house is $d_i$. It takes the same cost in either direction to carry.

The growing cost: The cost to grow one unit of the crop in the $i$-th house's field is $g_i$.

Your task is to calculate the minimum total cost to supply one unit of the crop to each house.

Input

The input consists of a single test case formatted as follows.

$N$
$d_1$ ... $d_{N-1}$
$g_1$ ... $g_{N}$

The first line consists of an integer $N$ ($2 \leq 200,000$), which is the number of the houses. The second line consists of $N-1$ integers separated by spaces. The $i$-th integer $d_i$ ($1 \leq d_i \leq 10^9$, $1 \leq i \leq N-1$)represents the carrying cost between the $i$-th and the ($i+1$)-th houses. The third line consists of $N$ integers separated by spaces. The $i$-th integer $g_i$ ($1 \leq g_i \leq 10^9$, $1 \leq i \leq N$) represents the growing cost of the $i$-th house's field.

Output

Print the minimum cost to supply one unit of the crop to each house.

Sample Input 1

2
3
1 5

Output for Sample Input 1

5

Sample Input 2

3
100 100
1 2 3

Output for Sample Input 2

6

Sample Input 3

4
1 2 3
1 1 100 100

Output for Sample Input 3

12

Solution in Ruby (judge verdict: Wrong Answer)

class FarmVillage
  def initialize(number_of_houses:, carrying_costs:, growing_costs:)
    @number_of_houses = number_of_houses
    @carrying_costs = carrying_costs.dup
    @growing_costs = growing_costs.dup
  end

  def calc_total_cost
    total_cost = 0

    @fields_productions = Array.new(@number_of_houses, 0)
    @imports = Array.new(@number_of_houses, nil)

    houses = (0...@number_of_houses).zip(@growing_costs).sort{|a, b| a[1] <=> b[1]}.map{|t| t[0]}

    houses.each do |house|
      local_cost, local_crop_house = calc_local_crop_cost(house: house)
      left_cost, left_crop_house = calc_left_import_cost(consumer_house: house)
      right_cost, right_crop_house = calc_right_import_cost(consumer_house: house)

      costs = []
      costs << local_cost unless local_cost.nil?
      costs << left_cost unless left_cost.nil?
      costs << right_cost unless right_cost.nil?

      if local_cost == costs.min
        total_cost += local_cost
        @fields_productions[local_crop_house] += 1
        @imports[house] = local_crop_house
      elsif left_cost == costs.min
        total_cost += left_cost
        @fields_productions[left_crop_house] += 1
        @imports[house] = left_crop_house
      elsif right_cost == costs.min
        total_cost += right_cost
        @fields_productions[right_crop_house] += 1
        @imports[house] = right_crop_house
      end
    end

    total_cost
  end

  private

  def calc_local_crop_cost(house:)
    cost = nil
    new_crop_house = nil
    if @fields_productions[house] < 2
      cost = @growing_costs[house]
      new_crop_house = house
    else
      export_houses = @imports.each_index.select {|i| @imports[i] == house}
      export_house_a = export_houses.first
      export_house_b = export_houses.last

      export_house_a_cost = nil
      new_crop_house_a = nil
      if export_house_a < house
        export_house_a_cost, new_crop_house_a = calc_left_import_cost(consumer_house: export_house_a)
      else
        export_house_a_cost, new_crop_house_a = calc_right_import_cost(consumer_house: export_house_a)
      end
      export_house_a_cost -= calc_carrying_cost(house, export_house_a) unless export_house_a_cost.nil?

      export_house_b_cost = nil
      new_crop_house_b = nil
      if export_house_b < house
        export_house_b_cost, new_crop_house_b = calc_left_import_cost(consumer_house: export_house_b)
      else
        export_house_b_cost, new_crop_house_b = calc_right_import_cost(consumer_house: export_house_b)
      end
      export_house_b_cost -= calc_carrying_cost(house, export_house_b) unless export_house_b_cost.nil?

      if !export_house_a_cost.nil?
        cost = export_house_a_cost
        new_crop_house = new_crop_house_a
      end

      if !export_house_b_cost.nil?
        if cost.nil? || export_house_b_cost < cost
          cost = export_house_b_cost
          new_crop_house = new_crop_house_b
        end
      end
    end
    [cost, new_crop_house]
  end

  def calc_left_import_cost(consumer_house:)
    calc_import_cost(consumer_house: consumer_house,
                     carrying_costs: @carrying_costs,
                     fields_productions: @fields_productions,
                     growing_costs: @growing_costs)
  end

  def calc_right_import_cost(consumer_house:)
    import_cost, import_house = calc_import_cost(consumer_house: @number_of_houses-1-consumer_house,
                                                 carrying_costs: @carrying_costs.reverse,
                                                 fields_productions: @fields_productions.reverse,
                                                 growing_costs: @growing_costs.reverse)
    import_house = @number_of_houses-1-import_house unless import_house.nil?

    [import_cost, import_house]
  end

  def calc_import_cost(consumer_house:, carrying_costs:, fields_productions:, growing_costs:)
    total_carrying_cost = 0
    total_carrying_costs = Array.new(consumer_house)
    (0...consumer_house).reverse_each do |house|
      total_carrying_cost += carrying_costs[house]
      total_carrying_costs[house] = total_carrying_cost
    end

    last_crop_house = nil
    crop_houses = Array.new(consumer_house)
    costs = Array.new(consumer_house)
    (0...consumer_house).each do |house|
      if fields_productions[house] < 2
        last_crop_house = house
      end

      if !last_crop_house.nil?
        crop_houses[house] = last_crop_house
        costs[house] = total_carrying_costs[last_crop_house] + growing_costs[last_crop_house]
      end
    end

    import_cost = nil
    import_house = nil
    costs.each_with_index do |cost, index|
      if !cost.nil?
        if import_cost.nil? || cost < import_cost
          import_cost = cost
          import_house = crop_houses[index]
        end
      end
    end

    [import_cost, import_house]
  end

  def calc_carrying_cost(house_a, house_b)
    house_a, house_b = house_b, house_a if house_a > house_b
    @carrying_costs[house_a...house_b].inject(:+)
  end
end

number_of_houses = gets.to_i
carrying_costs = gets.split.map(&:to_i)
growing_costs = gets.split.map(&:to_i)

farm_village = FarmVillage.new(number_of_houses: number_of_houses,
                               carrying_costs: carrying_costs,
                               growing_costs: growing_costs)

puts farm_village.calc_total_cost