Codeforces Round #486 (Div. 3) E. Divisibility by 25【贪心】

E. Divisibility by 25

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

You are given an integer $n$ from $1$ to ${10}^{18}$ without leading zeroes.

In one move you can swap any two adjacent digits in the given number in such a way that the resulting number will not contain leading zeroes. In other words, after each move the number you have cannot contain any leading zeroes.

What is the minimum number of moves you have to make to obtain a number that is divisible by $25$? Print -1 if it is impossible to obtain a number that is divisible by $25$.

Input

The first line contains an integer $n$ ($1\le n\le {10}^{18}$). It is guaranteed that the first (left) digit of the number $n$ is not a zero.

Output

If it is impossible to obtain a number that is divisible by $25$, print -1. Otherwise print the minimum number of moves required to obtain such number.

Note that you can swap only adjacent digits in the given number.

Examples

input

Copy

5071

output

Copy

4

input

Copy

705

output

Copy

1

input

Copy

1241367

output

Copy

-1

Note

In the first example one of the possible sequences of moves is 5071 $\to$ 5701 $\to$ 7501 $\to$ 7510 $\to$ 7150.

思路：

已知25的倍数末尾一定是00、25、50、75，且末尾为以上值的一定是25的倍数。那么就可以分别判断四种情况，取最优。

判断时直接找到距离末尾最近的目标值，然后直接交换过来即可。需要注意前导零，如果交换过程中出现前导零，那么我们可以在交换前用靠前的并且不是目标值的非零数移到前面，这样就不会有前导零了，为了简便，我们可以在最后判断一下有多少前导零，就是需要额为走的步数。

-1的情况可以预先判断一下。

代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
using namespace std;
#define inf 0x3f3f3f3f
#define MAXN 200005
#define ll long long
ll n;
int len,a[20],b[20];
int vis[10];
int main()
{
    scanf("%lld",&n);
    memset(vis,0,sizeof vis);
    while(n)
    {
        a[len++]=n%10;
        vis[n%10]++;
        n/=10;
    }
    int ans=inf;
    if(!(vis[0]>=2 || (vis[0] && vis[5]) || (vis[2] && vis[5]) || (vis[7] && vis[5])))
        printf("-1\n");
    else
    {
        if(vis[0]>=2)
        {
            int tmp,s=0;
            memcpy(b,a,sizeof a);
            for(int i=0;i<len;i++)
            {
                if(b[i]==0)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>0;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=1;i<len;i++)
            {
                if(b[i]==0)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>1;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=len-1;i>=0;i--)
            {
                if(b[i]) break;
                s++;
            }
            ans=min(ans,s);
        }
        if(vis[2] && vis[5])
        {
            memcpy(b,a,sizeof a);
            int tmp,s=0;
            for(int i=0;i<len;i++)
            {
                if(b[i]==5)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>0;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=1;i<len;i++)
            {
                if(b[i]==2)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>1;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=len-1;i>=0;i--)
            {
                if(b[i]) break;
                s++;
            }
            ans=min(ans,s);
        }
        if(vis[5] && vis[0])
        {
            int tmp,s=0;
            memcpy(b,a,sizeof a);
            for(int i=0;i<len;i++)
            {
                if(b[i]==0)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>0;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=1;i<len;i++)
            {
                if(b[i]==5)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>1;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=len-1;i>=0;i--)
            {
                if(b[i]) break;
                s++;
            }
            ans=min(ans,s);
        }
        if(vis[7] && vis[5])
        {
            int tmp,s=0;
            memcpy(b,a,sizeof a);
            for(int i=0;i<len;i++)
            {
                if(b[i]==5)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>0;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=1;i<len;i++)
            {
                if(b[i]==7)
                {
                    tmp=i;
                    break;
                }
            }
            for(int i=tmp;i>1;i--)
            {
                swap(b[i],b[i-1]);
                s++;
            }
            for(int i=len-1;i>=0;i--)
            {
                if(b[i]) break;
                s++;
            }
            ans=min(ans,s);
        }
        printf("%d\n",ans);
    }
	return 0;
}