Let's Go Rolling! (Codeforces 38E)
Tags: DP, sortings

On a number axis directed from the left rightwards, n marbles with coordinates x1, x2, ..., xn are situated. Let's assume that the sizes of the marbles are infinitely small, that is in this task each of them is assumed to be a material point. You can stick pins in some of them and the cost of sticking in the marble number i is equal to ci, number ci may be negative. After you choose and stick the pins you need, the marbles will start to roll left according to the rule: if a marble has a pin stuck in it, then the marble doesn't move, otherwise the marble rolls all the way up to the next marble which has a pin stuck in it and stops moving there. If there is no pinned marble on the left to the given unpinned one, it is concluded that the marble rolls to the left to infinity and you will pay an infinitely large fine for it. If no marble rolled infinitely to the left, then the fine will consist of two summands:   the sum of the costs of stuck pins;  the sum of the lengths of the paths of each of the marbles, that is the sum of absolute values of differences between their initial and final positions. Your task is to choose and pin some marbles in the way that will make the fine for you to pay as little as possible.

Input: The first input line contains an integer n (1 ≤ n ≤ 3000) which is the number of marbles. The next n lines contain the descriptions of the marbles in pairs of integers xi, ci ( - 109 ≤ xi, ci ≤ 109). The numbers are space-separated. Each description is given on a separate line. No two marbles have identical initial positions.

Output: Output the single number — the least fine you will have to pay.


Sample Inputs:
3
2 3
3 4
1 2

4
1 7
3 1
5 10
6 1

Sample Outputs:
5

11

Solution (Python):
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
HASH_RANDOMIZE = True
from collections import Counter

def solve(n, xc):
    xc.sort()
    dp = [float('INF')] * n
    dp[0] = xc[0][1]
    for i in range(1, n):
        m = float('INF')
        for j in range(i):
            if dp[j] < m:
                m = dp[j]
            dp[j] = dp[j] + xc[i][0] - xc[j][0]
        dp[i] = m + xc[i][1]
    return min(dp)

def main():
    t = 1
    for _ in range(t):
        (n,) = inputarr()
        xc = [inputarr() for _ in range(n)]
        print(solve(n, xc))
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            (self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            (self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            (self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda : self.buffer.read().decode('ascii')
        self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
    """"""
    (sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop('end', '\n'))
    if kwargs.pop('flush', False):
        file.flush()
if sys.version_info[0] < 3:
    (sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
    (sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from random import getrandbits
RANDOM = getrandbits(32)

class HashWrapper(int):

    def __init__(self, x):
        int.__init__(x)

    def __hash__(self):
        return super(HashWrapper, self).__hash__() ^ RANDOM
input = lambda : sys.stdin.readline().rstrip('\r\n')
if HASH_RANDOMIZE:
    inputarr = lambda : [HashWrapper(int(x)) for x in input().split()]
else:
    inputarr = lambda : [int(x) for x in input().split()]
if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
f = []
for i in range(n):
    (x, c) = map(int, input().split())
    f.append([x, c])
f.sort()
dp = [[], []]
dp[1] = [f[0][1] for i in range(n)]
dp[0] = [10 ** 21 for i in range(n)]
for i in range(1, n):
    dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + f[i][1]
    d = 0
    for j in range(i - 1, -1, -1):
        d += (f[j + 1][0] - f[j][0]) * (i - j)
        dp[0][i] = min(dp[0][i], dp[1][j] + d)
print(min(dp[0][-1], dp[1][-1]))

Solution (Python):
n = int(input())
f = []
for i in range(n):
    (x, c) = map(int, input().split())
    f.append([x, c])
f.sort()
dp = [[], []]
dp[1] = [f[0][1] for i in range(n)]
dp[0] = [10 ** 21 for i in range(n)]
for i in range(1, n):
    dp[1][i] = min(dp[0][i - 1], dp[1][i - 1]) + f[i][1]
    d = 0
    for j in range(i - 1, -1, -1):
        d += (f[j + 1][0] - f[j][0]) * (i - j)
        dp[0][i] = min(dp[0][i], dp[1][j] + d)
print(min(dp[0][-1], dp[1][-1]))