#include <iostream>

using namespace std;

int arr[100005];
int plusSeq=0;
int minusSeq=0;;
int answ[100006];
int main(){
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++){
        answ[i]=0;
        cin >> arr[i];
    }
    answ[n]=arr[n];
    if(i%2==1)
    plusSeq=arr[n];
    else plusSeq=arr[n]*-1;
    for(int i = n-1;  i>= 1; i--){
        if(i%2==1){
            answ[i]=arr[i]-plusSeq;
            plusSeq+=answ[i];
        }else{
            answ[i]=arr[i]+plusSeq;
            plusSeq-=answ[i];
        }
    }

    for(int i = 1; i<=n; i++){
        cout << answ[i] << " ";
    }

    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n;
    cin>>n;
    int a[n];
    int b[n];
    for(int i=1;i<=n;i++)
    cin>>a[i];
    for(int i=1;i<n;i++)
    b[i]=a[i]+a[i+1];
    b[n]=a[n];
    for(int i=1;i<=n;i++)
    cout<<b[i]<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n;
    cin>>n;
    int a[n];
    for(int i=1;i<=n;i++)
    cin>>a[i];
    for(int i=1;i<n;i++)
    b[i]=a[i]+a[i+1];
    b[n]=a[n];
    for(int i=1;i<=n;i++)
    cout<<b[i];
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n;
    cin>>n;
    int a[n],b[n];
    for(int i=1;i<=n;i++)
    cin>>a[i];
    for(int i=1;i<n;i++)
    b[i]=a[i]+a[i+1];
    b[n]=a[n];
    for(int i=1;i<=n;i++)
    cout<<b[i]<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n;
    cin>>n;
    int a[n];
    int b[n];
    for(int i=1;i<=n;i++)
    cin>>a[i];
    for(int i=1;i<n;i++)
    b[i]=a[i]+a[i+1];
    b[n]=a[n];
    for(int i=1;i<=n;i++)
    cout<<b[i];
    return 0;
}


#include<iostream>
#include<set>
using namespace std;
main()
{
	int n,i;
	cin>>n;
	long long a[n+1];
	for(i=0;i<n;++i)cin>>a[i];
	for(i=0;i<n;++i)cout<<a[i]+a[i+1]<<" ";
}


#include<iostream>
#include<set>
using namespace std;
long long a[100000];
main()
{
	int n,i;
	cin>>n;
	for(i=0;i<n;++i)cin>>a[i];
	for(i=0;i<n;++i)cout<<a[i]+a[i+1]<<" ";
}


#include<iostream>
#include<set>
using namespace std;
main()
{
	int n,i;
	long long a[n+1];
	for(i=0;i<n;++i)cin>>a[i];
	for(i=0;i<n;++i)cout<<a[i]+a[i+1]<<" ";
}


#include <cstdio>
#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

bool scan();
void print();
int getB(int);
vector<int> solve();

fstream fs;
int N;
vector<int> A;
vector<int> B;

const int NOT_VALUE = 2147483647;

int main()
{
	//fs.open("A.in",fstream::in);

	while(scan())
		print();

	//fs.close();

	return 0;
}

vector<int> solve()
{
	vector<int> sol(N);

	for(int i=0;i!=N;++i)
		sol[i] = getB(i);

	return sol;

}

void print()
{
	vector<int> sol = solve();

	for(int i=0;i!=N;++i)
	{
		if(i == 0)
		{
			printf("%d",sol[i]);

		}
		else
		{
			printf(" %d",sol[i]);
		}
	}

	puts("");

}

bool scan()
{
	//if(fs>>N)
	if(cin>>N)
	{
		A = vector<int>(N);
		B = vector<int>(N,NOT_VALUE);

		for(int i=0;i!=N;++i)
		{
			//fs>>A[i];
			cin>>A[i];
		}

		return true;
	}
	else
	{
		return false;

	}

}

int getB(int n)
{
	int t = 0;

	if(B[n] == NOT_VALUE)
	{
		for(int i=0;i+n<N;++i)
		{
			if(i == 0)
			{
				t += A[n+i];
			}
			else if(i%2 > 0)
			{
				t += getB(n+i);
			}
			else
			{
				t -= getB(n+i);
			}

		}

		return B[n] = t;
	}
	else
		return B[n];

}


#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
#define int long long

int n, d, b;
int a[N], A[N];

bool check(int x) {
	int mid = n / 2 + (n % 2);
	int lef = mid;
	int rig = n - mid;
	for (int i = 1; i <= n; ++i) A[i] = a[i];

	vector < pair<int, int> > buf; // (time, id)
	for (int i = mid; i >= mid - (lef - x) + 1; --i) {
		buf.push_back(make_pair(i, i));
	}
	for (int i = mid + 1; i <= mid + (rig - x); ++i) {
		buf.push_back(make_pair(n - i + 1, i));
	}

	// solve
	set < pair<int, int> > s;
	for (int i = 1; i <= n; ++i) if (A[i] > 0) s.insert(make_pair(i, A[i]));

	for (auto &e : buf) {
		int t = e.first; // time
		int pos = e.second; // pos
		// [pos - t * d ... pos + t * d]
		s.erase(make_pair(pos, A[pos]));

		while (A[pos] < b) {
			int where = (int)(max(1LL, pos - 1LL * t * d));
			set < pair<int, int> > :: iterator it = s.lower_bound(make_pair(where, 0));
			if (it == s.end()) return false;
			if (it -> first > pos + 1LL * t * d) return false;

			int tpos = it -> first;
			int take = min(b - A[pos], A[tpos]);
			//cerr << "tpos = " << tpos << endl;
			//cerr << "take = " << take << endl;
			A[pos] += take;
			A[tpos] -= take;

			s.erase(it);
			if (A[tpos]) {
				s.insert(make_pair(tpos, A[tpos]));
			}
		}

		if (A[pos] > b) {
			A[pos] -= b;
			s.insert(make_pair(pos, A[pos]));
		}
	}

	return true;
}

signed main() {
	ios_base::sync_with_stdio(false); cin.tie(0);
	cin >> n >> d >> b;
	for (int i = 1; i <= n; ++i) cin >> a[i];

	int low = 0, high = n / 2 + 1;
	while (low < high) {
		int mid = ((low + high) >> 1);
		if (check(mid)) high = mid;
		else low = mid + 1;
	}

	cout << low << endl;
}


/*input
50 1 1
2 0 0 0 2 4 1 0 1 2 2 1 0 0 1 2 0 0 1 2 0 0 0 1 1 0 0 2 1 1 2 0 4 2 0 0 2 2 1 1 1 4 0 0 0 2 0 0 1 1
*/
#include <bits/stdc++.h>
using namespace std;

const int N = 100005;

int n, d, b;
int a[N];

bool check(int x) {
	int mid = n / 2 + (n % 2);
	int lef = mid;
	int rig = n - mid;

	vector < pair<int, int> > buf; // (time, id)
	for (int i = mid - (lef - x) + 1; i <= mid; ++i) {
		buf.push_back(make_pair(i, i));
	}
	for (int i = mid + 1; i <= mid + (rig - x); ++i) {
		buf.push_back(make_pair(n - i + 1, i));
	}

	// solve
	set < pair<int, int> > s;
	for (int i = 1; i <= n; ++i) if (a[i] > 0) s.insert(make_pair(i, a[i]));

	for (auto &e : buf) {
		int t = e.first; // time
		int pos = e.second; // pos
		// [pos - t * d ... pos + t * d]

		int need = b;
		while (need > 0) {
			int where = (int)(max(1LL, pos - 1LL * t * d));
			set < pair<int, int> > :: iterator it = s.lower_bound(make_pair(where, 0));
			if (it == s.end())
				return false;
			if (it -> first > pos + 1LL * t * d) return false;

			int tpos = it -> first;
			int have = it -> second;
			int take = min(need, have);

			need -= take;
			have -= take;

			s.erase(it);
			if (have) {
				s.insert(make_pair(tpos, have));
			}
		}
	}

	return true;
}

signed main() {
	ios_base::sync_with_stdio(false); cin.tie(0);
	cin >> n >> d >> b;
	for (int i = 1; i <= n; ++i) cin >> a[i];

	int low = 0, high = n / 2 + 1;
	while (low < high) {
		int mid = ((low + high) >> 1);
		if (check(mid)) high = mid;
		else low = mid + 1;
	}

	cout << low << endl;
}


/*input
100 2 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 3 1 2 8 5 1 9 1 2 12 7 5 0 7 2 11 3 17

*/
#include <bits/stdc++.h>
using namespace std;
#define sp ' '
#define endl '\n'
#define fi first
#define se second
#define mp make_pair
#define int long long
#define N 100005
#define bit(x,y) ((x>>y)&1LL)

int n, d, b;
int a[N];
bool dead[N];
deque<pair<int, int> > dq;
deque<pair<int, int> > debt;

void solveDebt() {
	while (!dq.empty() && !debt.empty()) {
		auto money = dq.front(); auto amo = debt.front(); dq.pop_front(); debt.pop_front();
		if (abs(money.fi - amo.fi) > d * min(amo.fi, n - amo.fi + 1)) {
			debt.push_front(amo);
			continue;
		}
		int pay = min(money.se, amo.se);
		money.se -= pay; amo.se -= pay;
		if (money.se) dq.push_front(money);
		if (amo.se) debt.push_front(amo);
	}
}

bool check(int range) {
	dq.clear(); debt.clear();
	memset(dead, 0, sizeof(dead));
	for (int i = 1; i <= range; i++) dead[i] = true;
	for (int i = n - range + 1; i <= n; i++) dead[i] = true;
	for (int i = 1; i <= n; i++) {
		if (a[i])
			dq.push_back(mp(i, a[i]));
		if (dead[i]) continue;
		debt.push_back(mp(i, b));
		solveDebt();
	}
	solveDebt();
	if (!debt.empty()) return false;
	return true;
}

signed main() {
	ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	cin >> n >> d >> b;
	for (int i = 1; i <= n; i++) cin >> a[i];
	int l = 0, r = (n + 1) / 2;
	while (l != r) {
		int mid = (l + r) / 2;
		if (check(mid)) r = mid;
		else l = mid + 1;
	}
	cout << l << endl;
}


/*input
5 1 1
1 0 0 0 4

*/
#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
#define int long long

int n, d, b;
int a[N], A[N];

