Codeforces 581C Developing Skills【贪心】

C. Developing Skills

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Petya loves computer games. Finally a game that he's been waiting for so long came out!

The main character of this game has n different skills, each of which is characterized by an integer a_i from 0 to 100. The higher the number a_i is, the higher is the i-th skill of the character. The total rating of the character is calculated as the sum of the values ​​of for all i from 1 to n. The expression ⌊ x⌋ denotes the result of rounding the number x down to the nearest integer.

At the beginning of the game Petya got k improvement units as a bonus that he can use to increase the skills of his character and his total rating. One improvement unit can increase any skill of Petya's character by exactly one. For example, if a₄ = 46, after using one imporvement unit to this skill, it becomes equal to 47. A hero's skill cannot rise higher more than 100. Thus, it is permissible that some of the units will remain unused.

Your task is to determine the optimal way of using the improvement units so as to maximize the overall rating of the character. It is not necessary to use all the improvement units.

Input

The first line of the input contains two positive integers n and k (1 ≤ n ≤ 10⁵, 0 ≤ k ≤ 10⁷) — the number of skills of the character and the number of units of improvements at Petya's disposal.

The second line of the input contains a sequence of n integers a_i (0 ≤ a_i ≤ 100), where a_i characterizes the level of the i-th skill of the character.

Output

The first line of the output should contain a single non-negative integer — the maximum total rating of the character that Petya can get using k or less improvement units.

Examples

Input

2 4
7 9

Output

2

Input

3 8
17 15 19

Output

5

Input

2 2
99 100

Output

20

Note

In the first test case the optimal strategy is as follows. Petya has to improve the first skill to 10 by spending 3 improvement units, and the second skill to 10, by spending one improvement unit. Thus, Petya spends all his improvement units and the total rating of the character becomes equal to lfloor frac{100}{10} rfloor +  lfloor frac{100}{10} rfloor = 10 + 10 =  20.

In the second test the optimal strategy for Petya is to improve the first skill to 20 (by spending 3 improvement units) and to improve the third skill to 20 (in this case by spending 1 improvement units). Thus, Petya is left with 4 improvement units and he will be able to increase the second skill to 19 (which does not change the overall rating, so Petya does not necessarily have to do it). Therefore, the highest possible total rating in this example is .

In the third test case the optimal strategy for Petya is to increase the first skill to 100 by spending 1 improvement unit. Thereafter, both skills of the character will be equal to 100, so Petya will not be able to spend the remaining improvement unit. So the answer is equal to . 

题目大意：

一共给你N个技能，此时有K个技能点，每个技能的基础值已知，而且上限是100.其最终价值的计算是所有技能点除以十相加（向下取整）.我们可以随意的将这K个技能点分配，问最终能够得到的最大的最终价值。

思路：

1、根据最终计算的操作，是每个技能的点数除以10相加得到的，那么我们每个技能点数贡献值和这个点数的个位数无关。

2、那么我们贪心的点就很明确了。既然每个技能点数的贡献值和这个点数的个位数无关，那么我们肯定是想将个位数向上进位。

那么想让其向上进位就要提供技能点，那么我们肯定是先将需要技能点数少的技能先向上进位。

那么我们将每个数向上进1位所需要的技能点数按照从小到大排序。然后对这些需要进位的数字挨个进位，直到技能点分配完为止。

3、那么我们如果将所有数值都向上进了1位之后技能点还有剩余，那么对应看看哪些技能的点数没有达到100，对于没有达到100的，我们尽量将其增加至100.

整个贪心过程就结束了。

Ac代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct node
{
    int x,y;
}a[100600];
int cmp(node a,node b)
{
    return a.y<b.y;
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d",&a[i].x);
            a[i].y=(10-a[i].x%10)%10;
        }
        sort(a,a+n,cmp);
        for(int i=0;i<n;i++)
        {
            if(m>=a[i].y)m-=a[i].y,a[i].x+=a[i].y;
        }

        for(int i=0;i<n;i++)
        {
            if(m==0)break;
            if(a[i].x<=90)
            {
                int tmp=100-a[i].x;
                if(m>=tmp)
                {
                    m-=tmp;
                    a[i].x+=tmp;
                }
                else
                {
                    a[i].x+=m;
                    m=0;
                    break;
                }
            }
        }
        int output=0;
        for(int i=0;i<n;i++)
        {
            output+=a[i].x/10;
        }
        printf("%d\n",output);
    }
}