#include <bits/stdc++.h>
const size_t maxN = 100005;
int N, W, Q, A[maxN];
int Lg[maxN], STmin[17][maxN], STmax[17][maxN];
inline int getMin(int l, int r) {
  int d = Lg[r - l + 1];
  return std::min(STmin[d][l], STmin[d][r - (1 << d) + 1]);
}
inline int getMax(int l, int r) {
  int d = Lg[r - l + 1];
  return std::max(STmax[d][l], STmax[d][r - (1 << d) + 1]);
}
struct node {
  int size;
  node *ch[2], *fa;
  node() : size(1), fa(nullptr) { ch[0] = ch[1] = nullptr; }
  inline void pushup() {
    size = (ch[0] ? ch[0]->size : 0) + (ch[1] ? ch[1]->size : 0) + 1;
  }
  inline bool isroot() {
    return !fa || (fa->ch[0] != this && fa->ch[1] != this);
  }
} nodeBuf[maxN];
inline void rotate(node *u) {
  node *o = u->fa;
  int d = o->ch[1] == u;
  u->fa = o->fa;
  if (!o->isroot()) u->fa->ch[o->fa->ch[1] == o] = u;
  o->ch[d] = u->ch[d ^ 1];
  if (o->ch[d]) o->ch[d]->fa = o;
  u->ch[d ^ 1] = o;
  o->fa = u;
  o->pushup(), u->pushup();
}
void splay(node *o) {
  while (!o->isroot()) {
    node *f = o->fa;
    if (!f->isroot()) f->fa->ch[1] == f ^ f->ch[1] == o ? rotate(o) : rotate(f);
    rotate(o);
  }
}
void access(node *o) {
  node *t = nullptr;
  while (o) {
    splay(o);
    o->ch[1] = t;
    o->pushup();
    t = o;
    o = o->fa;
  }
}
inline void link(node *u, node *v) { access(u), splay(u), u->fa = v; }
inline void cut(node *u) {
  access(u), splay(u), u->ch[0]->fa = nullptr, u->ch[0] = nullptr;
  u->pushup();
}
node *find_root(node *u, int &size) {
  access(u), splay(u);
  size += u->ch[0] ? u->ch[0]->size : 0;
  while (u->ch[0]) u = u->ch[0];
  splay(u);
  return u;
}
struct query_t {
  int k, i;
  inline bool operator<(const query_t &other) const { return k < other.k; }
} B[maxN];
int S, Next[maxN], Ans[maxN];
std::vector<int> Pos[maxN];
int main() {
  scanf("%d%d%d", &N, &W, &Q);
  S = std::sqrt(N);
  Lg[0] = -1;
  for (int i = 1; i <= N; ++i) {
    scanf("%d", A + i);
    STmin[0][i] = A[i];
    STmax[0][i] = A[i];
    Lg[i] = Lg[i / 2] + 1;
  }
  for (int i = 1, k; i <= Q; ++i) {
    scanf("%d", &k);
    B[i] = (query_t){W - k, i};
  }
  for (int i = 1; i <= Lg[N]; ++i)
    for (int j = 1; j + (1 << i) - 1 <= N; ++j) {
      STmin[i][j] = std::min(STmin[i - 1][j], STmin[i - 1][j + (1 << i - 1)]);
      STmax[i][j] = std::max(STmax[i - 1][j], STmax[i - 1][j + (1 << i - 1)]);
    }
  std::sort(B + 1, B + 1 + Q);
  for (int i = 1; i <= N; ++i) Next[i] = i, Pos[1].push_back(i);
  for (int i = 1; i <= Q; ++i) {
    for (auto pos : Pos[i]) {
      if (Next[pos] != pos) cut((nodeBuf + pos));
      int &next = Next[pos];
      for (; next <= N && next <= pos + S &&
             getMax(pos, next) - getMin(pos, next) <= B[i].k;
           ++next)
        ;
      if (next > pos + S || next > N) continue;
      link((nodeBuf + pos), (nodeBuf + next));
      Pos[std::lower_bound(
              B + 1, B + 1 + Q,
              (query_t){getMax(pos, next) - getMin(pos, next), 0}) -
          B]
          .push_back(pos);
    }
    std::vector<int>().swap(Pos[i]);
    int &ans = Ans[B[i].i];
    int cur = 1;
    while (cur != N + 1) {
      cur = find_root((nodeBuf + cur), ans) - nodeBuf;
      int l = cur, r = N;
      while (l <= r) {
        int m = l + r >> 1;
        if (getMax(cur, m) - getMin(cur, m) <= B[i].k)
          l = m + 1;
        else
          r = m - 1;
      }
      cur = l, ++ans;
    }
  }
  for (int i = 1; i <= Q; ++i) printf("%d\n", Ans[i] - 1);
  return 0;
}