bool check(int x) {
	int mid = n / 2 + (n % 2);
	int lef = mid;
	int rig = n - mid;
	for (int i = 1; i <= n; ++i) A[i] = a[i];

	vector < pair<int, int> > buf; // (time, id)
	for (int i = mid - (lef - x) + 1; i <= mid; ++i) {
		buf.push_back(make_pair(i, i));
	}
	for (int i = mid + 1; i <= mid + (rig - x); ++i) {
		buf.push_back(make_pair(n - i + 1, i));
	}

	// solve
	set < pair<int, int> > s;
	for (int i = 1; i <= n; ++i) if (A[i] > 0) s.insert(make_pair(i, A[i]));

	for (auto &e : buf) {
		int t = e.first; // time
		int pos = e.second; // pos
		// [pos - t * d ... pos + t * d]
		s.erase(make_pair(pos, A[pos]));

		while (A[pos] < b) {
			int where = (int)(max(1LL, pos - 1LL * t * d));
			set < pair<int, int> > :: iterator it = s.lower_bound(make_pair(where, 0));
			if (it == s.end()) return false;
			if (it -> first > pos + 1LL * t * d) return false;

			int tpos = it -> first;
			int take = min(b - A[pos], A[tpos]);
			//cerr << "tpos = " << tpos << endl;
			//cerr << "take = " << take << endl;
			A[pos] += take;
			A[tpos] -= take;

			s.erase(it);
			if (A[tpos]) {
				s.insert(make_pair(tpos, A[tpos]));
			}
		}

		if (A[pos] > b) {
			A[pos] -= b;
			s.insert(make_pair(pos, A[pos]));
		}
	}

	return true;
}

signed main() {
	ios_base::sync_with_stdio(false); cin.tie(0);
	cin >> n >> d >> b;
	for (int i = 1; i <= n; ++i) cin >> a[i];

	int low = 0, high = n / 2 + 1;
	while (low < high) {
		int mid = ((low + high) >> 1);
		if (check(mid)) high = mid;
		else low = mid + 1;
	}

	cout << low << endl;
}


// writer: w33z8kqrqk8zzzx33
#include <bits/stdc++.h>
using namespace std;

// begin fast read template by CYJian (source: https://www.luogu.com.cn/paste/i11c3ppx)

namespace io {
	const int __SIZE = (1 << 21) + 1;
	char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1, __c, qu[55]; int __f, qr, _eof;
	#define Gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, __SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
	inline void flush () { fwrite (obuf, 1, oS - obuf, stdout), oS = obuf; }
	inline void gc (char &x) { x = Gc(); }
	inline void pc (char x) { *oS ++ = x; if (oS == oT) flush (); }
	inline void pstr (const char *s) { int __len = strlen(s); for (__f = 0; __f < __len; ++__f) pc (s[__f]); }
	inline void gstr (char *s) { for(__c = Gc(); __c < 32 || __c > 126 || __c == ' ';)  __c = Gc();
		for(; __c > 31 && __c < 127 && __c != ' '; ++s, __c = Gc()) *s = __c; *s = 0; }
	template <class I> inline bool gi (I &x) { _eof = 0;
		for (__f = 1, __c = Gc(); (__c < '0' || __c > '9') && !_eof; __c = Gc()) { if (__c == '-') __f = -1; _eof |= __c == EOF; }
		for (x = 0; __c <= '9' && __c >= '0' && !_eof; __c = Gc()) x = x * 10 + (__c & 15), _eof |= __c == EOF; x *= __f; return !_eof; }
	template <class I> inline void print (I x) { if (!x) pc ('0'); if (x < 0) pc ('-'), x = -x;
		while (x) qu[++ qr] = x % 10 + '0',  x /= 10; while (qr) pc (qu[qr --]); }
	struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
} using io::pc; using io::gc; using io::pstr; using io::gstr; using io::gi; using io::print;

// end fast read template by CYJian

#define iter(i, a, b) for(int i=(a); i<(b); i++)
#define rep(i, a) iter(i, 0, a)
#define rep1(i, a) iter(i, 1, (a)+1)
#define log(a) cerr<<"\033[32m[DEBUG] "<<#a<<'='<<(a)<<" @ line "<<__LINE__<<"\033[0m"<<endl
#define all(a) a.begin(), a.end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair

using ll=long long;
using pii=pair<int, int>;
//#define int ll
const int MOD = 1000000007;

int ar[100005];

signed main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    ll n, d, b; gi(n), gi(d), gi(b);
	rep1(i, n) gi(ar[i]), ar[i] += ar[i-1];
	ll m = (n+1)/2, c1 = 0, c2 = 0;
	for(int i=1; i<=m; i++) c1 += (ar[min(n,i+i*d)]-c1*b>=b);
	for(int i=n; i>m; i--) c2 += (ar[max(1ll,n+1-i-i*d)]-c2*b>=b);
	print(max(m-c1,n-m-c2));
}


// writer: w33z8kqrqk8zzzx33
#include <bits/stdc++.h>
using namespace std;

// begin fast read template by CYJian (source: https://www.luogu.com.cn/paste/i11c3ppx)

namespace io {
	const int __SIZE = (1 << 21) + 1;
	char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1, __c, qu[55]; int __f, qr, _eof;
	#define Gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, __SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
	inline void flush () { fwrite (obuf, 1, oS - obuf, stdout), oS = obuf; }
	inline void gc (char &x) { x = Gc(); }
	inline void pc (char x) { *oS ++ = x; if (oS == oT) flush (); }
	inline void pstr (const char *s) { int __len = strlen(s); for (__f = 0; __f < __len; ++__f) pc (s[__f]); }
	inline void gstr (char *s) { for(__c = Gc(); __c < 32 || __c > 126 || __c == ' ';)  __c = Gc();
		for(; __c > 31 && __c < 127 && __c != ' '; ++s, __c = Gc()) *s = __c; *s = 0; }
	template <class I> inline bool gi (I &x) { _eof = 0;
		for (__f = 1, __c = Gc(); (__c < '0' || __c > '9') && !_eof; __c = Gc()) { if (__c == '-') __f = -1; _eof |= __c == EOF; }
		for (x = 0; __c <= '9' && __c >= '0' && !_eof; __c = Gc()) x = x * 10 + (__c & 15), _eof |= __c == EOF; x *= __f; return !_eof; }
	template <class I> inline void print (I x) { if (!x) pc ('0'); if (x < 0) pc ('-'), x = -x;
		while (x) qu[++ qr] = x % 10 + '0',  x /= 10; while (qr) pc (qu[qr --]); }
	struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
} using io::pc; using io::gc; using io::pstr; using io::gstr; using io::gi; using io::print;

// end fast read template by CYJian

#define iter(i, a, b) for(int i=(a); i<(b); i++)
#define rep(i, a) iter(i, 0, a)
#define rep1(i, a) iter(i, 1, (a)+1)
#define log(a) cerr<<"\033[32m[DEBUG] "<<#a<<'='<<(a)<<" @ line "<<__LINE__<<"\033[0m"<<endl
#define all(a) a.begin(), a.end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair

using ll=long long;
using pii=pair<int, int>;
//#define int ll
const int MOD = 1000000007;

int ar[100005];

signed main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    ll n, d, b; gi(n), gi(d), gi(b);
	rep1(i, n) gi(ar[i]), ar[i] += ar[i-1];
	ll m = (n+1)/2, c1 = 0, c2 = 0;
	for(int i=1; i<=m; i++) c1 += (ar[min(n,i*(d+1))]-c1*b>=b);
	for(int i=n; i>m; i--) c2 += (n*b-ar[max(0ll,n-(n+1-i)*(d+1))]-c2*b>=b);
	print(max(m-c1,n-m-c2));
}


//
// Created by 佐竹俊哉 on 2019/11/11.
//

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }

template<class T, class U> void chmin(T& t, const U& u) { if (t > u) t = u; }
template<class T, class U> void chmax(T& t, const U& u) { if (t < u) t = u; }

template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os<<"("<<p.first<<","<<p.second<<")";
    return os;
}

template<class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    os<<"{";
    rep(i, v.size()) {
        if (i) os<<",";
        os<<v[i];
    }
    os<<"}";
    return os;
}

int main() {
    int n;
    ll d, b;
    cin >> n >> d >> b;
    V<ll> a(n);
    rep(i, n) cin >> a[i];
    int lo = 0, hi = n * b + 1;
    int ans = n;

    while (hi - lo > 1) {
        ll m = (lo + hi) / 2;
        int ansl = 0, ansr = 0;

        {
            V<ll> vec = a;
            V<ll> ps(n + 1);
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            int nl = (n + 1) / 2;
            ll rem = 0;
            rep(i, nl) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansl++;
                    }
                }
            }
        }

        {
            V<ll> vec = a;
            reverse(ALL(vec));
            ll mm = n * b - m;
            int nr = n / 2;

            V<ll> ps(n + 1);
            rep(i, n) ps[i + 1] = ps[i] + vec[i];
            ll cs = 0;
            rep(i, n) {
                ll zan = min(mm - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            ll rem = 0;
            rep(i, nr) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansr++;
                    }
                }
            }
            chmin(ans, max(ansl, ansr));
            if (ansl >= ansr) {
                lo = m;
            } else {
                hi = m;
            }
        }
    }
    cout << ans << endl;

    return 0;
}


//
// Created by 佐竹俊哉 on 2019/11/11.
//

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i, n) rep2(i,0,n)
#define rep2(i, m, n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl

constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }

template<class T, class U>
void chmin(T &t, const U &u) { if (t > u) t = u; }

template<class T, class U>
void chmax(T &t, const U &u) { if (t < u) t = u; }

template<class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << "(" << p.first << "," << p.second << ")";
    return os;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    rep(i, v.size()) {
        if (i) os << ",";
        os << v[i];
    }
    os << "}";
    return os;
}

