#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
    "sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
                     "no-stack-protector")
using namespace std;
int A, B;
int n, w, q, a[100015], nxt[100015], jump[100015], cnt[100015], Max[100015],
    Min[100015], res[100015];
pair<int, int> ask[100015];
priority_queue<pair<int, int> > Q;
namespace RMQ {
int Max[100015][21], Min[100015][21], Log[100015];
void init() {
  for (int i = (1); i <= (n); i++) Max[i][0] = Min[i][0] = a[i];
  for (int i = (2); i <= (n); i++) Log[i] = Log[i >> 1] + 1;
  for (int j = (1); j <= (19); j++)
    for (int i = (1); i <= (n); i++)
      if (i + (1 << j) - 1 <= n) {
        Max[i][j] = max(Max[i][j - 1], Max[i + (1 << (j - 1))][j - 1]);
        Min[i][j] = min(Min[i][j - 1], Min[i + (1 << (j - 1))][j - 1]);
      }
}
int qmax(int l, int r) {
  int K = Log[r - l + 1];
  return max(Max[l][K], Max[r - (1 << K) + 1][K]);
}
int qmin(int l, int r) {
  int K = Log[r - l + 1];
  return min(Min[l][K], Min[r - (1 << K) + 1][K]);
}
}  // namespace RMQ
int dif(int l, int r) { return RMQ::qmax(l, r) - RMQ::qmin(l, r); }
void fix(int x, int lim) {
  while (nxt[x] <= n && nxt[x] <= x + B && Max[x] - Min[x] <= lim) {
    nxt[x]++;
    if (nxt[x] <= n) {
      Max[x] = max(Max[x], a[nxt[x]]);
      Min[x] = min(Min[x], a[nxt[x]]);
    }
  }
}
int vis[100015], last[100015];
void modify(int x, int lim) {
  vector<int> stk;
  fix(x, lim);
  if (nxt[x] <= n && nxt[x] <= x + A) {
    Q.push(make_pair(Min[x] - Max[x], x));
  }
  jump[x] = x;
  cnt[x] = 0;
  stk.push_back(x);
  while (nxt[jump[x]] <= x + A && jump[x] <= n) {
    fix(jump[x], lim);
    jump[x] = nxt[jump[x]];
    stk.push_back(jump[x]);
    cnt[x]++;
  }
  last[x] = ((int)stk.size());
  vis[x] = 1;
  for (int i = (x - 1); i >= (max(1, x - A)); i--) {
    fix(i, lim);
    if (nxt[i] <= n && vis[nxt[i]]) {
      while (stk.back() > i + A) stk.pop_back();
      jump[i] = stk.back();
      cnt[i] = cnt[nxt[i]] + 1 + ((int)stk.size()) - last[nxt[i]];
      last[i] = ((int)stk.size());
      vis[i] = 1;
    }
  }
  for (int i = (x); i >= (max(1, x - A)); i--) vis[i] = 0;
}
int query(int lim) {
  while (!Q.empty() && -Q.top().first <= lim) {
    int tmp = Q.top().second;
    Q.pop();
    modify(tmp, lim);
  }
  int x = 1, ans = 0;
  while (x <= n) {
    fix(x, lim);
    if (nxt[x] <= x + A) {
      ans += cnt[x];
      x = jump[x];
    } else {
      ans++;
      if (nxt[x] <= x + B) {
        x = nxt[x];
      } else {
        int l = x, r = n, ljump = 0;
        while (l <= r) {
          int mid = (l + r) >> 1;
          if (dif(x, mid) <= lim)
            ljump = mid, l = mid + 1;
          else
            r = mid - 1;
        }
        assert(ljump != 0);
        x = ljump + 1;
      }
    }
  }
  return ans - 1;
}
int main() {
  scanf("%d%d%d", &n, &w, &q);
  A = (int)pow(n, 1.0 / 3);
  B = (int)pow(n, 2.0 / 3);
  for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
  RMQ::init();
  for (int i = (1); i <= (q); i++) {
    scanf("%d", &ask[i].first);
    ask[i].first = w - ask[i].first;
    ask[i].second = i;
  }
  for (int i = (1); i <= (n); i++) {
    nxt[i] = i + 1;
    if (nxt[i] <= n) {
      Max[i] = max(a[i], a[i + 1]);
      Min[i] = min(a[i], a[i + 1]);
      Q.push(make_pair(Min[i] - Max[i], i));
    }
    jump[i] = min(i + A, n + 1);
    cnt[i] = jump[i] - i;
  }
  sort(ask + 1, ask + q + 1);
  for (int i = (1); i <= (q); i++) {
    res[ask[i].second] = query(ask[i].first);
  }
  for (int i = (1); i <= (q); i++) printf("%d\n", res[i]);
  return 0;
}
