#include <bits/stdc++.h>
using namespace std;
int read() {
  int X = 0;
  char ch = 0;
  while (ch < 48 || ch > 57) ch = getchar();
  while (ch >= 48 && ch <= 57) X = X * 10 + (ch ^ 48), ch = getchar();
  return X;
}
struct LCT {
  struct Node {
    int l, r, f, c;
  } a[101000];
  void Init(int n) {
    for (int i = 1; i <= n; i++) a[i].c = 1;
  }
  inline bool nrt(int u) { return a[a[u].f].l == u || a[a[u].f].r == u; }
  inline void up(int u) { a[u].c = a[a[u].l].c + a[a[u].r].c + 1; }
  void rot(int u) {
    int fa = a[u].f, gf = a[fa].f;
    if (a[gf].l == fa) a[gf].l = u;
    if (a[gf].r == fa) a[gf].r = u;
    a[a[fa].f = u].f = gf;
    if (a[fa].l == u) {
      a[a[fa].l = a[u].r].f = fa;
      a[u].r = fa;
    } else {
      a[a[fa].r = a[u].l].f = fa;
      a[u].l = fa;
    }
    up(fa);
    up(u);
  }
  void splay(int u) {
    while (nrt(u)) {
      int fa = a[u].f, gf = a[fa].f;
      if (nrt(fa) && (a[fa].l == u) == (a[gf].l == fa)) rot(fa);
      rot(u);
    }
  }
  void access(int u) {
    int sav = u;
    for (int v = 0; u; u = a[v = u].f) {
      splay(u);
      a[u].r = v;
      up(u);
    }
    splay(sav);
  }
  int findrt(int u) {
    access(u);
    while (a[u].l) u = a[u].l;
    splay(u);
    return u;
  }
  void link(int u, int v) {
    access(u);
    a[u].f = v;
  }
  void cut(int u, int v) {
    access(u);
    splay(v);
    a[u].f = a[v].r = 0;
    up(v);
  }
} T;
const int INF = 2100000000;
int x[101000];
struct ST {
  int t0[20][101000], t1[20][101000], lg2[101000];
  void Init(int n, int *x) {
    for (int i = 2; i <= n; i++) lg2[i] = lg2[i >> 1] + 1;
    reverse(lg2 + 1, lg2 + n + 1);
    for (int i = 1; i <= n; i++) t0[0][i] = t1[0][i] = x[i];
    for (int j = 0; (1 << j + 1) <= n; j++)
      for (int i = 1; i + (1 << j + 1) - 1 <= n; i++) {
        t0[j + 1][i] = min(t0[j][i], t0[j][i + (1 << j)]);
        t1[j + 1][i] = max(t1[j][i], t1[j][i + (1 << j)]);
      }
  }
  int qry(int u, int lim, int &l, int &r) {
    l = INF;
    r = 0;
    for (int k = lg2[u]; ~k; k--)
      if (k <= lg2[u] && max(r, t1[k][u]) - min(l, t0[k][u]) <= lim) {
        r = max(r, t1[k][u]);
        l = min(l, t0[k][u]);
        u += (1 << k);
      }
    return u;
  }
  int qry2(int u, int lim) {
    int l, r;
    return qry(u, lim, l, r);
  }
} S;
struct Qry {
  int l, p;
} sq[101000];
bool cmpQ(const Qry &A, const Qry &B) { return A.l < B.l; }
vector<int> tb[101000];
int n, BS, q, t[101000];
void upd(int u, int lim) {
  if (t[u]) T.cut(u, t[u]);
  int l, r, sav = S.qry(u, lim, l, r);
  t[u] = sav;
  if (t[u] - u <= BS) {
    T.link(u, t[u]);
    if (t[u] <= n) {
      int nxt = max(r, x[t[u]]) - min(l, x[t[u]]),
          tim = lower_bound(sq + 1, sq + q + 1, (Qry){nxt, 0}, cmpQ) - sq;
      if (tim <= q) tb[tim].push_back(u);
    }
  }
}
int solve(int i, vector<int> &b) {
  int lim = sq[i].l;
  for (int i = 0; i < b.size(); i++) upd(b[i], lim);
  b.clear();
  int ret = 0;
  for (int p = 1; p <= n;) {
    int rt = T.findrt(p);
    ret += T.a[rt].c - 1;
    if (rt > n) break;
    p = S.qry2(rt, lim);
    ret++;
  }
  return ret;
}
int w, ans[101000];
int main() {
  n = read();
  w = read();
  q = read();
  while (BS * BS < n) BS++;
  for (int i = 1; i <= n; i++) x[i] = read();
  x[n + 1] = INF;
  S.Init(n + 1, x);
  for (int i = 1; i <= q; i++) {
    sq[i].l = w - read();
    sq[i].p = i;
  }
  sort(sq + 1, sq + q + 1, cmpQ);
  T.Init(n + 1);
  for (int i = 1; i <= n; i++) tb[1].push_back(i);
  for (int i = 1; i <= q; i++) ans[sq[i].p] = solve(i, tb[i]);
  for (int i = 1; i <= q; i++) printf("%d\n", ans[i] - 1);
  return 0;
}