int main() {
    int n;
    ll d, b;
    cin >> n >> d >> b;
    V<ll> a(n);
    rep(i, n) cin >> a[i];
    int lo = 0, hi = n * b + 1;
    int ans = n;

    auto calc = [&](ll m) {
        int ansl = 0, ansr = 0;

        {
            V<ll> vec = a;
            V<ll> ps(n + 1);
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            int nl = (n + 1) / 2;
            ll rem = 0;
            rep(i, nl) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1) + 1, n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        rem -= b;
                    } else {
                        ansl++;
                    }
                }
            }
        }

        {
            V<ll> vec = a;
            reverse(ALL(vec));
            ll mm = n * b - m;
            int nr = n / 2;

            V<ll> ps(n + 1);
            rep(i, n) ps[i + 1] = ps[i] + vec[i];
            ll cs = 0;
            rep(i, n) {
                ll zan = min(mm - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            ll rem = 0;
            rep(i, nr) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1) + 1, n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        rem -= b;
                    } else {
                        ansr++;
                    }
                }
            }
        }
        return mp(ansl, ansr);
    };

    while (hi - lo > 1) {
        ll m = (lo + hi) / 2;
        auto res = calc(m);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
        if (ansl >= ansr) {
            lo = m;
        } else {
            hi = m;
        }
    }
    if (lo > 0) {
        auto res = calc(lo - 1);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    if (hi <= n * b) {
        auto res = calc(hi);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    cout << ans << endl;

    return 0;
}


//
// Created by 佐竹俊哉 on 2019/11/11.
//

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i, n) rep2(i,0,n)
#define rep2(i, m, n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl

constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }

template<class T, class U>
void chmin(T &t, const U &u) { if (t > u) t = u; }

template<class T, class U>
void chmax(T &t, const U &u) { if (t < u) t = u; }

template<class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << "(" << p.first << "," << p.second << ")";
    return os;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    rep(i, v.size()) {
        if (i) os << ",";
        os << v[i];
    }
    os << "}";
    return os;
}

int main() {
    int n;
    ll d, b;
    cin >> n >> d >> b;
    V<ll> a(n);
    rep(i, n) cin >> a[i];
    int lo = 0, hi = n * b + 1;
    int ans = n;

    auto calc = [&](ll m) {
        int ansl = 0, ansr = 0;

        {
            V<ll> vec = a;
            V<ll> ps(n + 1);
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            int nl = (n + 1) / 2;
            ll rem = 0;
            rep(i, nl) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansl++;
                    }
                }
            }
        }

        {
            V<ll> vec = a;
            reverse(ALL(vec));
            ll mm = n * b - m;
            int nr = n / 2;

            V<ll> ps(n + 1);
            rep(i, n) ps[i + 1] = ps[i] + vec[i];
            ll cs = 0;
            rep(i, n) {
                ll zan = min(mm - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            ll rem = 0;
            rep(i, nr) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansr++;
                    }
                }
            }
        }
        return mp(ansl, ansr);
    };

    while (hi - lo > 1) {
        ll m = (lo + hi) / 2;
        auto res = calc(m);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
        if (ansl >= ansr) {
            lo = m;
        } else {
            hi = m;
        }
    }
    if (lo > 0) {
        auto res = calc(lo - 1);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    if (hi <= n * b) {
        auto res = calc(hi);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    cout << ans << endl;

    return 0;
}


//
// Created by 佐竹俊哉 on 2019/11/11.
//

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }

template<class T, class U> void chmin(T& t, const U& u) { if (t > u) t = u; }
template<class T, class U> void chmax(T& t, const U& u) { if (t < u) t = u; }

template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os<<"("<<p.first<<","<<p.second<<")";
    return os;
}

template<class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    os<<"{";
    rep(i, v.size()) {
        if (i) os<<",";
        os<<v[i];
    }
    os<<"}";
    return os;
}

int main() {
    int n;
    ll d, b;
    cin >> n >> d >> b;
    V<ll> a(n);
    rep(i, n) cin >> a[i];
    int lo = 0, hi = n * b + 1;
    int ans = n;

    while (hi - lo > 1) {
        ll m = (lo + hi) / 2;
        int ansl = 0, ansr = 0;

        {
            V<ll> vec = a;
            V<ll> ps(n + 1);
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            int nl = (n + 1) / 2;
            ll rem = 0;
            rep(i, nl) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansl++;
                    }
                }
            }
        }

        {
            V<ll> vec = a;
            reverse(ALL(vec));
            ll mm = n * b - m;
            int nr = n / 2;

            V<ll> ps(n + 1);
            rep(i, n) ps[i + 1] = ps[i] + vec[i];
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            ll rem = 0;
            rep(i, nr) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1), n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansr++;
                    }
                }
            }
            chmin(ans, max(ansl, ansr));
            if (ansl >= ansr) {
                lo = m;
            } else {
                hi = m;
            }
        }
    }
    cout << ans << endl;

    return 0;
}


//
// Created by 佐竹俊哉 on 2019/11/11.
//

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i, n) rep2(i,0,n)
#define rep2(i, m, n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#define dump(x) cout << #x << " = " << (x) << endl

constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }

template<class T, class U>
void chmin(T &t, const U &u) { if (t > u) t = u; }

template<class T, class U>
void chmax(T &t, const U &u) { if (t < u) t = u; }

template<class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << "(" << p.first << "," << p.second << ")";
    return os;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    rep(i, v.size()) {
        if (i) os << ",";
        os << v[i];
    }
    os << "}";
    return os;
}

