#include <bits/stdc++.h>
using namespace std;
vector<int> cache;
vector<int> cacheRange;
int findMin(int f, int t) {
  int ret = 1000000000;
  while (true) {
    if (f % 316 == 0 && f + 316 <= t + 1) {
      assert(f / 316 < (int)cacheRange.size());
      ret = ret < cacheRange[f / 316] ? ret : cacheRange[f / 316];
      f += 316;
      continue;
    }
    if (f + 1 <= t + 1) {
      assert(f < (int)cache.size());
      ret = ret < cache[f] ? ret : cache[f];
      f++;
      continue;
    }
    break;
  }
  return ret;
}
int n, s, l;
vector<int> data;
vector<int> maxData;
vector<int> minData;
int go(int start) {
  int end = start;
  assert(start < (int)data.size());
  int maxEl = data[start];
  int minEl = data[start];
  while (true) {
    if ((end + 1) % 316 == 0 && end + 316 < (int)data.size()) {
      int ind = (end + 1) / 316;
      assert(ind < (int)maxData.size() && ind < (int)minData.size());
      int candMax = maxEl > maxData[ind] ? maxEl : maxData[ind];
      int candMin = minEl < minData[ind] ? minEl : minData[ind];
      if (candMax - candMin <= s) {
        maxEl = candMax;
        minEl = candMin;
        end += 316;
        continue;
      }
    }
    if (end + 1 < (int)data.size()) {
      assert(end + 1 < (int)data.size());
      int candMax = maxEl > data[end + 1] ? maxEl : data[end + 1];
      int candMin = minEl < data[end + 1] ? minEl : data[end + 1];
      if (candMax - candMin <= s) {
        maxEl = candMax;
        minEl = candMin;
        end += 1;
        continue;
      }
    }
    break;
  }
  assert(start < (int)cache.size() && start / 316 < (int)cacheRange.size());
  int ret = 1000000000;
  if (start + l <= (int)data.size() && (int)data.size() <= end + 1) {
    ret = 1;
    cache[start] = 1;
    cacheRange[start / 316] = 1;
  } else {
    ret = 1 + findMin(start + l, end + 1 < (int)data.size() - 1
                                     ? end + 1
                                     : (int)data.size() - 1);
    assert(start < (int)cache.size() && start / 316 < (int)cacheRange.size());
    cache[start] = ret < cache[start] ? ret : cache[start];
    cacheRange[start / 316] =
        ret < cacheRange[start / 316] ? ret : cacheRange[start / 316];
  }
  return ret;
}
int main() {
  scanf("%d", &n);
  scanf("%d", &s);
  scanf("%d", &l);
  data.resize(n, 0);
  maxData.resize((n + 316 - 1) / 316, -1000000000);
  minData.resize((n + 316 - 1) / 316, 1000000000);
  cache.resize(n, 1000000000);
  cacheRange.resize((n + 316 - 1) / 316, 1000000000);
  for (int i = 0; i < n; i++) {
    scanf("%d", &data[i]);
    int ind = i / 316;
    assert(ind < (int)maxData.size() && ind < (int)minData.size());
    maxData[ind] = maxData[ind] > data[i] ? maxData[ind] : data[i];
    minData[ind] = minData[ind] < data[i] ? minData[ind] : data[i];
  }
  for (int i = n - 1; i >= 0; i--) go(i);
  if (cache[0] >= 1000000000) {
    printf("-1\n");
  } else {
    printf("%d\n", cache[0]);
  }
  return 0;
}
