#include <bits/stdc++.h>
using namespace std;
int S, L, N;
int Array[100005];
int DP[100005];
const int INF = 2000000005;
int Min[4 * 100005], Max[4 * 100005];
int D[4 * 100005];
void Read() {
  cin >> N >> S >> L;
  for (int i = 1; i <= N; i++) cin >> Array[i];
}
void Update(int K, int L, int R, int poz, int val) {
  if (L > R || L > poz || R < poz) return;
  if (L == R) {
    Min[K] = val;
    Max[K] = val;
    return;
  }
  if (poz > (L + R) / 2)
    Update(K * 2 + 1, (L + R) / 2 + 1, R, poz, val);
  else
    Update(K * 2, L, (L + R) / 2, poz, val);
  Min[K] = min(Min[2 * K], Min[2 * K + 1]);
  Max[K] = max(Max[2 * K], Max[2 * K + 1]);
}
void Update2(int K, int L, int R, int poz, int val) {
  if (L > R || L > poz || R < poz) return;
  if (L == R) {
    D[K] = val;
    return;
  }
  if (poz > (L + R) / 2)
    Update2(K * 2 + 1, (L + R) / 2 + 1, R, poz, val);
  else
    Update2(K * 2, L, (L + R) / 2, poz, val);
  D[K] = min(D[2 * K], D[2 * K + 1]);
}
int Query2(int K, int L, int R, int x, int y) {
  if (L > R || L > y || R < x) return INF;
  if (L >= x && R <= y) return D[K];
  int a = Query2(K * 2, L, (L + R) / 2, x, y);
  int b = Query2(K * 2 + 1, (L + R) / 2 + 1, R, x, y);
  return min(a, b);
}
pair<int, int> Query(int K, int L, int R, int x, int y) {
  if (L > R || L > y || R < x) return make_pair(INF, -INF);
  if (L >= x && R <= y) return make_pair(Min[K], Max[K]);
  pair<int, int> a = Query(K * 2, L, (L + R) / 2, x, y);
  pair<int, int> b = Query(K * 2 + 1, (L + R) / 2 + 1, R, x, y);
  return make_pair(min(a.first, b.first), max(a.second, b.second));
}
int binarySearch(int poz) {
  int left = 1, right = poz, mid, sol = poz + 1;
  while (left <= right) {
    mid = (left + right) / 2;
    pair<int, int> x = Query(1, 1, N, mid, poz);
    if (x.second - x.first <= S && x.first != INF && x.second != -INF) {
      sol = mid;
      right = mid - 1;
    } else
      left = mid + 1;
  }
  return sol;
}
void Solve(int poz) {
  int i = poz;
  Update(1, 1, N, poz, Array[poz]);
  int p = binarySearch(poz);
  DP[i] = INF;
  if (p == 0 || i - p + 1 < L) return;
  DP[i] = Query2(1, 1, N, max(p - 1, 0), i - L) + 1;
  if (p == 1) DP[i] = min(DP[i], 1);
  DP[i] = min(DP[i], INF);
  Update2(1, 1, N, poz, DP[poz]);
}
int main() {
  Read();
  for (int i = 1; i <= 4 * N; i++) {
    Min[i] = D[i] = INF;
  }
  for (int i = 1; i <= N; i++) Solve(i);
  if (DP[N] >= INF) DP[N] = -1;
  cout << DP[N] << "\n";
  return 0;
}