int main() {
    int n;
    ll d, b;
    cin >> n >> d >> b;
    V<ll> a(n);
    rep(i, n) cin >> a[i];
    int lo = 0, hi = n * b + 1;
    int ans = n;

    auto calc = [&](ll m) {
        int ansl = 0, ansr = 0;

        {
            V<ll> vec = a;
            V<ll> ps(n + 1);
            ll cs = 0;
            rep(i, n) {
                ll zan = min(m - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            int nl = (n + 1) / 2;
            ll rem = 0;
            rep(i, nl) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1) + 1, n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansl++;
                    }
                }
            }
        }

        {
            V<ll> vec = a;
            reverse(ALL(vec));
            ll mm = n * b - m;
            int nr = n / 2;

            V<ll> ps(n + 1);
            rep(i, n) ps[i + 1] = ps[i] + vec[i];
            ll cs = 0;
            rep(i, n) {
                ll zan = min(mm - cs, vec[i]);
                vec[i] = zan;
                ps[i + 1] = ps[i] + vec[i];
                cs += vec[i];
            }

            ll rem = 0;
            rep(i, nr) {
                ll cur = vec[i] + rem;
                if (cur >= b) {
                    rem = cur - b;
                } else {
                    ll r = min<ll>(i + d * (i + 1) + 1, n);
                    ll fr = ps[r] - ps[i];
                    cur = fr + rem;
                    rem += vec[i];
                    if (cur >= b) {
                        ll get = max(0ll, b - rem);
                        rem -= get + b;
                    } else {
                        ansr++;
                    }
                }
            }
        }
        return mp(ansl, ansr);
    };

    while (hi - lo > 1) {
        ll m = (lo + hi) / 2;
        auto res = calc(m);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
        if (ansl >= ansr) {
            lo = m;
        } else {
            hi = m;
        }
    }
    if (lo > 0) {
        auto res = calc(lo - 1);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    if (hi <= n * b) {
        auto res = calc(hi);
        int ansl = res.fi, ansr = res.se;
        chmin(ans, max(ansl, ansr));
    }
    cout << ans << endl;

    return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef vector<int> vi;

template<class T> inline T re(){
	T N = 0; char c = getchar(); bool neg = 0;
	for (; c < '0' || c > '9'; c = getchar()) neg |= c == '-';
	for (; c >= '0' && c <= '9'; c = getchar())
		N = (N<<3)+(N<<1) + c - '0';
	return neg ? -N : N;
}

const int MX = 1e5;
int n, d, b, a[MX + 5];
int cur[MX + 5];

bool can(int lim){
	memcpy(cur, a, (n + 1) * sizeof(int));
	int li = 1, ri = n;
	for (int i = 1, j = n; i <= j; i++, j--){
		if (i <= lim) continue;
		int rem = b;
		while (rem && li <= min(i * d + i, n)){
			int sub = min(rem, cur[li]);
			rem -= sub;
			cur[li] -= sub;
			if (cur[li] == 0) li++;
		}
			if (rem) return 0;
		if (i < j){ // run j
			rem = b;
			while (rem && ri >= max(1, n + 1 - i - i * d)){
				int sub = min(rem, cur[ri]);
				rem -= sub;
				cur[ri] -= sub;
				if (cur[ri] == 0) ri--;
			}
			if (rem) return 0;
		}
	}
	return 1;
}
int main(){
	n = re<int>(); d = re<int>(); b = re<int>();
	for (int i = 1; i <= n; i++) a[i] = re<int>();
	int lo = 0, hi = (n + 1) >> 1, md, ans = (n + 1) >> 1;
	for (md = (lo + hi) >> 1; lo <= hi; md = (lo + hi) >> 1) {
		if (can(md)) ans = md, hi = md - 1;
		else lo = md + 1;
	}
	printf("%lld\n", ans);
	return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef vector<int> vi;

template<class T> inline T re(){
	T N = 0; char c = getchar(); bool neg = 0;
	for (; c < '0' || c > '9'; c = getchar()) neg |= c == '-';
	for (; c >= '0' && c <= '9'; c = getchar())
		N = (N<<3)+(N<<1) + c - '0';
	return neg ? -N : N;
}

const int MX = 1e5;
int n, d, b, a[MX + 5];
int cur[MX + 5];

bool can(int lim){
	memcpy(cur, a, (n + 1) * sizeof(int));
	int li = 1, ri = n;
	for (int i = 1, j = n; i <= j; i++, j--){
		if (i <= lim) continue;
		int rem = b;
		while (rem && li <= min(1LL * i * d + i, 1LL * n)){
			int sub = min(rem, cur[li]);
			rem -= sub;
			cur[li] -= sub;
			if (cur[li] == 0) li++;
		}
			if (rem) return 0;
		if (i < j){ // run j
			rem = b;
			while (rem && ri >= max(1LL, 1LL * n + 1 - i - 1LL * i * d)){
				int sub = min(rem, cur[ri]);
				rem -= sub;
				cur[ri] -= sub;
				if (cur[ri] == 0) ri--;
			}
			if (rem) return 0;
		}
	}
	return 1;
}
int main(){
	n = re<int>(); d = re<int>(); b = re<int>();
	for (int i = 1; i <= n; i++) a[i] = re<int>();
	int lo = 0, hi = (n + 1) >> 1, md, ans = (n + 1) >> 1;
	for (md = (lo + hi) >> 1; lo <= hi; md = (lo + hi) >> 1) {
		if (can(md)) ans = md, hi = md - 1;
		else lo = md + 1;
	}
	printf("%d\n", ans);
	return 0;
}


#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef vector<int> vi;

template<class T> inline T re(){
	T N = 0; char c = getchar(); bool neg = 0;
	for (; c < '0' || c > '9'; c = getchar()) neg |= c == '-';
	for (; c >= '0' && c <= '9'; c = getchar())
		N = (N<<3)+(N<<1) + c - '0';
	return neg ? -N : N;
}

const int MX = 1e5;
int n, d, b, a[MX + 5];
int cur[MX + 5];

bool can(int lim){
	memcpy(cur, a, (n + 1) * sizeof(int));
	int li = 1, ri = n;
	for (int i = 1, j = n; i <= j; i++, j--){
		if (i <= lim) continue;
		int rem = b;
		while (rem && li <= min(i * d + i, n)){
			int sub = min(rem, cur[li]);
			rem -= sub;
			cur[li] -= sub;
			if (cur[li] == 0) li++;
		}
			if (rem) return 0;
		if (i < j){ // run j
			rem = b;
			while (rem && ri >= max(1, n + 1 - i - i * d)){
				int sub = min(rem, cur[ri]);
				rem -= sub;
				cur[ri] -= sub;
				if (cur[ri] == 0) ri--;
			}
			if (rem) return 0;
		}
	}
	return 1;
}
int main(){
	n = re<int>(); d = re<int>(); b = re<int>();
	for (int i = 1; i <= n; i++) a[i] = re<int>();
	int lo = 0, hi = (n + 1) >> 1, md, ans = (n + 1) >> 1;
	for (md = (lo + hi) >> 1; lo <= hi; md = (lo + hi) >> 1) {
		if (can(md)) ans = md, hi = md - 1;
		else lo = md + 1;
	}
	printf("%d\n", ans);
	return 0;
}


/** I can do this all day **/

#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;

typedef long long                   ll;
typedef long double                 ld;
typedef pair<int,int>               pii;
typedef pair<ll,ll>                 pll;
#define all(x)                      (x).begin(),(x).end()
#define F                           first
#define S                           second
#define Mp                          make_pair
#define fast_io                     ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io                     freopen("in.txt" , "r+" , stdin) ; freopen("out.txt" , "w+" , stdout);
#define endl                        "\n"

//void add(int I, int value){seg[I += MAXN] = value;for (I >>= 1; I; I >>= 1){seg[I] = __gcd(seg[I << 1], seg[I << 1 | 1]);}}

//int query(int l, int r){int ans = seg[l + MAXN];for (l += MAXN, r += MAXN + 1; l < r; l >>= 1, r >>= 1){if(l & 1) ans = __gcd(ans, seg[l ++]);if(r & 1) ans = __gcd(ans, seg[-- r]);}return ans;}

const int MAXN = 1e6 + 10;
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll INF = 8e18;
const int LOG = 22;

ll pw(ll a , ll b, ll mod)  { return (!b ? 1 : (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod : pw(a * a % mod, b / 2, mod))); }

ll ps[MAXN], v[MAXN], n, d, b;

bool check(ll x)
{
        if(x >= (n + 1) / 2)return 1;
        for(ll i = x + 1; i <= ((n + 1) / 2); i++)
        {
                int l = max(1ll, i - (i * d)), r = min(n, i + (i * d));
                ll sum = ps[r] - ps[l - 1];
                if(sum < (i - x) * b)
                {
                        return 0;
                }
        }
        for(ll i = n - x; i >= ((n + 1) / 2); i--)
        {
                int l = max(1ll, i - (n - i + 1) * d), r = min(n, i + (n + 1 - i) * d);
                ll sum = ps[r] - ps[l - 1];
                if(sum < (n - x + 1 - i) * b)
                {
                        return 0;
                }
        }
        return 1;
}

int main(){
    fast_io;
    //cout << fixed << setprecision(15);
    //scanf("%d %d %f %lld %s %c", &x);
    //printf("%d %d %f %lld %s %c", x);
    cin >> n >> d >> b;
    bool is_OK = 1;
    for(int i = 1; i <= n; i++)
    {
            cin >> v[i];
            if(v[i] != b)is_OK = 0;
            ps[i] = ps[i - 1] + v[i];
    }
    if(is_OK)return cout << 0, 0;
    int d = 0, up = n + 1;
    while(up - d > 1)
    {
            int mid = (up + d) / 2;
            if(check(mid))
            {
                    up = mid;
            }
            else
            {
                    d = mid;
            }
    }
    cout << up << endl;
    return 0;
}


/** I can do this all day **/

#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;

typedef long long                   ll;
typedef long double                 ld;
typedef pair<int,int>               pii;
typedef pair<ll,ll>                 pll;
#define all(x)                      (x).begin(),(x).end()
#define F                           first
#define S                           second
#define Mp                          make_pair
#define fast_io                     ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io                     freopen("in.txt" , "r+" , stdin) ; freopen("out.txt" , "w+" , stdout);
#define endl                        "\n"

//void add(int I, int value){seg[I += MAXN] = value;for (I >>= 1; I; I >>= 1){seg[I] = __gcd(seg[I << 1], seg[I << 1 | 1]);}}

//int query(int l, int r){int ans = seg[l + MAXN];for (l += MAXN, r += MAXN + 1; l < r; l >>= 1, r >>= 1){if(l & 1) ans = __gcd(ans, seg[l ++]);if(r & 1) ans = __gcd(ans, seg[-- r]);}return ans;}

const int MAXN = 1e6 + 10;
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll INF = 8e18;
const int LOG = 22;

ll pw(ll a , ll b, ll mod)  { return (!b ? 1 : (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod : pw(a * a % mod, b / 2, mod))); }

ll ps[MAXN], v[MAXN], n, d, b;

bool check(ll x)
{
        if(x >= (n + 1) / 2)return 1;
        for(ll i = x + 1; i <= ((n + 1) / 2); i++)
        {
                int l = max(1ll, i - (i * d)), r = min(n, i + (i * d));
                ll sum = ps[r] - ps[l - 1];
                if(sum < (i - x) * b)
                {
                        return 0;
                }
        }
        for(ll i = n - x; i >= ((n + 1) / 2); i--)
        {
                int l = max(1ll, i - (n - i + 1) * d), r = min(n, i + (n + 1 - i) * d);
                ll sum = ps[r] - ps[l - 1];
                if(sum < (n - x + 1 - i) * b)
                {
                        return 0;
                }
        }
        return 1;
}

int main(){
    fast_io;
    //cout << fixed << setprecision(15);
    //scanf("%d %d %f %lld %s %c", &x);
    //printf("%d %d %f %lld %s %c", x);
    cin >> n >> d >> b;
    bool is_OK = 1;
    for(int i = 1; i <= n; i++)
    {
            cin >> v[i];
            if(v[i] != b)is_OK = 0;
            ps[i] = ps[i - 1] + v[i];
    }
    if(is_OK)return cout << 0, 0;
    int d = -1, up = n + 1;
    while(up - d > 1)
    {
            int mid = (up + d) / 2;
            if(check(mid))
            {
                    up = mid;
            }
            else
            {
                    d = mid;
            }
    }
    cout << up << endl;
    return 0;
}


#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
typedef pair<int, bool> sP;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef vector<ll> vec;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-5;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;

void solve() {
	int n, d, b; cin >> n >> d >> b;
	vector<int > a(n);
	rep(i, n) {
		cin >> a[i];
	}
	vector<int> ra(n + 1);
	rep(i, n) {
		ra[i + 1] += ra[i] + a[i];
	}
	int hn = n / 2;
	int le = -1, ri = hn + 1;
	while (ri - le > 1) {
		int mid = (le + ri) / 2;
		bool valid = true;
		Rep(j, mid, hn) {
			int l = 0, r = min((ll)n, j + (ll)(j + 1)*d+1);
			ll sum = ra[r] - ra[l];
			//cout << mid << " " << j << " " << sum << endl;
			sum -= (j-mid)*b;
			//cout << mid << " "<<j<<" " << sum << endl;
			if (sum < b) {
				valid = false; break;
			}
		}
		Rep(j, mid, hn) {
			int rj = n - 1 - j;
			int l = max((ll)0, rj - (ll)(j + 1)*d);
			int r = n;
			ll sum = ra[r] - ra[l];
			sum -= (j-mid)*b;
			//cout << mid << " " << j << " " << sum << endl;
			if (sum < b) {
				valid = false; break;
			}
		}
		if (valid) {
			ri = mid;
		}
		else {
			le = mid;
		}
	}
	cout << ri << endl;
	//int ans = hn - ri;
	//cout << ans << endl;
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	//cout << fixed << setprecision(7);
	//init();
	solve();
	//stop
	return 0;
}


/* {{{ */ #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;

namespace utils{
constexpr bool use_stdio = false;
ostream* out = &cout;
FILE* stdio_out = stdout;
const bool __ = [](){ if constexpr(!use_stdio){ ios_base::sync_with_stdio(false); cin.tie(nullptr);
  cout << fixed; cout << setprecision(12); cerr << fixed; cerr << setprecision(12); } return true; }();
template<typename ...> using to_void = void;
template<typename T, typename = void> struct is_container : false_type {};
template<typename T> struct is_container<T, to_void<decltype(declval<T>().begin()), decltype(declval<T>().end())>> : true_type {};
template<typename V, typename N> struct resize { V& v; N& n; resize(V& vv, N& nn) : v(vv), n(nn) {} ~resize() { v.resize(n); } };

inline void rd(int& x) { if constexpr(use_stdio) scanf("%d", &x); else cin >> x; }
inline void rd(long long& x) { if constexpr(use_stdio) scanf("%lld", &x); else cin >> x; }
inline void rd(double& x) { if constexpr(use_stdio) scanf("%lf", &x); else cin >> x; }
inline void rd(long double& x) { if constexpr(use_stdio){ double y; scanf("%lf", &y); x=y; } else cin >> x; }
inline void rd(char& x) { if constexpr(use_stdio) scanf(" %c", &x); else cin >> x; }
inline void rd(char* x) { if constexpr(use_stdio) scanf("%s", x); else cin >> x; }
inline void rd(string& x) { if constexpr(use_stdio) assert(false); else cin >> x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void rd(T& x) { cin >> x; }
template<typename T> inline void rd(T* x);
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x);
template<typename... Ts> inline void rd(tuple<Ts...>& x);
template<typename V, typename N> inline void rd(const resize<V, N>& x);
template<typename T, typename U> inline void rd(pair<T, U>& x) { rd(x.first); rd(x.second); }
template<typename V, typename N> inline void rd(const resize<V, N>& x) { const_cast<V&>(x.v).resize(x.n); rd(x.v); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x) { for(auto& v : x) rd(v); }
template<typename T, typename U, typename... Ts> inline void rd(T&& t, U&& u, Ts&&... ts) {
  rd(forward<T>(t)); rd(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void rd(tuple<Ts...>& x) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_rd = [](auto&&... xs) { rd(xs...); }; apply(apply_rd, x); }
template<typename T> inline void rd(T* x) { rd(*x); }

inline void prt(const int& x) { if constexpr(use_stdio) fprintf(stdio_out, "%d", x); else *out << x; }
inline void prt(const long long& x) { if constexpr(use_stdio) fprintf(stdio_out, "%lld", x); else *out << x; }
inline void prt(const double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", x); else *out << x; }
inline void prt(const long double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", (double)x); else *out << x; }
inline void prt(const char& x) { if constexpr(use_stdio) fprintf(stdio_out, "%c", x); else *out << x; }
inline void prt(const char* x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x); else *out << x; }
inline void prt(const string &x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x.c_str()); else *out << x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void prt(const T& x) { *out << x; }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x);
template<typename... Ts> inline void prt(const tuple<Ts...>& x);
template<typename T, typename U> inline void prt(const pair<T, U>& x) { prt(x.first); prt(' '); prt(x.second); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x) {
  if (x.begin() != x.end()) { prt(*x.begin()); for(auto it = x.begin(); ++it != x.end(); ) { prt(' '); prt(*it); } } }
template<typename T, typename U, typename... Ts> inline void prt(T&& t, U&& u, Ts&&... ts) {
  prt(forward<T>(t)); prt(' '); prt(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void prt(const tuple<Ts...>& x ) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_prt = [](auto&&... xs) { prt(xs...); }; apply(apply_prt, x); }
inline void wt() { prt('\n'); }
template<typename... Ts> inline void wt(Ts&&... ts) { prt(forward<Ts>(ts)...); wt(); }

#ifdef MY_DEBUG_FLAG
inline void enter_db() { if constexpr(use_stdio) stdio_out = stderr; else out = &cerr; }
inline void leave_db() { if constexpr(use_stdio) stdio_out = stdout; else out = &cout; }
inline void db() { enter_db(); prt('\n'); leave_db(); }
template<typename... Ts> inline void db(Ts&&... ts) { enter_db(); prt(forward<Ts>(ts)...); wt(); leave_db(); }
#define db(...) utils::db("Debug(", #__VA_ARGS__, ") == (", __VA_ARGS__, ")")
#else
#define db(...)
#endif // define(MY_DEBUG_FLAG)
constexpr int slen(char*s){ return (int) strlen(s); }
void flush() { if constexpr(use_stdio) fflush(stdout); else cout << std::flush; }
} using utils::rd, utils::prt, utils::wt, utils::slen, utils::resize, utils::flush;

#define pb emplace_back
#define x first
#define y second
#define sz(a) ((int)(a).size())
#define rep(i,a,b) for(int i=(a); i<(b); i++)
#define dec(i,n,a) for(int i=(n); i>=(a); i--)
#define clr(a,v) memset(a, v, sizeof(a))
#define all(a) (a).begin(),(a).end() /* }}} */

constexpr int inf = 0x3f3f3f3f;
constexpr ld EPS = 1e-9;
constexpr int MAXN = 1e5 + 10;
constexpr int LOGN = 20;
constexpr int mod = 1000000007;

int n, d, b;
vi vet;

bool cant(int from, int to) {
  int nd = abs(from - to) / d;
  return nd > min(to, n-1-to);
}

bool ok(int k) {
  int ptr = 0;
  int q = 0;
  rep(i,0,n) {
    if (i < k || n-1-i < k) continue;
    int f = b;
    while (f > 0) {
      while(q == vet[ptr] || cant(ptr, i)) {
        ptr++;
        q = 0;
        if (ptr == n) return false;
      }
      int v = min(vet[ptr] - q, f);
      f -= v;
      q += v;
    }
  }
  return true;
}

int main() {
  rd(n, d, b, resize(vet, n));
  int l = 0, r = n / 2 - 1, ans = n / 2, md;
  while (l <= r) {
    md = (l + r) / 2;
    if (ok(md)) ans = md, r = md - 1;
    else l = md + 1;
  }
  wt(ans);
}


/* {{{ */ #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;

namespace utils{
constexpr bool use_stdio = false;
ostream* out = &cout;
FILE* stdio_out = stdout;
const bool __ = [](){ if constexpr(!use_stdio){ ios_base::sync_with_stdio(false); cin.tie(nullptr);
  cout << fixed; cout << setprecision(12); cerr << fixed; cerr << setprecision(12); } return true; }();
template<typename ...> using to_void = void;
template<typename T, typename = void> struct is_container : false_type {};
template<typename T> struct is_container<T, to_void<decltype(declval<T>().begin()), decltype(declval<T>().end())>> : true_type {};
template<typename V, typename N> struct resize { V& v; N& n; resize(V& vv, N& nn) : v(vv), n(nn) {} ~resize() { v.resize(n); } };

inline void rd(int& x) { if constexpr(use_stdio) scanf("%d", &x); else cin >> x; }
inline void rd(long long& x) { if constexpr(use_stdio) scanf("%lld", &x); else cin >> x; }
inline void rd(double& x) { if constexpr(use_stdio) scanf("%lf", &x); else cin >> x; }
inline void rd(long double& x) { if constexpr(use_stdio){ double y; scanf("%lf", &y); x=y; } else cin >> x; }
inline void rd(char& x) { if constexpr(use_stdio) scanf(" %c", &x); else cin >> x; }
inline void rd(char* x) { if constexpr(use_stdio) scanf("%s", x); else cin >> x; }
inline void rd(string& x) { if constexpr(use_stdio) assert(false); else cin >> x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void rd(T& x) { cin >> x; }
template<typename T> inline void rd(T* x);
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x);
template<typename... Ts> inline void rd(tuple<Ts...>& x);
template<typename V, typename N> inline void rd(const resize<V, N>& x);
template<typename T, typename U> inline void rd(pair<T, U>& x) { rd(x.first); rd(x.second); }
template<typename V, typename N> inline void rd(const resize<V, N>& x) { const_cast<V&>(x.v).resize(x.n); rd(x.v); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x) { for(auto& v : x) rd(v); }
template<typename T, typename U, typename... Ts> inline void rd(T&& t, U&& u, Ts&&... ts) {
  rd(forward<T>(t)); rd(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void rd(tuple<Ts...>& x) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_rd = [](auto&&... xs) { rd(xs...); }; apply(apply_rd, x); }
template<typename T> inline void rd(T* x) { rd(*x); }

inline void prt(const int& x) { if constexpr(use_stdio) fprintf(stdio_out, "%d", x); else *out << x; }
inline void prt(const long long& x) { if constexpr(use_stdio) fprintf(stdio_out, "%lld", x); else *out << x; }
inline void prt(const double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", x); else *out << x; }
inline void prt(const long double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", (double)x); else *out << x; }
inline void prt(const char& x) { if constexpr(use_stdio) fprintf(stdio_out, "%c", x); else *out << x; }
inline void prt(const char* x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x); else *out << x; }
inline void prt(const string &x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x.c_str()); else *out << x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void prt(const T& x) { *out << x; }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x);
template<typename... Ts> inline void prt(const tuple<Ts...>& x);
template<typename T, typename U> inline void prt(const pair<T, U>& x) { prt(x.first); prt(' '); prt(x.second); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x) {
  if (x.begin() != x.end()) { prt(*x.begin()); for(auto it = x.begin(); ++it != x.end(); ) { prt(' '); prt(*it); } } }
template<typename T, typename U, typename... Ts> inline void prt(T&& t, U&& u, Ts&&... ts) {
  prt(forward<T>(t)); prt(' '); prt(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void prt(const tuple<Ts...>& x ) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_prt = [](auto&&... xs) { prt(xs...); }; apply(apply_prt, x); }
inline void wt() { prt('\n'); }
template<typename... Ts> inline void wt(Ts&&... ts) { prt(forward<Ts>(ts)...); wt(); }

#ifdef MY_DEBUG_FLAG
inline void enter_db() { if constexpr(use_stdio) stdio_out = stderr; else out = &cerr; }
inline void leave_db() { if constexpr(use_stdio) stdio_out = stdout; else out = &cout; }
inline void db() { enter_db(); prt('\n'); leave_db(); }
template<typename... Ts> inline void db(Ts&&... ts) { enter_db(); prt(forward<Ts>(ts)...); wt(); leave_db(); }
#define db(...) utils::db("Debug(", #__VA_ARGS__, ") == (", __VA_ARGS__, ")")
#else
#define db(...)
#endif // define(MY_DEBUG_FLAG)
constexpr int slen(char*s){ return (int) strlen(s); }
void flush() { if constexpr(use_stdio) fflush(stdout); else cout << std::flush; }
} using utils::rd, utils::prt, utils::wt, utils::slen, utils::resize, utils::flush;

#define pb emplace_back
#define x first
#define y second
#define sz(a) ((int)(a).size())
#define rep(i,a,b) for(int i=(a); i<(b); i++)
#define dec(i,n,a) for(int i=(n); i>=(a); i--)
#define clr(a,v) memset(a, v, sizeof(a))
#define all(a) (a).begin(),(a).end() /* }}} */

constexpr int inf = 0x3f3f3f3f;
constexpr ld EPS = 1e-9;
constexpr int MAXN = 1e5 + 10;
constexpr int LOGN = 20;
constexpr int mod = 1000000007;

int n, d, b;
vi vet;

bool cant(int from, int to) {
  int nd = max(0, (abs(from - to) - 1) / d);
  return nd > min(to, n-1-to);
}

bool ok(int k) {
  int ptr = 0;
  int q = 0;
  rep(i,0,n) {
    if (i < k || n-1-i < k) continue;
    int f = b;
    while (f > 0) {
      while(q == vet[ptr] || cant(ptr, i)) {
        ptr++;
        q = 0;
        if (ptr == n) return false;
      }
      int v = min(vet[ptr] - q, f);
      f -= v;
      q += v;
    }
  }
  return true;
}

int main() {
  rd(n, d, b, resize(vet, n));
  int l = 0, r = n / 2 - 1, ans = n / 2, md;
  while (l <= r) {
    md = (l + r) / 2;
    if (ok(md)) ans = md, r = md - 1;
    else l = md + 1;
  }
  wt(ans);
}


/* {{{ */ #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;

namespace utils{
constexpr bool use_stdio = false;
ostream* out = &cout;
FILE* stdio_out = stdout;
const bool __ = [](){ if constexpr(!use_stdio){ ios_base::sync_with_stdio(false); cin.tie(nullptr);
  cout << fixed; cout << setprecision(12); cerr << fixed; cerr << setprecision(12); } return true; }();
template<typename ...> using to_void = void;
template<typename T, typename = void> struct is_container : false_type {};
template<typename T> struct is_container<T, to_void<decltype(declval<T>().begin()), decltype(declval<T>().end())>> : true_type {};
template<typename V, typename N> struct resize { V& v; N& n; resize(V& vv, N& nn) : v(vv), n(nn) {} ~resize() { v.resize(n); } };

inline void rd(int& x) { if constexpr(use_stdio) scanf("%d", &x); else cin >> x; }
inline void rd(long long& x) { if constexpr(use_stdio) scanf("%lld", &x); else cin >> x; }
inline void rd(double& x) { if constexpr(use_stdio) scanf("%lf", &x); else cin >> x; }
inline void rd(long double& x) { if constexpr(use_stdio){ double y; scanf("%lf", &y); x=y; } else cin >> x; }
inline void rd(char& x) { if constexpr(use_stdio) scanf(" %c", &x); else cin >> x; }
inline void rd(char* x) { if constexpr(use_stdio) scanf("%s", x); else cin >> x; }
inline void rd(string& x) { if constexpr(use_stdio) assert(false); else cin >> x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void rd(T& x) { cin >> x; }
template<typename T> inline void rd(T* x);
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x);
template<typename... Ts> inline void rd(tuple<Ts...>& x);
template<typename V, typename N> inline void rd(const resize<V, N>& x);
template<typename T, typename U> inline void rd(pair<T, U>& x) { rd(x.first); rd(x.second); }
template<typename V, typename N> inline void rd(const resize<V, N>& x) { const_cast<V&>(x.v).resize(x.n); rd(x.v); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void rd(T& x) { for(auto& v : x) rd(v); }
template<typename T, typename U, typename... Ts> inline void rd(T&& t, U&& u, Ts&&... ts) {
  rd(forward<T>(t)); rd(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void rd(tuple<Ts...>& x) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_rd = [](auto&&... xs) { rd(xs...); }; apply(apply_rd, x); }
template<typename T> inline void rd(T* x) { rd(*x); }

inline void prt(const int& x) { if constexpr(use_stdio) fprintf(stdio_out, "%d", x); else *out << x; }
inline void prt(const long long& x) { if constexpr(use_stdio) fprintf(stdio_out, "%lld", x); else *out << x; }
inline void prt(const double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", x); else *out << x; }
inline void prt(const long double& x) { if constexpr(use_stdio) fprintf(stdio_out, "%.12f", (double)x); else *out << x; }
inline void prt(const char& x) { if constexpr(use_stdio) fprintf(stdio_out, "%c", x); else *out << x; }
inline void prt(const char* x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x); else *out << x; }
inline void prt(const string &x) { if constexpr(use_stdio) fprintf(stdio_out, "%s", x.c_str()); else *out << x; }
template<typename T, typename enable_if<!use_stdio && is_integral<T>::value>::type* = nullptr> inline void prt(const T& x) { *out << x; }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x);
template<typename... Ts> inline void prt(const tuple<Ts...>& x);
template<typename T, typename U> inline void prt(const pair<T, U>& x) { prt(x.first); prt(' '); prt(x.second); }
template<typename T, typename enable_if<is_container<T>::value>::type* = nullptr> inline void prt(const T& x) {
  if (x.begin() != x.end()) { prt(*x.begin()); for(auto it = x.begin(); ++it != x.end(); ) { prt(' '); prt(*it); } } }
template<typename T, typename U, typename... Ts> inline void prt(T&& t, U&& u, Ts&&... ts) {
  prt(forward<T>(t)); prt(' '); prt(forward<U>(u), forward<Ts>(ts)...); }
template<typename... Ts> inline void prt(const tuple<Ts...>& x ) { static_assert(sizeof...(Ts) > 0);
  constexpr auto apply_prt = [](auto&&... xs) { prt(xs...); }; apply(apply_prt, x); }
inline void wt() { prt('\n'); }
template<typename... Ts> inline void wt(Ts&&... ts) { prt(forward<Ts>(ts)...); wt(); }

#ifdef MY_DEBUG_FLAG
inline void enter_db() { if constexpr(use_stdio) stdio_out = stderr; else out = &cerr; }
inline void leave_db() { if constexpr(use_stdio) stdio_out = stdout; else out = &cout; }
inline void db() { enter_db(); prt('\n'); leave_db(); }
template<typename... Ts> inline void db(Ts&&... ts) { enter_db(); prt(forward<Ts>(ts)...); wt(); leave_db(); }
#define db(...) utils::db("Debug(", #__VA_ARGS__, ") == (", __VA_ARGS__, ")")
#else
#define db(...)
#endif // define(MY_DEBUG_FLAG)
constexpr int slen(char*s){ return (int) strlen(s); }
void flush() { if constexpr(use_stdio) fflush(stdout); else cout << std::flush; }
} using utils::rd, utils::prt, utils::wt, utils::slen, utils::resize, utils::flush;

#define pb emplace_back
#define x first
#define y second
#define sz(a) ((int)(a).size())
#define rep(i,a,b) for(int i=(a); i<(b); i++)
#define dec(i,n,a) for(int i=(n); i>=(a); i--)
#define clr(a,v) memset(a, v, sizeof(a))
#define all(a) (a).begin(),(a).end() /* }}} */

constexpr int inf = 0x3f3f3f3f;
constexpr ld EPS = 1e-9;
constexpr int MAXN = 1e5 + 10;
constexpr int LOGN = 20;
constexpr int mod = 1000000007;

int n, d, b;
vi vet;

bool cant(int from, int to) {
  int nd = max(0, (abs(from - to) - 1) / d);
  return nd > min(to, n-1-to);
}

bool ok(int k) {
  int ptr = 0;
  int q = 0;
  rep(i,0,n) {
    if (i < k || n-1-i < k) continue;
    int f = b;
    while (f > 0) {
      while(q == vet[ptr] || cant(ptr, i)) {
        ptr++;
        q = 0;
        if (ptr == n) return false;
      }
      int v = min(vet[ptr] - q, f);
      f -= v;
      q += v;
    }
  }
  return true;
}

int main() {
  rd(n, d, b, resize(vet, n));
  int l = 0, r = n / 2 - 1, ans = n / 2, md;
  db(ok(0));
  while (l <= r) {
    md = (l + r) / 2;
    if (ok(md)) ans = md, r = md - 1;
    else l = md + 1;
  }
  wt(ans);
}


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n, d, b;
	cin >> n >> d >> b;
	vi a(n), SUM(n + 1);
	cin >> a;
	partial_sum(all(a), SUM.begin() + 1);
	auto sum = [&](int i, int j){
		return SUM[j] - SUM[i];
	};
	int res = 0;
	if(sum(0, (n + 1) / 2) >= (n + 1) / 2 * b){ // Left should help right
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(0LL, i - 1LL * cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ res;
			}
		}
	}
	else{ // Right should help left
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + 1LL * cnt * d, 1LL * n)) - hid >= b){
				hid += b;
			}
			else{
				++ res;
			}
		}
	}
	cout << res;
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n, d, b;
	cin >> n >> d >> b;
	vi a(n), SUM(n + 1);
	cin >> a;
	partial_sum(all(a), SUM.begin() + 1);
	auto sum = [&](int i, int j){
		return SUM[j] - SUM[i];
	};
	int L = 0, R = 0;
	if(sum(0, (n + 1) / 2) >= (n + 1) / 2 * b){ // Left should help right
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + 1LL * cnt * d, 1LL * (n + 1) / 2)) - hid >= b){
				hid += b;
			}
			else{
				++ L;
			}
		}
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(0LL, i - 1LL * cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ R;
			}
		}
	}
	else{ // Right should help left
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + 1LL * cnt * d, 1LL * n)) - hid >= b){
				hid += b;
			}
			else{
				++ L;
			}
		}
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(1LL * (n + 1) / 2, i - 1LL * cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ R;
			}
		}
	}
	cout << max(L, R);
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n, d, b;
	cin >> n >> d >> b;
	vi a(n), SUM(n + 1);
	cin >> a;
	partial_sum(all(a), SUM.begin() + 1);
	auto sum = [&](int i, int j){
		return SUM[j] - SUM[i];
	};
	int L = 0, R = 0;
	if(sum(0, (n + 1) / 2) >= (n + 1) / 2 * b){ // Left should help right
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + 1LL * cnt * d + 1, 1LL * (n + 1) / 2)) - hid >= b){
				hid += b;
			}
			else{
				++ L;
			}
		}
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(0LL, i - 1LL * cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ R;
			}
		}
	}
	else{ // Right should help left
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + 1LL * cnt * d + 1, 1LL * n)) - hid >= b){
				hid += b;
			}
			else{
				++ L;
			}
		}
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(1LL * (n + 1) / 2, i - 1LL * cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ R;
			}
		}
	}
	cout << max(L, R);
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n, d, b;
	cin >> n >> d >> b;
	vi a(n), SUM(n + 1);
	cin >> a;
	partial_sum(all(a), SUM.begin() + 1);
	auto sum = [&](int i, int j){
		return SUM[j] - SUM[i];
	};
	int res = 0;
	if(sum(0, (n + 1) / 2) >= (n + 1) / 2 * b){ // Left should help right
		for(int i = n - 1, cnt = 1, hid = 0; i >= (n + 1) / 2; -- i, ++ cnt){
			if(sum(max(0, i - cnt * d), n) - hid >= b){
				hid += b;
			}
			else{
				++ res;
			}
		}
	}
	else{ // Right should help left
		for(int i = 0, cnt = 1, hid = 0; i < (n + 1) / 2; ++ i, ++ cnt){
			if(sum(0, min(i + cnt * d, n)) - hid >= b){
				hid += b;
			}
			else{
				++ res;
			}
		}
	}
	cout << res;
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC target ("avx2")
//#pragma GCC optimization ("unroll-loops")
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")

