题目大意：

有n个路灯，每个路灯都有各自的位置ai，以及功率bi，已知小明站在某个c路灯处，小明的步行速率是1m/s，问我们小明怎么关灯使得我们的电量消耗最少。

解题思路：

首先，我们发现小明关灯肯定是关掉一个区间的灯，毕竟不可能小明路过一个灯不去关它，这是毫无益处的，所以这里我们考虑转换为区间DP，所以可以有状态 [l][r]，其中l，r分别表示所在的路灯的编号，这个状态表示在[l][r]区间中的最少耗电量。为了能够转移出去，我们还需要考虑两种情况，小明站在l点或者小明站在r点，这时候就能得到我们的转移方程：

memo[l][r][1]=min(memo[l][r-1][0]+calc(),memo[l][r-1][1]+calc())

memo[l][r][0]=min(memo[l+1][r][0]+calc(),memo[l+1][r][1]+calc())

其中calc表示中间走过程的损耗。损耗等于时间乘以功率，时间相当于距离这个好算，功率的话利用前缀和可以O（1）算区间功率和，这个也没什么好说的。

在这里有一个问题是，边界在哪：

我们知道在做记忆化DP时，传入的参数有：ll,rr，其中ll，rr分别表示当前访问区间。

我们知道ll必须要小于等于c，所以当ll走到c的时候memo[l][r][0]即为一个无效的状态，可以设为INF

我们知道rr必须要大于等于c，所以当rr走到c的时候memo[l][r][1]即为一个无效的状态，可以设为INF

废话：这里我们再次看到了转为区间DP，可见这种做法非常重要！可以多往区间这里靠！其它的可能可以转化为区间覆盖问题啊等等！总之区间有很多有意思的问题！

另外这里也让我们看到了DP转移中的边界条件！

最后，我们需要注意为什么这里我们设了一些状态为INF，因为我们认为从这些状态转移开来是不合理的。这种设置状态的思想要学会！

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
int p[MAXN], l[MAXN], r[MAXN];
pair<int, int> memo[MAXN][MAXN];
#define OPEN 0
int c;
const int INF = 1e9 + 10;
int calc(int pl, int pr, int la, int ra) {
  return (p[pr] - p[pl])*(l[la + 1] + r[ra + 1]);
}

pair<int, int> dfs(int ll, int rr) {

  if (memo[ll][rr].first != -1) {
    assert(memo[ll][rr].second != -1);
    return memo[ll][rr];
  }
  
  int fir, sec;
  if(rr!=c)
  sec = min(dfs(ll, rr - 1).second + calc(rr - 1, rr, ll - 1, rr), dfs(ll, rr - 1).first + calc(ll, rr, ll - 1, rr));
  else sec=INF;
  
  if(ll!=c)
  fir = min(dfs(ll + 1, rr).first + calc(ll, ll + 1, ll, rr + 1), dfs(ll + 1, rr).second + calc(ll, rr, ll, rr + 1));
  else fir=INF;
  memo[ll][rr].first = fir;
  memo[ll][rr].second = sec;
  return memo[ll][rr];

}
int main() {
#if OPEN
  freopen("in.txt", "r", stdin);
#endif
  int n;cin >> n >> c;
  int power[MAXN];
  int minpos = INF;
  int maxpos = -INF;
  c -= 1;
  for (int i = 0;i<n;i++) {
    cin >> p[i] >> power[i];
    minpos = min(minpos, p[i]);
    maxpos = max(maxpos, p[i]);
  }
  if (n == 1) {
    cout << 0 << endl;
    return 0;
  }
  memset(l, 0, sizeof(l));
  memset(r, 0, sizeof(r));

  for (int i = 0;i<MAXN;i++)
    for (int j = 0;j<MAXN;j++)
      memo[i][j].first = memo[i][j].second = -1;

  int sum = 0;

  for (int i = 0;i<n;i++) {
    sum += power[i];
    l[i + 1] = sum;
  }
  sum = 0;
  for (int i = 0;i<n;i++) {
    sum += power[n - 1 - i];
    r[n + 1 - 1 - i] = sum;
  }
  if (p[c]>minpos) {
    memo[c - 1][c].first = (p[c] - p[c - 1])*(l[c + 1 - 1] + r[c + 1 + 1]);
    memo[c - 1][c].second = INF;
  }
  if (p[c]<maxpos) {
    memo[c][c + 1].second = (p[c + 1] - p[c])*(r[c + 1 + 1] + l[c + 1 - 1]);
    memo[c][c + 1].first = INF;
  }
  int ans = min(dfs(0, n - 1).first, dfs(0, n - 1).second);
  cout << ans << endl;
  return 0;
}