Problem:
Score: 500 points

Problem Statement

In the Kingdom of AtCoder, only banknotes are used as currency. There are 10^{100}+1 kinds of banknotes, with the values of 1, 10, 10^2, 10^3, \dots, 10^{(10^{100})}. You have come shopping at a mall and are now buying a takoyaki machine with a value of N. (Takoyaki is the name of a Japanese snack.)

To make the payment, you will choose some amount of money which is at least N and give it to the clerk. Then, the clerk gives you back the change, which is the amount of money you give minus N.

What will be the minimum possible number of total banknotes used by you and the clerk, when both choose the combination of banknotes to minimize this count?

Assume that you have sufficient numbers of banknotes, and so does the clerk.

Constraints

N is an integer between 1 and 10^{1,000,000} (inclusive).

Input

Input is given from Standard Input in the following format:

N

Output

Print the minimum possible number of total banknotes used by you and the clerk.

Sample Input 1

36

Sample Output 1

8

If you give four banknotes of value 10 each, and the clerk gives you back four banknotes of value 1 each, a total of eight banknotes are used.

The payment cannot be made with less than eight banknotes in total, so the answer is 8.

Sample Input 2

91

Sample Output 2

3

If you give two banknotes of value 100, 1, and the clerk gives you back one banknote of value 10, a total of three banknotes are used.

Sample Input 3

314159265358979323846264338327950288419716939937551058209749445923078164062862089986280348253421170

Sample Output 3

243

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <limits>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <functional>
#include <iomanip>

using namespace std;

#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
using ll = long long;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
#define reps(i, S, E) for (ll i = (S); i <= (E); i++)
#define rep(i, N) reps(i, 0, N-1)
#define deps(i, E, S) for (ll i = (E); i >= (S); i--)
#define dep(i, N) deps(i, N-1, 0)
const ll INF = 1LL << 60;
const int INF_INT = 1 << 30;