#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

const long double PI = 4 * atan((long double) 1);

typedef long long ll;
typedef long double ld;

typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef complex<ld> cd;

typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ld> vd;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;

#define f0r(i,a) for(int i=0;i<a;i++)
#define f1r(i,a,b) for(int i=a;i<b;i++)
#define trav(a, x) for (auto& a : x)
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)

#define mp make_pair
#define pb push_back
#define eb emplace_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound

#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rall(x) rbegin(x), rend(x)
#define resz resize
#define ins insert

template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
  cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}

template<class T> bool ckmin(T& a, const T& b) {
	return a > b ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) {
	return a < b ? a = b, 1 : 0; }

namespace input {
	template<class T> void re(complex<T>& x);
	template<class T1, class T2> void re(pair<T1,T2>& p);
	template<class T> void re(vector<T>& a);
	template<class T, size_t SZ> void re(array<T,SZ>& a);

	template<class T> void re(T& x) { cin >> x; }
	void re(double& x) { string t; re(t); x = stod(t); }
	void re(ld& x) { string t; re(t); x = stold(t); }
	template<class T, class... Ts> void re(T& t, Ts&... ts) {
		re(t); re(ts...);
	}

	template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }
	template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }
	template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }
	template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }
}

using namespace input;

namespace output {
	void pr(int x) { cout << x; }
	void pr(long x) { cout << x; }
	void pr(ll x) { cout << x; }
	void pr(unsigned x) { cout << x; }
	void pr(unsigned long x) { cout << x; }
	void pr(unsigned long long x) { cout << x; }
	void pr(float x) { cout << x; }
	void pr(double x) { cout << x; }
	void pr(ld x) { cout << x; }
	void pr(char x) { cout << x; }
	void pr(const char* x) { cout << x; }
	void pr(const string& x) { cout << x; }
	void pr(bool x) { pr(x ? "true" : "false"); }
	template<class T> void pr(const complex<T>& x) { cout << x; }

