#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
  if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
  if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const int MAXMEM = 200 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void *operator new(size_t _x) {
  _ptr += _x;
  return _memory + _ptr - _x;
}
void operator delete(void *) noexcept {}
const string FILENAME = "input";
const int MAXN = 100228;
const int BLOCK = 30;
const int BLOCK1 = 1300;
int n, w, q;
int x[MAXN];
int ans[MAXN];
int mx[18][MAXN];
int mx1[18][MAXN];
int gr[MAXN];
inline int getmax(const int l, const int r) {
  int grs = 31 - __builtin_clz(r - l + 1);
  return max(mx1[grs][l], mx1[grs][r - (1 << grs) + 1]);
}
inline int getmin(const int l, const int r) {
  int grs = 31 - __builtin_clz(r - l + 1);
  return min(mx[grs][l], mx[grs][r - (1 << grs) + 1]);
}
inline bool check(const int l, const int r, int k) {
  if (l > r || r >= n) {
    return false;
  }
  int f = getmin(l, r);
  int f1 = getmax(l, r);
  return f + w - f1 >= k;
}
inline int findGroupEnd(const int i, const int k) {
  int l = i;
  int r = n - 1;
  while (l < r) {
    int mid = (l + r + 1) >> 1;
    if (check(i, mid, k)) {
      l = mid;
    } else {
      r = mid - 1;
    }
  }
  return l + 1;
}
int curs[MAXN];
int jump[MAXN];
int target[MAXN];
int val;
void calc(int i) {
  if (curs[i] == BLOCK) {
    jump[i] = 0;
    target[i] = i;
  } else {
    if (i + curs[i] >= n) {
      jump[i] = 1;
      target[i] = i + curs[i];
    } else {
      if (target[curs[i] + i] >= i + BLOCK) {
        int t = i + curs[i];
        int cnt = 1;
        while (curs[t] + t < i + BLOCK) {
          cnt++;
          t += curs[t];
        }
        target[i] = t + curs[t];
        jump[i] = cnt + 1;
      } else {
        jump[i] = 1 + jump[curs[i] + i];
        target[i] = target[curs[i] + i];
      }
    }
  }
}
void calc1(int i) {
  if (curs[i] == BLOCK) {
    jump[i] = 0;
    target[i] = i;
  } else {
    if (i + curs[i] >= n) {
      jump[i] = 1;
      target[i] = i + curs[i];
    }
  }
}
int gt[MAXN];
int ls[MAXN];
int ft[MAXN];
int ukr;
int nxt[MAXN];
bool used[MAXN];
int st[MAXN];
int uks;
int grs;
int stacker[MAXN];
int ukt = 0;
int curuk[MAXN];
int curval[MAXN];
void dfs(int start) {
  ukt = 0;
  stacker[ukt] = start;
  curuk[start] = gt[start];
  ukt++;
  uks = 0;
  curval[start] = 0;
  while (ukt) {
    int u = stacker[ukt - 1];
    if (curuk[u] == gt[u]) {
      used[u] = true;
      if (u <= grs) {
        if (target[curs[u] + u] >= u + BLOCK) {
          while (curval[u] < uks && st[curval[u]] >= u + BLOCK) {
            curval[u]++;
          }
          int l = curval[u];
          jump[u] = uks - l;
          if (curs[st[l]] == BLOCK) {
            target[u] = st[l];
          } else {
            jump[u]++;
            target[u] = st[l] + curs[st[l]];
          }
        } else {
          jump[u] = 1 + jump[curs[u] + u];
          target[u] = target[curs[u] + u];
        }
      }
      st[uks] = u;
      uks++;
    }
    if (curuk[u] == -1) {
      uks--;
      ukt--;
      continue;
    }
    int h = ft[curuk[u]];
    curuk[u] = nxt[curuk[u]];
    if (!used[h]) {
      stacker[ukt] = h;
      curval[h] = curval[u];
      curuk[h] = gt[h];
      ukt++;
    }
  }
}
void add(int a, int b) {
  if (gt[a] == -1) {
    gt[a] = ukr;
    ls[a] = ukr;
    ft[ukr] = b;
    nxt[ukr] = -1;
    ukr++;
  } else {
    nxt[ls[a]] = ukr;
    ft[ukr] = b;
    nxt[ukr] = -1;
    ls[a] = ukr;
    ukr++;
  }
}
void update(int i) {
  for (int j = i; j >= max(0, i - BLOCK - 1); j--) {
    calc(j);
  }
}
bool bad[MAXN];
int curs2[MAXN];
inline bool comp(const pair<int, pair<int, int> > &a,
                 const pair<int, pair<int, int> > &b) {
  return a.first < b.first;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> w >> q;
  for (int i = 0; i < n; i++) {
    cin >> x[i];
    mx[0][i] = x[i];
    mx1[0][i] = x[i];
  }
  for (int k = 1; k < 18; k++) {
    for (int i = 0; i < n; i++) {
      int t = min(i + (1 << (k - 1)), n - 1);
      mx[k][i] = min(mx[k - 1][i], mx[k - 1][t]);
      mx1[k][i] = max(mx1[k - 1][i], mx1[k - 1][t]);
    }
  }
  int cur = 1;
  int step = 0;
  for (int i = 1; i <= n; i++) {
    if (cur + cur <= i) {
      cur += cur;
      step++;
    }
    gr[i] = step;
  }
  vector<pair<int, int> > st;
  for (int it = 0; it < q; it++) {
    int k;
    cin >> k;
    st.push_back({k, it});
  }
  sort((st).begin(), (st).end());
  vector<pair<int, pair<int, int> > > g;
  vector<pair<int, int> > g1;
  for (int i = 0; i < n; i++) {
    for (int j = 1; j <= BLOCK; j++) {
      int maxk = 0;
      if (i + j - 1 >= n) {
        maxk = 0;
      } else {
        int s = getmin(i, i + j - 1);
        int s1 = getmax(i, i + j - 1);
        maxk = max(0, s + w - s1);
      }
      g.push_back({maxk + 1, {i, j - 1}});
      if (maxk) {
        chkmax(curs[i], j);
      }
    }
    if (i + BLOCK1 <= n) {
      int s = getmin(i, i + BLOCK1 - 1);
      int s1 = getmax(i, i + BLOCK1 - 1);
      if (max(0, s + w - s1) != 0) {
        g1.push_back({max(0, s + w - s1) + 1, i});
        bad[i] = true;
      }
    }
    curs2[i] = findGroupEnd(i, 1) - i;
  }
  sort((g).begin(), (g).end(), comp);
  sort((g1).begin(), (g1).end());
  val = 1;
  int uk = 0;
  for (int i = n - 1; i >= 0; i--) {
    calc(i);
  }
  int uk1 = 0;
  for (int it = 0; it < q; it++) {
    val = st[it].first;
    while (uk < (int)(g).size() && g[uk].first <= val) {
      int gh = curs[g[uk].second.first];
      chkmin(curs[g[uk].second.first], g[uk].second.second);
      if (curs[g[uk].second.first] != gh) {
        update(g[uk].second.first);
      }
      uk++;
    }
    while (uk1 < (int)(g1).size() && g1[uk1].first <= val) {
      bad[g1[uk1].second] = false;
      curs2[g1[uk1].second] = BLOCK1 - 1;
      uk1++;
    }
    int cur = 0;
    int cnt = 0;
    while (cur < n) {
      if (curs[cur] == BLOCK) {
        if (bad[cur]) {
          cnt++;
          cur = findGroupEnd(cur, val);
        } else {
          while (!check(cur, cur + curs2[cur] - 1, val)) {
            curs2[cur]--;
          }
          cnt++;
          int val = curs2[cur];
          cur += val;
        }
      } else {
        cnt += jump[cur];
        cur = target[cur];
      }
    }
    ans[st[it].second] = cnt - 1;
  }
  for (int it = 0; it < q; it++) {
    cout << ans[it] << '\n';
  }
  return 0;
}
