Codeforces Problem

E. Let's Go Rolling!

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

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.

Examples

input

Copy

3
2 3
3 4
1 2

output

5

input

Copy

4
1 7
3 1
5 10
6 1

output

11

题意：

有n个小球，所有小球都在一条线上，以该线为x轴，每个球在x轴上都有各自的位置，所有小球都有各自固定的费用。

初始状态每个小球都未固定，为固定的小球会向x轴的负半轴滚动，直到碰到一个固定的小球。

小球滚动的距离也算是费用。选择哪些小球固定或不固定。

求滚动费用与固定费用之和最小为多少。

我们先将每个点按照坐标升序排序

dp[i][j]中一维表示进行到第几个点，二维表示最后一个被固定的点

则递推到i点时分两种情况：

1: i点固定（加上需要固定的费用，i点后的小球不会往前滚），那么有dp[i][i]=min(dp[i][i],dp[i-1][j]+p[i].c);

2: i点不固定（则需要加上从j点向前滚到i点的费用），那么有dp[i][j]=min(dp[i][j],dp[i-1][j]+p[i].x-p[j].x);

#include<bits/stdc++.h>  
#define LL long long  
#define inf 0x3f3f3f3f  
using namespace std;  
struct node  
{  
    int x;  
    int c;  
}p[3005];  
LL dp[3005][3005];  
bool cmp(node one,node two)  
{  
    return one.x<two.x;  
}  
int main()  
{  
    int n;  
    scanf("%d",&n);  
    for(int i=1;i<=n;i++)  
    {  
        scanf("%d%d",&p[i].x,&p[i].c);  
    }  
    sort(p+1,p+1+n,cmp);  
    for(int i=1;i<=n;i++)  
    {  
        for(int j=1;j<=n;j++)  
            dp[i][j]=1e18;  
    }  
    dp[1][1]=p[1].c;  
    for(int i=2;i<=n;i++)  
    {  
        for(int j=1;j<i;j++)  
        {  
            dp[i][j]=min(dp[i][j],dp[i-1][j]+p[i].x-p[j].x);  
            dp[i][i]=min(dp[i][i],dp[i-1][j]+p[i].c);  
        }  
    }  
    LL ans=1e18;  
    for(int i=1;i<=n;i++)  
        ans=min(ans,dp[n][i]);  
    printf("%ld
",ans);  
}  

一维：

题解：
dp1[i]表示前i个球的最小花费，dp2[i]表示固定第i个球的最小花费。
则dp2[i]=dp1[i-1]+cost[i]。
dp1[i]=dp2[j]+ans;
ans表示j~i之间的球滚到了j位置的花费

#include<cstdio>  
#include<algorithm>  
using namespace std;  
#define ll long long   
struct node  
{  
    ll id,cost;  
}c[3003];  
bool cmp(node a,node b)  
{  
    return a.id<b.id;  
}  
ll dp1[3003],dp2[3003];  
ll min1(ll a,ll b)  
{  
    if(a>b)return b;  
    return a;  
}  
int main()  
{  
    int n;scanf("%d",&n);  
    for(int i=1;i<=n;i++)  
        scanf("%lld%lld",&c[i].id,&c[i].cost);  
    sort(c+1,c+n+1,cmp);  
    dp1[1]=dp2[1]=c[1].cost;  
    for(ll i=2;i<=n;i++)  
    {  
        ll ans=0;  
        dp1[i]=dp2[i]=dp1[i-1]+c[i].cost;  
        for(ll j=i-1;j>=1;j--)  
        {  
            ans=ans+(c[j+1].id-c[j].id)*(i-j);  
            dp1[i]=min1(dp1[i],dp2[j]+ans);  
        }  
    }  
    printf("%lld
",dp1[n]);  
    return 0;  
}  

题意：给你每个求的位置以及在这个点修卡点的费用，每个球都会向左滚，求让所有球停下来的最小费用

思路：DP， 先处理出当前点之前都跑到第一个点的距离和，然后用dp[i]表示到第i个点的最小费用，假设停在了第j个点，那么我们就要算上[j, i]所有点都跑到j的距离和，还有要算上修j的费用，最后减去[j, i]要跑到第1点的距离

#include <iostream>  
#include <cstring>  
#include <algorithm>  
#include <cstdio>  
using namespace std;  
typedef long long ll;  
const ll inf = 1e15;  
const int maxn = 3005;  
  
struct Node {  
    int x, c;  
    bool operator <(const Node &a) const {  
        return x < a.x;  
    }  
} node[maxn];  
  
ll sum[maxn], dp[maxn];  
  
int main() {  
    int n;  
    scanf("%d", &n);  
    for (int i = 1; i <= n; i++)  
        scanf("%d%d", &node[i].x, &node[i].c);  
    sort(node+1, node+1+n);  
    sum[0] = 0;  
    memset(dp, 0, sizeof(dp));  
    for (int i = 1; i <= n; i++)   
        sum[i] = sum[i-1] + node[i].x - node[1].x;  
    for (int i = 1; i <= n; i++) {  
        dp[i] = inf;  
        for (int j = 1; j <= i; j++)  
            dp[i] = min(dp[i], dp[j-1]+sum[i]-sum[j-1]-(ll)(node[j].x-node[1].x)*(i-j+1)+node[j].c);  
    }     
    printf("%lld
", dp[n]);  
    return 0;  
}