#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class KingdomAndDucks{
public:
int minDucks(vector<int> duckTypes) {
int cnt[55];
int size = 0;
int max = 0;
memset(cnt,0,sizeof(cnt));
int m = duckTypes.size();
for(int i = 0; i < m; i++) {
cnt[duckTypes[i]]++;
}
for(int j = 1; j <= 50; j++) {
if(cnt[j] > 0) {
if(max < cnt[j])
max = cnt[j];
size++;
}
}
return size*max;
}
};
#deinfie FOR(i,a,b) for (int i = a; i <= b; i++)
int minDucks(vector < int > ducktype ) {
map < int , int > f; // we will use map
int z = ducktype.size(), d = 0;
FOR (i, 0, z - 1) {
int u = f[ducktype [i]];
f[ducktype [i]] = u + 1;
d = max (d, u + 1);
}
//size of the map f is c.
return d * f.size();
}
#deinfie FOR(i,a,b) for (int i = a; i <= b; i++)
bool check(vector < int > h, int x) { //check that whether the spell level x can do
int prev = 0, n = h.size();
//prev store the height of the previous tree
FOR (i, 0, n - 1) {
//if we can make tree[i] higher than previous one
if (h[i] + x <= prev) return false;
//reset the value of prev for the next step
prev = max(prev + 1, h[i] - x);
}
return true;
}
int minLevel(vector < int > heights) {
int l = 0, r = 1000000000, res = -1;
//binary search
while (l <= r) {
int m = (l + r) / 2;
if (check(heights, m)) {
//if spell level m can do it, we search in range [l, m - 1]
res = m;
r = m - 1;
}
else l = m + 1;
}
return res;
}
/*
dp[i],i表示状态,即使用了原密码的哪几位数据,然后维护一个前几位比原密码大的,前几位与原密码相等,比原密码小的三个数,那么。
假设状态p能转移到i,那么有
如果p的前几位存在与原密码相等,那么,如果新加进来那个数符合条件,且新加进来这个数与原密码相应的位置上的数相等,那么i的与原密码相等的值更新,如果比原密码相应位置上的数大,更新i的比原密码大的值,否则更新i的比原密码小的值。
否则,通过p的比原密码大的值和比原密码小的值更新i的大值和小值。
*/
typedef struct
{
long long big;
long long equal;
long long small;
}DP;
class KingdomAndPassword
{
public:
DP dp[(1<<16)+5];
int count[(1<<16)+5];
long long ten[17];
long long newPassword(long long oldPassword, vector<int> restrictedDigits)
{
int i,j,n,t,tag,p;
int old[20];
long long pp;
pp=oldPassword;
n=0;
while(oldPassword)
{
old[n++]=oldPassword%10;
oldPassword/=10;
}
oldPassword=pp;
for (i=0;i<n/2;i++)
{
t=old[i];
old[i]=old[n-i-1];
old[n-i-1]=t;
}
ten[0]=1;
for (i=1;i<=n;i++)
{
ten[i]=ten[i-1]*10;
}
memset(count,0,sizeof(count));
for (i=0;i<(1<<n);i++)
{
for (j=0;j<n;j++)
{
if ((i & (1<<j))!=0) count[i]++;
}
}
dp[0].big=0;
dp[0].small=0;
dp[0].equal=0;
for (i=1;i<(1<<n);i++)
{
dp[i].small=0;
dp[i].big=INF;
for (j=0;j<n;j++)
{
if ((i & (1<<j))==0) continue;
tag=old[j];
if (restrictedDigits[count[i]-1]==tag) continue;
p=i & (~(1<<j));
if (tag==old[count[i]-1] && count[i]==1)
{
dp[i].equal=tag*ten[n-count[i]];
continue;
}
if (count[i]==1)
{
if (tag>old[count[i]-1]) dp[i].big=min(dp[i].big,tag*ten[n-count[i]]);
if (tag<old[count[i]-1]) dp[i].small=max(dp[i].small,tag*ten[n-count[i]]);
continue;
}
if (dp[p].equal!=0)
{
if (tag>old[count[i]-1]) dp[i].big=min(dp[i].big,dp[p].equal+tag*ten[n-count[i]]);
if (tag==old[count[i]-1]) dp[i].equal=dp[p].equal+tag*ten[n-count[i]];
if (tag<old[count[i]-1]) dp[i].small=max(dp[i].small,dp[p].equal+tag*ten[n-count[i]]);
}
else
{
if (dp[p].big!=INF) dp[i].big=min(dp[i].big,dp[p].big+tag*ten[n-count[i]]);
if (dp[p].small!=0) dp[i].small=max(dp[i].small,dp[p].small+tag*ten[n-count[i]]);
}
}
}
if (dp[(1<<n)-1].equal!=0) return dp[(1<<n)-1].equal;
if (dp[(1<<n)-1].small==0 && dp[(1<<n)-1].big==INF) return -1;
if (dp[(1<<n)-1].small!=0 && dp[(1<<n)-1].big!=INF)
{
return oldPassword-dp[(1<<n)-1].small<=dp[(1<<n)-1].big-oldPassword?dp[(1<<n)-1].small:dp[(1<<n)-1].big;
}
if (dp[(1<<n)-1].small!=0) return dp[(1<<n)-1].small;
return dp[(1<<n)-1].big;
}
};