	template<class T1, class T2> void pr(const pair<T1,T2>& x);
	template<class T> void pr(const T& x);

	template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
		pr(t); pr(ts...);
	}
	template<class T1, class T2> void pr(const pair<T1,T2>& x) {
		pr("{",x.f,", ",x.s,"}");
	}
	template<class T> void pr(const T& x) {
		pr("{"); // const iterator needed for vector<bool>
		bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0;
		pr("}");
	}

	void ps() { pr("\n"); } // print w/ spaces
	template<class T, class... Ts> void ps(const T& t, const Ts&... ts) {
		pr(t); if (sizeof...(ts)) pr(" "); ps(ts...);
	}

	void pc() { pr("]\n"); } // debug w/ commas
	template<class T, class... Ts> void pc(const T& t, const Ts&... ts) {
		pr(t); if (sizeof...(ts)) pr(", "); pc(ts...);
	}
	#define dbg(x...) pr("[",#x,"] = ["), pc(x);
}

using namespace output;

namespace io {
	void setIn(string s) { freopen(s.c_str(),"r",stdin); }
	void setOut(string s) { freopen(s.c_str(),"w",stdout); }
	void setIO(string s = "") {
		cin.sync_with_stdio(0); cin.tie(0); // fast I/O
		//cin.exceptions(cin.failbit); // ex. throws exception when you try to read letter into int
		if (sz(s)) { setIn(s+".in"), setOut(s+".out"); } // for USACO
	}
}