template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; }return false; }
template<class T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; }return false; }
struct mll {
	static ll MOD;
	ll val;
	mll(ll v = 0) : val(v % MOD) { if (val < 0) val += MOD; }
	mll operator - () const { return -val; }
	mll operator + (const mll &b) const { return val + b.val; }
	mll operator - (const mll &b) const { return val - b.val; }
	mll operator * (const mll &b) const { return val * b.val; }
	mll operator / (const mll &b) const { return mll(*this) /= b; }
	mll operator + (ll b) const { return *this + mll(b); }
	mll operator - (ll b) const { return *this - mll(b); }
	mll operator * (ll b) const { return *this * mll(b); }
	friend mll operator + (ll a, const mll &b) { return b + a; }
	friend mll operator - (ll a, const mll &b) { return -b + a; }
	friend mll operator * (ll a, const mll &b) { return b * a; }
	mll &operator += (const mll &b) { val = (val + b.val) % MOD; return *this; }
	mll &operator -= (const mll &b) { val = (val + MOD - b.val) % MOD; return *this; }
	mll &operator *= (const mll &b) { val = (val*b.val) % MOD; return *this; }
	mll &operator /= (const mll &b) {
		ll c = b.val, d = MOD, u = 1, v = 0;
		while (d) {
			ll t = c / d;
			c -= t * d; swap(c, d);
			u -= t * v; swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	mll &operator += (ll b) { return *this += mll(b); }
	mll &operator -= (ll b) { return *this -= mll(b); }
	mll &operator *= (ll b) { return *this *= mll(b); }
	mll &operator /= (ll b) { return *this /= mll(b); }
	bool operator == (const mll &b) { return val == b.val; }
	bool operator != (const mll &b) { return val != b.val; }
	bool operator == (ll b) { return *this == mll(b); }
	bool operator != (ll b) { return *this != mll(b); }
	friend bool operator == (ll a, const mll &b) { return mll(a) == b.val; }
	friend bool operator != (ll a, const mll &b) { return mll(a) != b.val; }
	friend ostream &operator << (ostream &os, const mll &a) { return os << a.val; }
	friend istream &operator >> (istream &is, mll &a) { return is >> a.val; }
	static mll Combination(ll a, ll b) {
		chmin(b, a - b);
		if (b < 0) return mll(0);
		mll c = 1;
		rep(i, b) c *= a - i;
		rep(i, b) c /= i + 1;
		return c;
	}
};
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;

struct Fast {
	Fast() {
		cin.tie(0);
		ios::sync_with_stdio(false);
		cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
	}
} fast; //cin,cout高速化のおまじない＋桁数指定

ll mll::MOD = (ll)(1e9 + 7);// 998244353ll;

//--debug--
#ifdef LOCAL
void _debug_out_(string s = "") {
	if (s != "") { eprintf(s.c_str()); } else { eprintf("\n"); }
}
void _debug_out_(ll x, string s = "") {
	if (s != "") { eprintf(s.c_str(), x); }	else { eprintf("%lld\n", x); }
}
void _debug_out_(vvll x, string s = "") {
	string t = s;
	if (s == "") {
		ll maxLen = 0;
		rep(i, (ll)x.size()) rep(j, (ll)x[i].size()) {
			ll n = x[i][j] / 10, len = 1;
			while (n > 0) { len++; n /= 10; }
			chmax(maxLen, len);
		}
		t = "%" + to_string(maxLen) + "lld ";
	}
	rep(i, (ll)x.size()) { rep(j, (ll)x[i].size()) { eprintf(t.c_str(), x[i][j]); } eprintf("\n"); }
	eprintf("\n");
}
void _debug_out_(vll x, string s = "") {
	rep(i, (ll)x.size()) { if (s != "") { eprintf(s.c_str(), x[i]); } else { eprintf("%lld ", x[i]); } }
	eprintf("\n");
}
void _debug_out_(vector<bool> x) {
	rep(i, (ll)x.size()) { eprintf("%s", x[i] ? "o" : "x");	}
	eprintf("\n");
}
void _debug_out_(vector<vector<bool>> x) {
	rep(i, (ll)x.size()) { rep(j, (ll)x[i].size()) { eprintf("%s", x[i][j] ? "o" : "x"); } eprintf("\n"); }
	eprintf("\n");
}
void _debug_out_(map<ll, ll> x) {
	auto begin = x.begin(), end = x.end();
	for (auto iter = begin; iter != end; iter++) { eprintf("%lld:%lld ", iter->first, iter->second); }
	eprintf("\n");
}
void _debug_out_(map<char, ll> x) {
	auto begin = x.begin(), end = x.end();
	for (auto iter = begin; iter != end; iter++) { eprintf("%c:%lld ", iter->first, iter->second); }
	eprintf("\n");
}
#define debug_out(...) _debug_out_(__VA_ARGS__)
#else
#define debug_out(...) 42
#endif
//--debug--


int main() {
	string S;
	cin >> S;
	ll N = S.size();

	vll dpJust(N + 2, INF);
	vll dpOver(N + 2, INF);
	dpJust[N + 1] = 0;

	deps(i, N, 1) {
		ll num = S[i - 1] - '0';
		
		//ちょうど払った後→ちょうど払う
		chmin(dpJust[i], dpJust[i + 1] + num);

		//ちょうど払った後→ひとつ上の桁で払うこととする
		chmin(dpOver[i], dpJust[i + 1] + 10 - num);

		ll numWithOver = num + 1;

		if (numWithOver < 10) {
			//払い残しがある状態→ちょうど払う
			chmin(dpJust[i], dpOver[i + 1] + numWithOver);
		}

		//払い残しがある状態→ひとつ上の桁で払うこととする
		chmin(dpOver[i], dpOver[i + 1] + 10 - numWithOver);
	}

	//最上位桁のひとつ上の桁にゼロを仮定
	chmin(dpJust[0], dpJust[1]);
	chmin(dpJust[0], dpOver[1] + 1);

	debug_out(dpJust);
	debug_out(dpOver);

	ll result = dpJust[0];

	cout << result << endl;

	return 0;
}