Greater = Proc.new {|a, b| b <=> a}

Infinity = 1e+9.to_i

def main(argv)
  (n, c) = gets.chomp.split(' ').map(&:to_i)

  ps = [0] * n
  n.times{|i| ps[i] = gets.chomp.to_i}
  ps.sort!(&Greater)
  total = ps.reduce(:+)

  cs1 = []
  cs2 = []
  c.times do |j|
    cc = gets.chomp.split(' ').map(&:to_i)
    if cc[0] == 1 then
      cs1.push(cc[1])
    else # cc[0] == 2
      cs2.push(cc[1])
    end
  end
  cs1.sort!(&Greater)
  cs2.sort!(&Greater)

  dp = [nil] * (n + 1)
  (n + 1).times{|i| dp[i] = Hash.new}
  dp[0][{:c1 => 0, :c2 => 0}] = 0
  n.times do |i|
    dp[i].each do |state, value|
      dp[i + 1][state] = value + ps[i]

      if state[:c1] < cs1.size then
        next_state = {:c1 => state[:c1] + 1, :c2 => state[:c2]}
        cost = [ps[i] - cs1[state[:c1]], 0].max
        next_value = value + cost
        if dp[i + 1][next_state] == nil then
          dp[i + 1][next_state] = next_value
        else
          dp[i + 1][next_state] = [dp[i + 1][next_state], next_value].min
        end
      end

      if state[:c2] < cs2.size then
        next_state = {:c1 => state[:c1], :c2 => state[:c2] + 1}
        cost = ps[i] - ((ps[i] / 100) * cs2[state[:c2]])
        next_value = value + cost
        if dp[i + 1][next_state] == nil then
          dp[i + 1][next_state] = next_value
        else
          dp[i + 1][next_state] = [dp[i + 1][next_state], next_value].min
        end
      end
    end
  end

  min_cost = 1e+12.to_i
  dp[n].each{|state, value| min_cost = [min_cost, value].min}
  puts min_cost.to_s
end

main(ARGV) if self.to_s == 'main'