using namespace io;
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());

const ll MOD = 998244353;

typedef decay<decltype(MOD)>::type T;
struct mi {
	T val;
	explicit operator T() const { return val; }
	mi() { val = 0; }
	mi(const ll& v) {
		val = (-MOD <= v && v <= MOD) ? v : v % MOD;
		if (val < 0) val += MOD;
	}
	// friend ostream& operator<<(ostream& os, const mi& a) {
		// return os << a.val; }
	friend void pr(const mi& a) { pr(a.val); }
	friend void re(mi& a) { ll x; re(x); a = mi(x); }

	friend bool operator==(const mi& a, const mi& b) {
		return a.val == b.val; }
	friend bool operator!=(const mi& a, const mi& b) {
		return !(a == b); }
	friend bool operator<(const mi& a, const mi& b) {
		return a.val < b.val; }

	mi operator-() const { return mi(-val); }
	mi& operator+=(const mi& m) {
		if ((val += m.val) >= MOD) val -= MOD;
		return *this; }
	mi& operator-=(const mi& m) {
		if ((val -= m.val) < 0) val += MOD;
		return *this; }
	mi& operator*=(const mi& m) {
		val = (ll)val*m.val%MOD; return *this; }
	friend mi pow(mi a, ll p) {
		mi ans = 1; assert(p >= 0);
		for (; p; p /= 2, a *= a) if (p&1) ans *= a;
		return ans;
	}
	friend mi inv(const mi& a) {
		assert(a != 0); return pow(a,MOD-2); }
	mi& operator/=(const mi& m) { return (*this) *= inv(m); }

	friend mi operator+(mi a, const mi& b) { return a += b; }
	friend mi operator-(mi a, const mi& b) { return a -= b; }
	friend mi operator*(mi a, const mi& b) { return a *= b; }
	friend mi operator/(mi a, const mi& b) { return a /= b; }
};

typedef pair<mi,mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;
const int MAX = 1e5 + 5;
vl a;
ll n,d, b;
ll pre[MAX];

ll sum(ll l, ll r){
    if(l>r) return 0;
    if(l<0 && r<0) return 0;
    if(l>=n && r>=n) return 0;
    ckmin(r, n-1);
    ckmax(l, 0LL);
    return pre[r] - (l == 0? 0: pre[l-1]);
}
int check(ll k){
    ll l, r;
    l = k;
    r = n-1 -(k);
    ckmin(r, n-1);
    ckmax(l, 0LL);
    f1r(i, l, n/2+1){
        ll v1 = sum(l-(l+1)*d, i+(i+1)*d);
        if(v1<(i-l+1)*b) return 0;
    }
    for(int i = r; i>= n/2+1; i--){
        ll v2 = sum(i - (n-1 -i+1)*d, r+(n-1-r+1)*d);
        if(v2<(r-i+1)*b) return 0;
    }
    return 1;
}
int main(){
    re(n, d, b);
    f0r(i, n){
        int ai; re(ai);
        a.eb(ai);
    }
    f0r(i, n){
        if(i == 0) pre[i] = a[i];
        else pre[i] = pre[i-1] + a[i];
    }
    int l = 0;
    int r = (n+1)/2;
    while(abs(r-l)>1){
        int mid = (l+r)/2;
        if(check(mid)) r = mid;
        else l = mid + 1;
    }
    if(l>r) swap(l, r);
    if(check(l)) ps(l);
    else ps(r);
}


// #pragma GCC optimize("O3")
// #pragma GCC target("sse4")

#include <bits/stdc++.h>

using namespace std;

#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define __FOR3(i, a, n, inc) for(int i = (a); (inc) > 0 ? i < (n) : i >= (n); i += (inc))
#define __FOR2(i, a, n) __FOR3(i, a, n, 1)
#define __FOR1(i, n) __FOR2(i, 0, n)
#define FOR(...) GET_MACRO(__VA_ARGS__, __FOR3, __FOR2, __FOR1)(__VA_ARGS__)

#define BOOST 			ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ELO             exit(0)
#define ALL(a) 			(a).begin(), (a).end()
#define SZ(a) 			(int)(a).size()
#define TRAV(a, b) 		for (auto& a : b)
#define REV(a)          reverse(ALL(a))
#define SORT(a)         sort(ALL(a))
#define SORTR(a)        SORT(a), REV(a)
#define PB              push_back
#define F               first
#define S               second
using ll = 				long long;
using ld = 				long double; // 'long double' is 2.2 times slower than double
using pii = 			pair<int, int>;
using pll = 			pair<ll, ll>;
using pld =             pair<ld, ld>;
using vi = 				vector<int>;
using vvi =             vector<vi>;
using vll = 			vector<ll>;
using vvll =            vector<vll>;
using vpii = 			vector<pii>;
using vpll = 			vector<pll>;
using vld =             vector<ld>;
using vpld =            vector<pld>;

constexpr int MOD = 1e9 + 7; // 998244353
constexpr int INF = MOD;
constexpr ll LLINF = 1e18;
const ld PI = acos(-1);

template <class T> inline bool setmin(T& a, T b) {if (a > b) return a = b, 1; return 0; }
template <class T> inline bool setmax(T& a, T b) {if (a < b) return a = b, 1; return 0; }

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

template <class key, class cmp = less<key>> using ordered_set = tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template <class key, class cmp = less_equal<key>> using ordered_multiset = tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
//* find_by_order(k) - returns an iterator to the k-th largest element (counting from zero)
//* order_of_key(k)  - the number of items in a set that are strictly smaller than k.
template <class key, class value, class cmp = less<key>> using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
using pref_trie = trie<string, null_type, trie_string_access_traits<>, pat_trie_tag, trie_prefix_search_node_update>;
// * prefix_range(s) - return iterator range, prefix equal to s

namespace input {
    template <class T> istream &operator>>(istream &os, vector<T> & vec) { for (auto& u : vec) os >> u; return os; }
    template<class T1, class T2> istream& operator>>(istream& os, pair<T1, T2>& p) { return os >> p.first >> p.second; }
    template <class T, size_t N> istream& operator>>(istream& os, array<T, N>& a) { for (auto& u : a) os >> u; return os; }

    void re() {}
    template <typename T, typename... args> void re(T& x, args&... tail) { cin >> x; re(tail...); }
} // namespace input
using namespace input;

namespace output {
    template <class T> ostream &operator<<(ostream &os, const vector<T> & vec){for (const auto& u : vec) os << u << " "; return os; }
    template<class T1, class T2> ostream& operator<<(ostream& os, const pair<T1, T2>& p) { return os << p.first << " " << p.second; }
    template <class T> ostream &operator<<(ostream &os, set<T> & con) { for (const auto& u : con) os << u << " "; return os; }
    template <class T, size_t N> ostream& operator<<(ostream& os, array<T, N>& a) { for (const auto& u : a) os << u << " "; return os; }

