1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
#include <cstdio>
#include <vector>

using namespace std;

#define ADIF(a,b) ((a<b)?(b-a):(a-b))

class route
{
public:
int N,K;
vector<int> R;

	route();
	route(const route &s);
route operator=(const route &s);
int ret();

void print() const;
};

route::route()
{
int a;

	R.clear();
	
	scanf("%d %d",&N,&K);
	
	for (int n = 0; n < N; n++)
	{
		scanf("%d",&a);
		R.push_back(a);
	}
}

route::route(const route &s)
{
	R.clear();
	
	for (int n = 0; n < s.R.size(); n++)
		R.push_back(s.R[n]);
}

route route::operator=(const route &s)
{
	R.clear();
	
	for (int n = 0; n < s.R.size(); n++)
		R.push_back(s.R[n]);
	
	return *this;
}

int route::ret()
{
int r = 0;

	for (int n = 1; n < N; n++)
	{
		if (R[n-1] + K < R[n])
		{
			r += R[n] - K - R[n-1];
			R[n-1] += R[n] - K - R[n-1];
		}
		else if (R[n] + K < R[n-1])
		{
			r += R[n-1] - K - R[n];
			R[n] += R[n-1] - K - R[n];
		}
	}
	
	for (int n = N-2; n >= 0; n--)
	{
		if (R[n+1] + K < R[n])
		{
			r += R[n] - K - R[n+1];
			R[n+1] += R[n] - K - R[n+1];
		}
		else if (R[n] + K < R[n+1])
		{
			r += R[n+1] - K - R[n];
			R[n] += R[n+1] - K - R[n];
		}
	}
	
	return r;
}

void route::print() const
{
	printf("%d %d\n",N,K);
	for (int n = 0; n < R.size(); n++)
		printf("%d ",R[n]);
	printf("\n");
}

//////////////////////////////////////////

int main()
{
route S;

//	S.print();
	printf("%d\n",S.ret());
//	S.print();
	
	return 0;
}