Problem:
Score : 700 points

Problem Statement

We have N gemstones labeled 1 through N.

You can perform the following operation any number of times (possibly zero).

Select a positive integer x, and smash all the gems labeled with multiples of x.

Then, for each i, if the gem labeled i remains without getting smashed, you will receive a_i yen (the currency of Japan).
However, a_i may be negative, in which case you will be charged money.

By optimally performing the operation, how much yen can you earn?

Constraints

All input values are integers.

1 \leq N \leq 100

|a_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

Print the maximum amount of money that can be earned.

Sample Input 1

6
1 2 -6 4 5 3

Sample Output 1

12

It is optimal to smash Gem 3 and 6.

Sample Input 2

6
100 -100 -100 -100 100 -100

Sample Output 2

200

Sample Input 3

5
-1 -2 -3 -4 -5

Sample Output 3

0

It is optimal to smash all the gems.

Sample Input 4

2
-1000 100000

Sample Output 4

99000

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

def addedge(graph, from, to, cap)
  graph[from]<<[to,cap,graph[to].size]
  graph[to]<<[from,0,graph[from].size-1]
end

def dfs (graph, used, from, sink, flow)
  return flow if from == sink
  used[from] = true
  
  graph[from].each{|edge|
    next if used[edge[0]] || (edge[1]<=0)
    
    fmin = edge[1]
    fmin = flow if fmin > flow
    
    d = dfs(graph, used, edge[0], sink, fmin)
    
    if d > 0 then
      edge[1] -= d
      graph[edge[0]][edge[2]][1] += d
      return d
    end
  }
  return 0
end

n = gets.to_i
a = gets.split.map &:to_i

#
inf = 100000000
v = n+2
#
source = 0
sink = n+1
graph = v.times.map{[]}
used = Array.new(v, false)
#
all = a.select{|t| t>0}.inject(:+).to_i

#addedge
a.each.with_index{|t, i|
  if t<=0 then
    addedge(graph, source, i+1, -t)
  else
    addedge(graph, i+1, sink, t)
  end
}
#ついでにたたきわる
n.times{|i|
  x = 2
  while (i+1)*x<=n
    addedge(graph, (i+1)*x, i+1, inf)
    x+=1
  end
}

#fordFulkerson
flow = 0
while 1
  v.times{|i| used[i]=false}
  f = dfs(graph, used, source, sink, inf)
  break if f==0
  flow += f
end

puts all-flow