# https://atcoder.jp/contests/abc116/tasks/abc116_d
class PopHeap
  attr_accessor :nodes, :size
  def initialize
    @nodes = []
    @size = 0
  end

  def push(x)
    current_index = @size
    @size += 1
    while current_index > 0 do
      parent_index = (current_index - 1)>>1
      parent_value = @nodes[parent_index]
      break if parent_value <= x
      @nodes[current_index] = parent_value
      current_index = parent_index
    end
    @nodes[current_index] = x
  end

  def pop
    top = @nodes[0]
    current_node_index = 0
    current_node_value = @nodes[0] = @nodes[@size - 1]
    @nodes[@size - 1] = nil
    @size -= 1

    while
      child_node_index_r = (current_node_index + 1) << 1
      child_node_index_l = child_node_index_r - 1
      return top unless child_node_index_l < @size
      child_node_value_l = @nodes[child_node_index_l]
      child_node_value_r = @nodes[child_node_index_r]
      if child_node_value_r&.<child_node_value_l
        min_child_value = child_node_value_r
        min_child_index = child_node_index_r
      else
        min_child_value = child_node_value_l
        min_child_index = child_node_index_l
      end
      return top unless min_child_value < current_node_value
      change(current_node_index, min_child_index)
      current_node_index = min_child_index
    end
  end

  private

  def change(index_i, index_j)
    @nodes[index_i], @nodes[index_j] = @nodes[index_j], @nodes[index_i]
  end
end

class ReversePopHeap
  attr_accessor :nodes, :size
  def initialize
    @nodes = Array.new
    @size = 0
  end

  def push(x)
    current_index = @size
    @size += 1
    while current_index > 0 do
      parent_index = (current_index - 1)>>1
      parent_value = @nodes[parent_index]
      break if parent_value >= x
      @nodes[current_index] = parent_value
      current_index = parent_index
    end
    @nodes[current_index] = x
  end

  def pop
    top = @nodes[0]
    current_node_index = 0
    current_node_value = @nodes[0] = @nodes[@size - 1]
    @nodes[@size - 1] = nil
    @size -= 1

    while
      child_node_index_r = (current_node_index + 1) << 1
      child_node_index_l = child_node_index_r - 1
      return top unless child_node_index_l < @size
      child_node_value_l = @nodes[child_node_index_l]
      child_node_value_r = @nodes[child_node_index_r]
      if child_node_value_r&.>child_node_value_l
        max_child_value = child_node_value_r
        max_child_index = child_node_index_r
      else
        max_child_value = child_node_value_l
        max_child_index = child_node_index_l
      end
      return top unless max_child_value > current_node_value
      change(current_node_index, max_child_index)
      current_node_index = max_child_index
    end
  end

  private

  def change(index_i, index_j)
    @nodes[index_i], @nodes[index_j] = @nodes[index_j], @nodes[index_i]
  end
end

N, K = gets.split.map(&:to_i)
max_in_type = {}
values = []

N.times do
  temp = gets.split.map(&:to_i)
  max_in_type[temp[0]] = temp[1] if !(max_in_type[temp[0]]&.>(temp[1]))
  values << temp
end

ph = PopHeap.new
sum = 0
use_type_count = 0
type_flags = {}

values.sort_by {|t, v| v}.reverse[0...K].each do |t, v|
  sum += v
  if !type_flags[t]
    type_flags[t] = true
    use_type_count += 1
  else
    ph.push(v)
  end
end
ans = sum + use_type_count**2

rph = max_in_type.each_with_object(ReversePopHeap.new) do |(k, v), obj|
  if !type_flags[k]
    # p "#{k} #{v}"
    obj.push(v)
  end
end


t = 0
phsize = ph.size
rphsize = rph.size
# p "#{rphsize} #{phsize}"
(phsize > rphsize ? rphsize : phsize).times do
  sum = sum - ph.pop + rph.pop
  t = sum + (use_type_count += 1)**2
  ans = t if t > ans
end

p ans

Measured memory_bytes: 21212