这个题有点牛了。

朴素 dp 就是关路灯，设 $f_{l,r,0/1}$ 表示考虑了 $[l,r]$，当前在 $l/r$ 的答案，直接转移做到 $\mathcal{O(k(n-k))}$。但是完全没有前途。

考虑我们走的路径大概长这个样子：

发现我们在决策的是拐弯的位置，于是尝试把贡献摊到拐弯上。具体地，每个点有一个初始的到达时刻 $|a_i-a_m|$。假设我们是从左侧的 $l$ 走到了右侧的 $r$，那么 $l$ 左侧的所有位置的到达时刻都会被延迟 $2(r-l)$ 秒。从 $r$ 到 $l$ 同理。

于是假设左侧到达 $l$ 的答案为 $f_l$，右侧到达 $r$ 的答案为 $f_r$，我们有转移：

转移成环了，但问题不大。我们模拟 dijkstra 的过程，发现：因为转移的一端固定时，转移的权值是随着转移到的那一端的远离而增大的。这就意味着，任意时刻，算出最短路的点集形成一段区间。

因此以 $[m,m]$ 为起始状态，每次选左右端点 dp 值较小的一个转移即可。转移形如：插入一条直线，查询一个点的最小值。因为直线斜率递减，查询的点递增，可以直接用单调队列维护凸包。时间复杂度 $\mathcal{O}(n)$。

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int MAXN = 3e5 + 10;

struct func {
	ll k, b;
	func(ll k = 0, ll b = 0) : k(k), b(b) {}
	ll operator () (ll x) { return k * x + b; }
};

inline 
bool check1(func i, func j, func k) {
	return (__int128)(k.b - i.b) * (i.k - j.k) <= (__int128)(j.b - i.b) * (i.k - k.k);
}

inline 
bool check2(func i, func j, ll k) {
	return j.b - i.b <= k * (i.k - j.k);
}

struct slopes {
	
	deque<func> q;
	
	inline 
	void insert(ll k, ll b) {
		func t(k, b);
		for (; q.size() > 1 && check1(q.end()[-2], q.end()[-1], t); q.pop_back());
		q.emplace_back(t);
	}
	
	inline 
	ll ask(ll x) {
		for (; q.size() > 1 && check2(q[0], q[1], x); q.pop_front());
		return q[0](x);
	}
	
} sf, sg;

int n, m; ll a[MAXN], f[MAXN], g[MAXN];

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 2; i <= n; i++) scanf("%d", &a[i]), a[i] += a[i - 1];
	sf.insert((m - 1) * 2, -a[m] * (m - 1) * 2);
	sg.insert((n - m) * 2, a[m] * (n - m) * 2);
	for (int l = m, r = m; l > 1 || r < n; ) {
		ll x = 9e18, y = 9e18;
		if (l > 1) x = sg.ask(-a[l - 1]);
		if (r < n) y = sf.ask(a[r + 1]);
		if (x < y) f[--l] = x, sf.insert((l - 1) * 2, x - a[l] * (l - 1) * 2);
		else g[++r] = y, sg.insert((n - r) * 2, y + a[r] * (n - r) * 2);
	}
	ll ans = min(f[1], g[n]);
	for (int i = 1; i <= n; i++) ans += abs(a[m] - a[i]);
	printf("%lld", ans);
}