Submission #1437034

---

Source Code Expand

#include <bits/stdc++.h>

using namespace std;

typedef long long int64;

const int64 INF = 1LL << 58;

template< typename T >
struct SegmentTree
{
  const T INF;

  vector< T > seg;
  int sz;

  SegmentTree(int n) : INF(numeric_limits< T >::max() / 10)
  {
    sz = 1;
    while(sz < n) sz <<= 1;
    seg.assign(2 * sz - 1, INF);
  }

  T merge(T a, T b)
  {
    return (min(a, b));
  }

  void set(int k, int x)
  {
    seg[k + sz - 1] = x;
  }

  void build()
  {
    for(int k = sz - 2; k >= 0; k--) {
      seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);
    }
  }

  T rmq(int a, int b, int k, int l, int r)
  {
    if(a >= r || b <= l) return (INF);
    if(a <= l && r <= b) return (seg[k]);
    return (merge(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),
                  rmq(a, b, 2 * k + 2, (l + r) >> 1, r)));
  }

  T rmq(int a, int b)
  {
    return (rmq(a, b, 0, 0, sz));
  }

  void update(int k, T x)
  {
    k += sz - 1;
    seg[k] = x;
    while(k > 0) {
      k = (k - 1) >> 1;
      seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);
    }
  }
};


int main()
{
  int64 N, T, E, X[100002];

  cin >> N >> T >> E;
  for(int i = 1; i <= N; i++) cin >> X[i];

  /*
  int64 dp[2002][2002]; // curr, pending
  fill_n(*dp, 2002 * 2002, INF);
  dp[1][0] = 0;
  dp[1][1] = E;

  auto chmin = [](int64 &a, int64 b)
  {
    a = min(a, b);
  };

  for(int i = 2; i <= N; i++) {
    for(int j = 0; j < i; j++) {
      chmin(dp[i][j], dp[i - 1][j]);
      chmin(dp[i][i], dp[i - 1][j] + max(E, (X[i] - X[j + 1]) * 2));
    }
  }
  // dp[j]+(X[i]-X[j+1])*2 = dp[j]-X[j+1]*2+X[i]*2
  // dp2[j]=dp[j]-X[j+1]*2
  */


  SegmentTree< int64 > dp1(N + 1), dp2(N + 1);

  dp1.update(0, 0);
  dp1.update(1, E);
  dp2.update(0, dp1.rmq(0, 1) - X[1] * 2);
  dp2.update(1, dp1.rmq(1, 2) - X[2] * 2);
  int tail = 0;

  for(int i = 2; i <= N; i++) {
    int low = 0, high = i - 1;
    while((X[i] - X[tail + 1]) * 2 > E) ++tail;
    dp1.update(i, min(dp1.rmq(tail, i) + E, X[i] * 2 + dp2.rmq(0, tail)));
    dp2.update(i, dp1.rmq(i, i + 1) - X[i + 1] * 2);
  }
  cout << dp1.rmq(N, N + 1) + T << endl;
}

Submission Info

Judge Result