    void pr() {}
    template <typename T> void pr(const T& x) { cout << x; }
    template <typename T, typename... args> void pr(const T& x, const args&... tail) { cout << x << " "; pr(tail...);}
    template <typename T> void prs(const T& x) { cout << x << " "; }
    template <typename T, typename... args> void prs(const T& x, const args&... tail) { cout << x << " "; prs(tail...);}
    template <typename... args> void prln(const args&... tail) { pr(tail...); cout << "\n";}
} // namespace output
using namespace output;

namespace pair_magic {
	#define PT1T2 pair<T1,T2>
	#define TT1T2 template<class T1, class T2>
	TT1T2 inline PT1T2 operator+(const PT1T2 &p1, const PT1T2 &p2) { return PT1T2(p1.first + p2.first, p1.second + p2.second); }
	TT1T2 inline PT1T2& operator+=(PT1T2 &p1, const PT1T2 &p2) { p1.first += p2.first, p1.second += p2.second; return p1; }
	TT1T2 inline PT1T2 operator-(const PT1T2 &p1, const PT1T2 &p2) { return PT1T2(p1.first - p2.first, p1.second - p2.second); }
	TT1T2 inline PT1T2& operator-=(PT1T2 &p1, const PT1T2 &p2) { p1.first -= p2.first, p1.second -= p2.second; return p1; }
	#undef PT1T2
	#undef TT1T2
}
using namespace pair_magic;

namespace random_nsp {
	thread_local std::mt19937 gen{std::random_device{}()};
	template <typename T>T random(T min, T max){using dist = std::conditional_t<std::is_integral<T>::value, std::uniform_int_distribution<T>, std::uniform_real_distribution<T>>;return dist{min, max}(gen);}
	template <typename T> T randomINT(T min, T max) { return std::uniform_int_distribution<T>{min, max}(gen); }
}
using namespace random_nsp;

namespace triple {
	#define TT1T2T3 template<class T1, class T2, class T3>
	#define TRT1T2T3  triple<T1, T2, T3>
	TT1T2T3 struct triple { T1 a; T2 b; T3 c; triple() : a(T1()), b(T2()), c(T3()) {}; triple(T1 _a, T2 _b, T3 _c) :a(_a), b(_b), c(_c) {} };
	TT1T2T3 bool operator<(const TRT1T2T3&t1, const TRT1T2T3&t2) { if (t1.a != t2.a)return t1.a < t2.a; else if (t1.b != t2.b)return t1.b < t2.b; else return t1.c < t2.c; }
	TT1T2T3 bool operator>(const TRT1T2T3&t1, const TRT1T2T3&t2) { if (t1.a != t2.a)return t1.a > t2.a; else if (t1.b != t2.b)return t1.b > t2.b; else return t1.c > t2.c; }
	TT1T2T3 bool operator==(const TRT1T2T3&t1, const TRT1T2T3&t2) { return (t1.a == t2.a && t1.b == t2.b && t1.c == t2.c); }
	TT1T2T3 inline istream& operator >> (istream& os, triple<T1, T2, T3>& t) { return os >> t.a >> t.b >> t.c; }
	TT1T2T3 ostream& operator << (ostream& os, const triple<T1, T2, T3>& t) { return os << t.a << " " << t.b << " " << t.c; }
	#undef TRT1T2T3
	#undef TT1T2T3
	using tri =  triple<int, int, int>;
	using trll = triple<ll, ll, ll>;
	using vtri = vector<tri>;
    using vtrll = vector<trll>;
}
using namespace triple;

template <class T> T invGeneral(T a, T b) { // 0 < a < b, gcd(a,b) = 1
    a %= b;
    if (a == 0) return b == 1 ? 0 : -1;
    T x = invGeneral(b, a);
    return x == -1 ? -1 : ((1-(ll)b * x) / a + b) % b;
}

template<class T, int MOD> struct modular {
	T val;
	explicit operator T() const { return val; }
	modular() { val = 0; }
	modular(const ll& v) {
		val = (-MOD <= v && v <= MOD) ? v : v % MOD;
		if (val < 0) val += MOD;
	}

	friend ostream& operator<<(ostream& os, const modular& a) { return os << a.val; }
	friend void pr(const modular& a) { pr(a.val); }
	friend void re(modular& a) { ll x; re(x); a = modular(x); }

	friend bool operator==(const modular& a, const modular& b) { return a.val == b.val; }
	friend bool operator!=(const modular& a, const modular& b) { return !(a == b); }
	friend bool operator<(const modular& a, const modular& b) { return a.val < b.val; }

	modular operator-() const { return modular(-val); }
	modular& operator+=(const modular& m) { if ((val += m.val) >= MOD) val -= MOD; return *this; }
	modular& operator-=(const modular& m) { if ((val -= m.val) < 0) val += MOD; return *this; }
	modular& operator*=(const modular& m) { val = (ll)val*m.val%MOD; return *this; }
	friend modular pow(modular a, ll p) {
		modular ans = 1; for (; p; p /= 2, a *= a) if (p&1) ans *= a;
		return ans;
	}
	friend modular inv(const modular& a) {
		auto i = invGeneral(a.val,MOD); assert(i != -1);
		return i;
	} // equivalent to return exp(b,MOD-2) if MOD is prime
	modular& operator/=(const modular& m) { return (*this) *= inv(m); }

	friend modular operator+(modular a, const modular& b) { return a += b; }
	friend modular operator-(modular a, const modular& b) { return a -= b; }
	friend modular operator*(modular a, const modular& b) { return a *= b; }
	friend modular operator/(modular a, const modular& b) { return a /= b; }
};

using mi = modular<int, MOD>;
using pmi = pair<mi,mi>;
using vmi = vector<mi>;
using vpmi = vector<pmi>;

namespace debug {
    template < typename _T > inline void _debug(const char *s, _T x) { cerr << s << " = " << x << "\n"; }
    template < typename _T, typename... args > void _debug(const char *s, _T x, args... a) { while(*s != ',') cerr << *s++; cerr << " = " << x << ','; _debug(s + 1, a...); }

    #if 1
        #define debug(...) _debug(#__VA_ARGS__, __VA_ARGS__)
        #define cerr cout
    #else
        #define debug(...) 1999
        #define cerr if(0) cout
    #endif
} // namespace debug
using namespace debug;

//////////////_________CODE_________//////////////

int main() {
    BOOST;
	int n, d, b; re(n, d, b);
	vi a(n); re(a);

	auto solve = [&](int cnt) -> int {
		vi sum(n + 2);
		FOR(i, n) sum[i + 1] = sum[i] + a[i];
		int lok = 0, res = 0;
		FOR(i, cnt) {
			int id = min(1ll * n, 1ll * (i + 1) * (d + 1));
			int ile = sum[id] - lok;
			// debug(i, id, ile);
			if(ile >= b) lok += b;
			else res++;
		}
		return res;
	};

	// FOR(i, 0, n) {
	// 	int xd = solve(i);
	// 	REV(a);
	// 	setmax(xd, solve(n - i));
	// 	REV(a);
	// 	debug(xd);
	// }

	int res = solve(n + 1 >> 1);
	REV(a);
	prln(max(res, solve(n >> 1)));
}


#include <bits/stdc++.h>
using namespace std;

using ll = long long;

#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define len(x) int((x).size())

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define randint(n) uniform_int_distribution<int>(1, (n))(rng)

int ceiling(int a, int b)
{
	if(a%b == 0) return int(a/b);
	return int(a/b) + 1;
}

int d;
int b;

const int p2 = (1<<17);
int st[p2+p2];

int query(int l, int r)
{
	l = max(l,1);
	r = min(r,p2);

	l += p2-1;
	r += p2-1;

	int ret = 0;

	while(l<=r)
	{
		if(l%2==1) ret += st[l++];
		if(r%2==0) ret += st[r--];
		l/=2;
		r/=2;
	}

	return ret;
}

void upd(int ind, int new_val)
{
	ind += p2-1;
	st[ind]=new_val;
	ind/=2;

	while(ind>0)
	{
		st[ind] = st[ind+ind] + st[ind+ind+1];
		ind /= 2;
	}
}

int solve(vector<int> A, int c)
{
	// solve the subproblem with an array of length n (A) where students can move a distance d and where the first c things are checked

	// initialise seg tree

	for(int i=0; i<p2; i++)
	{
		if(i < len(A)) st[i+p2]=A[i];
		else st[i+p2]=0;
	}

	for(int i=p2-1; i>=1; i--) st[i] = st[i+i] + st[i+i+1];

	// done

	int a_ind=0;
	int ans=0;

	for(int i=1; i<=c; i++)
	{
		// try and satisfy ith room requirement

		int l,r;

		if(ll(i)*ll(d) >= ll(p2))
		{
			l=1;
			r=p2;
		}

		else
		{
			l=i-d*i;
			r=i+d*i;
		}

		if(query(l,r) < b) // we fail to be able to satisfy here
		{
			ans++;
			continue;
		}

		int place=b; // 'children left to place'

		while(place>0)
		{
			if(A[a_ind] >= place)
			{
				upd(a_ind+1,A[a_ind]-place); // i THINK that's a +1
				break;
			}

			place -= A[a_ind];
			upd(a_ind+1,0);
			a_ind++;
		}
	}

	return ans;
}

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	#ifdef ARTHUR_LOCAL
		ifstream cin("input.txt");
	#endif

	int n;
	cin>>n>>d>>b;

	vector<int> A;

	for(int i=0; i<n; i++)
	{
		int a;
		cin>>a;
		A.push_back(a);
	}

	int ans = 0;

	vector<int> A_front;
	int i=0;
	int cur=0;
	int front_no = b * ceiling(n,2);

	while(cur < front_no)
	{
		if(A[i] + cur >= front_no)
		{
			A_front.push_back(front_no - cur);
			A[i] -= (front_no-cur);

			break;
		}

		A_front.push_back(A[i]);
		cur += A[i];
		A[i]=0;
		i++;
	}

	// for(auto a:A_front) cout << a << " ";
	// cout << endl;

	reverse(all(A));

	// for(auto a:A) cout << a << " ";
	// cout << endl;

	cout << max(solve(A_front,ceiling(n,2)),solve(A,int(n/2))) << endl;
}