#include <bits/stdc++.h>
template <typename T>
inline T read() {
  T x = 0;
  char ch = getchar();
  bool f = 0;
  while (!std::isdigit(ch)) f = (ch == '-'), ch = getchar();
  while (std::isdigit(ch)) x = x * 10 + (ch - '0'), ch = getchar();
  return f ? -x : x;
}
template <typename T>
void print(T x) {
  if (x < 0) {
    x = -x;
    putchar('-');
  }
  if (x < 10) {
    putchar(x + 48);
    return;
  }
  print<T>(x / 10);
  putchar(x % 10 + 48);
  return;
}
const int N = 1e5 * 1.1, B = sqrt(N);
int n, w, a[N], stmx[18][N], stmn[18][N], k[N], lst[N], res[N], g[N];
std::vector<int> v[N];
std::pair<int, int> p[N];
int query(int x, int y) {
  int qs = g[y - x + 1];
  return std::max(stmx[qs][x], stmx[qs][y - (1 << qs) + 1]) -
         std::min(stmn[qs][x], stmn[qs][y - (1 << qs) + 1]);
}
struct Node {
  int fa, son[2], sz;
} QS[N];
void up(int k) { QS[k].sz = QS[QS[k].son[0]].sz + QS[QS[k].son[1]].sz + 1; }
bool no_root(int k) {
  return QS[QS[k].fa].son[0] == k || QS[QS[k].fa].son[1] == k;
}
void rotate(int k) {
  int p = QS[k].fa, gp = QS[p].fa, isl = QS[p].son[1] == k;
  if (no_root(p)) QS[gp].son[QS[gp].son[1] == p] = k;
  if (QS[k].son[isl ^ 1]) QS[QS[k].son[isl ^ 1]].fa = p;
  QS[p].fa = k;
  QS[k].fa = gp;
  QS[p].son[isl] = QS[k].son[isl ^ 1];
  QS[k].son[isl ^ 1] = p;
  up(p);
}
int s[N], top;
void splay(int k) {
  while (no_root(k)) {
    int p = QS[k].fa;
    if (no_root(p))
      rotate((QS[p].son[1] == k) == (QS[QS[p].fa].son[1] == p) ? p : k);
    rotate(k);
  }
  return up(k);
}
void access(int x) {
  for (int y = 0; x; x = QS[y = x].fa) {
    splay(x);
    QS[x].son[1] = y;
    up(x);
  }
}
void link(int x, int y) {
  splay(x);
  QS[x].fa = y;
}
void cut(int x, int y) {
  access(x);
  splay(y);
  QS[x].fa = QS[y].son[1] = 0;
  up(y);
}
int find_root(int x) {
  access(x);
  splay(x);
  while (QS[x].son[0]) x = QS[x].son[0];
  splay(x);
  return x;
}
int main() {
  n = read<int>();
  w = read<int>();
  int q = read<int>();
  for (int i = 1; i <= n; ++i) stmx[0][i] = stmn[0][i] = a[i] = read<int>();
  for (int i = 2; i <= n; ++i) g[i] = g[i / 2] + 1;
  for (int i = 1; i <= 16; ++i) {
    int len = 1 << i;
    for (int j = 1; j <= n - len + 1; ++j) {
      stmx[i][j] = std::max(stmx[i - 1][j], stmx[i - 1][j + len / 2]);
      stmn[i][j] = std::min(stmn[i - 1][j], stmn[i - 1][j + len / 2]);
    }
  }
  for (int i = 1; i <= q; ++i) p[i] = std::make_pair(k[i] = w - read<int>(), i);
  std::sort(p + 1, p + 1 + q);
  std::sort(k + 1, k + 1 + q);
  for (int i = 1; i <= n; ++i) {
    v[1].push_back(i);
    link(i, lst[i] = i + 1);
    QS[i].sz = 1;
  }
  QS[n + 1].sz = 1;
  for (int i = 1; i <= q; ++i) {
    for (int j = 0; j < (int)v[i].size(); ++j) {
      cut(v[i][j], lst[v[i][j]]);
      int &ans = lst[v[i][j]];
      while (ans <= n && query(v[i][j], ans) <= k[i] && ans - v[i][j] <= B)
        ++ans;
      if (ans == n + 1)
        link(v[i][j], n + 1);
      else if (ans - v[i][j] <= B) {
        link(v[i][j], ans);
        int pos =
            std::lower_bound(k + i + 1, k + q + 1, query(v[i][j], ans)) - k;
        if (pos != q + 1) v[pos].push_back(v[i][j]);
      }
    }
    int tot = 0, nw = 1;
    while (nw != n + 1) {
      access(nw);
      splay(nw);
      tot += QS[nw].sz - 1;
      nw = find_root(nw);
      if (nw == n + 1) break;
      tot++;
      int L = nw + 1, R = n, nxt = n + 1;
      while (L <= R) {
        int mid(L + R >> 1);
        if (query(nw, mid) > k[i]) {
          nxt = mid;
          R = mid - 1;
        } else
          L = mid + 1;
      }
      nw = nxt;
    }
    res[p[i].second] = tot - 1;
  }
  for (int i = 1; i <= q; ++i) {
    print<int>(res[i]);
    putchar('\n');
  }
  return 0;
}
