CF educational Codeforces Round D. Round subset

Original question:
D. Round Subset
Time limit per test2 seconds
Memory limit per test256 megabytes
Inputstandard input
Outputstandard output
Let's call the roundness of the number the number of zeros to which it ends.

You have an array of n numbers. You need to choose a subset of exactly k numbers so that the roundness of the product of the selected numbers would be maxi Mum possible.

Input
The first line contains the numbers n and K (1≤n≤200, 1≤k≤n).

The second line contains n space-separated integer numbers a1, a2, ..., an (1≤ai≤1018).

Output
Print maximal roundness of product of the chosen subset of length K.

Examples
Input
3 2
50 4 20
Output
3
Input
5 3
15 16 3) 25 9
Output
3
Input
3 3
9 77 13
Output
0
Note
In the first example there is 3 subsets of 2 numbers. [4] has product roundness 2, [4, 20]-product, roundness 1, [, 20]-product, roundness 3.

In the second example subset [+] has product 6000, roundness 3.

The third example all subsets have product with roundness 0.

English:
Give you the number of n, let you choose K to multiply. Ask you the number of the last 0 at the end of the maximum number of.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
ll n,k;
ll dp[201][10001];
ll two[201],five[201],num[201];
pii get_five_two(ll x)
{
    int f=0,t=0;
    while(true)
    {
        if(x%5)
            break;
        x/=5;
        f++;
    }
    while(true)
    {
        if(x%2)
            break;
        x/=2;
        t++;
    }
    return make_pair(f,t);
}

int main()
{
    ios::sync_with_stdio(false);
    while(cin>>n>>k)
    {
        ll tot=0;
        for(int i=1;i<=n;i++)
        {
            cin>>num[i];
            pii p=get_five_two(num[i]);
            two[i]=p.second;
            five[i]=p.first;
            tot+=five[i];
        }
        for(int i=0;i<=200;i++)
        {
            for(int j=0;j<=10000;j++)
                dp[i][j]=INT_MIN;
        }
        dp[0][0]=0;
        for(ll i=1;i<=n;i++)
        {
            for(ll j=min(i,k);j>=1;j--)
            {
                for(ll kk=tot;kk>=five[i];kk--)
                    dp[j][kk]=max(dp[j][kk],dp[j-1][kk-five[i]]+two[i]);
            }
        }
        ll ans=0;
        for(ll i=1;i<=tot;i++)
            ans=max(ans,min(dp[k][i],i));//5和2最小的
        cout<<ans<<endl;
    }
    return 0;
}



}

Answer:
0 of the occurrences are only 2 and 5 multiplied, so the number of n, each of which is recorded by the number of 2 and 5 factors.

N number of selected K, obvious knapsack problem. If you apply the 01 Knapsack model directly, you cannot know the number of the previous state 2 and 5 when the state transitions.

Add one dimension and record the number of 5 (2 is also possible). Set the state transition equation
Dp[i][j][k]=max (Dp[[i−1][j][k],dp[i−1][j−1][k−five[i]]+two[i]) Dp[i][j][k]=max (dp[[i-1][j][k],dp[i-1][j-1][ K-five[i]]+two[i])
Indicates the maximum number of 2 in cases where the number of first I is selected J can have K 5.

So the final result is to find out the number of K selected, the least 2 and 5 is the number of 0

Note Using a scrolling array to become 2-dimensional, otherwise burst memory

Dp[j][k]=max (Dp[j][k],dp[j−1][k−five[i]]+two[i]) Dp[j][k]=max (Dp[j][k],dp[j-1][k-five[i]]+two[i])