QDU_CEF（补）

C - Arthur and Table

Arthur has bought a beautiful big table into his new flat. When he came home, Arthur noticed that the new table is unstable.

In total the table Arthur bought has n legs, the length of the i-th leg is li.

Arthur decided to make the table stable and remove some legs. For each of them Arthur determined number di — the amount of energy that he spends to remove the i-th leg.

A table with k legs is assumed to be stable if there are more than half legs of the maximum length. For example, to make a table with 5 legs stable, you need to make sure it has at least three (out of these five) legs of the maximum length. Also, a table with one leg is always stable and a table with two legs is stable if and only if they have the same lengths.

Your task is to help Arthur and count the minimum number of energy units Arthur should spend on making the table stable.

Input

The first line of the input contains integer n (1 ≤ n ≤ 105) — the initial number of legs in the table Arthur bought.

The second line of the input contains a sequence of n integers li (1 ≤ li ≤ 105), where li is equal to the length of the i-th leg of the table.

The third line of the input contains a sequence of n integers di (1 ≤ di ≤ 200), where di is the number of energy units that Arthur spends on removing the i-th leg off the table.

Output

Print a single integer — the minimum number of energy units that Arthur needs to spend in order to make the table stable.

Examples

Input

2
1 5
3 2

Output

2

Input

3
2 4 4
1 1 1

Output

0

Input

6
2 2 1 1 3 3
4 3 5 5 2 1

Output

8

题意：将某些桌子腿砍掉，使得当前长度最大的桌子腿的数量大于总数量的一半

思路：我们可以枚举所有的桌子腿，找出某一个长度是最适合的，使得代价最小，我们可以想到把大于当前枚举桌子腿的数量给去掉，我们假设我们保留了该长度的桌子腿的数量为x，那么小于该长度的的桌子腿数量最多为x-1。我们可以枚举保留的长度，因为代价最大为200，我们记录下每个代价的个数然后去找

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#define MAX 100005

typedef long long ll;
using namespace std;
int a[MAX];

struct node
{
	int len,val;
}p[MAX];
bool cmp(node x,node y)
{
	return x.len<y.len;
}
int sumlen[MAX],sumcost[MAX];
int vis1[MAX],vis2[MAX];
int summ[205];
int main()
{
	int n;
	cin>>n;
	for(int t=1;t<=n;t++)
	{
		scanf("%d",&p[t].len);
		vis1[p[t].len]++;
	}
	for(int t=1;t<=n;t++)
	{
		scanf("%d",&p[t].val);
		sumcost[p[t].len]+=p[t].val;
	}
	sort(p+1,p+n+1,cmp);

	int maxn1=p[n].len;

	for(int t=1;t<=maxn1;t++)
	{
		sumcost[t]+=sumcost[t-1];
	}

	int ans;
	int minn=0x3f3f3f3f;
	for(int t=1;t<=n;t++)
	{
		int left=vis1[p[t].len]-1;
		ans=sumcost[maxn1]-sumcost[p[t].len];
		for(int j=200;j>=1;j--)
		{
			if(vis2[j]>0)
			{
				if(left>=vis2[j])
				{
					left-=vis2[j];
				}
				else
				{
					ans+=j*(vis2[j]-left);
					left=0;
				}
			}
		}
		minn=min(minn,ans);
		vis2[p[t].val]++;
	}

	cout<<minn<<endl;

	return 0;
}

E - Case of Matryoshkas

Andrewid the Android is a galaxy-famous detective. He is now investigating the case of vandalism at the exhibition of contemporary art.

The main exhibit is a construction of n matryoshka dolls that can be nested one into another. The matryoshka dolls are numbered from 1 to n. A matryoshka with a smaller number can be nested in a matryoshka with a higher number, two matryoshkas can not be directly nested in the same doll, but there may be chain nestings, for example, 1 → 2 → 4 → 5.

In one second, you can perform one of the two following operations:

• Having a matryoshka a that isn't nested in any other matryoshka and a matryoshka b, such that b doesn't contain any other matryoshka and is not nested in any other matryoshka, you may put a in b;
• Having a matryoshka a directly contained in matryoshka b, such that b is not nested in any other matryoshka, you may get a out of b.

According to the modern aesthetic norms the matryoshka dolls on display were assembled in a specific configuration, i.e. as several separate chains of nested matryoshkas, but the criminal, following the mysterious plan, took out all the dolls and assembled them into a single large chain (1 → 2 → ... → n). In order to continue the investigation Andrewid needs to know in what minimum time it is possible to perform this action.

Input

The first line contains integers n (1 ≤ n ≤ 105) and k (1 ≤ k ≤ 105) — the number of matryoshkas and matryoshka chains in the initial configuration.

The next k lines contain the descriptions of the chains: the i-th line first contains number mi (1 ≤ mi ≤ n), and then mi numbers ai1, ai2, ..., aimi — the numbers of matryoshkas in the chain (matryoshka ai1 is nested into matryoshka ai2, that is nested into matryoshka ai3, and so on till the matryoshka aimi that isn't nested into any other matryoshka).

It is guaranteed that m1 + m2 + ... + mk = n, the numbers of matryoshkas in all the chains are distinct, in each chain the numbers of matryoshkas follow in the ascending order.

Output

In the single line print the minimum number of seconds needed to assemble one large chain from the initial configuration.

Examples

Input

3 2
2 1 2
1 3

Output

1

Input

7 3
3 1 3 7
2 2 5
2 4 6

Output

10

Note

In the first sample test there are two chains: 1 → 2 and 3. In one second you can nest the first chain into the second one and get 1 → 2 → 3.

In the second sample test you need to disassemble all the three chains into individual matryoshkas in 2 + 1 + 1 = 4 seconds and then assemble one big chain in 6 seconds.

这道题应该是这次最简单的签到题，但是我读错了题意，我以为是接的时候可以接一个链，但是却是只能单哥的接

思路：找出1连续的链不拆，其余都拆，一个记录拆的总时间，一个记录拆出来多少链，这样最后连的时候是总链数-1

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#define MAX 100005

typedef long long ll;
using namespace std;
int a[MAX];

int main()
{
	int n,m;
	cin>>n>>m;
	int s=0;
	int cnt;
	int sum=0;
	for(int t=1;t<=m;t++)
	{
		int x;
		cin>>x;
		cnt=0;
		for(int j=1;j<=x;j++)
		{
			scanf("%d",&a[j]);
		}
		for(int j=2;j<=x;j++)
		{
	           if(a[j]==j)
	           {
	           	 continue;
			   }
			   else
			   {
			   	s++;
			   	cnt++;
			   }
		}
		sum+=cnt+1;

	}
	cout<<s+sum-1<<endl;
	return 0;
}

F - Amr and Chemistry

Amr loves Chemistry, and specially doing experiments. He is preparing for a new interesting experiment.

Amr has n different types of chemicals. Each chemical i has an initial volume of ailiters. For this experiment, Amr has to mix all the chemicals together, but all the chemicals volumes must be equal first. So his task is to make all the chemicals volumes equal.

To do this, Amr can do two different kind of operations.

• Choose some chemical i and double its current volume so the new volume will be 2ai
• Choose some chemical i and divide its volume by two (integer division) so the new volume will be 

Suppose that each chemical is contained in a vessel of infinite volume. Now Amr wonders what is the minimum number of operations required to make all the chemicals volumes equal?

Input

The first line contains one number n (1 ≤ n ≤ 105), the number of chemicals.

The second line contains n space separated integers ai (1 ≤ ai ≤ 105), representing the initial volume of the i-th chemical in liters.

Output

Output one integer the minimum number of operations required to make all the chemicals volumes equal.

Examples

Input

3
4 8 2

Output

2

Input

3
3 5 6

Output

5

Note

In the first sample test, the optimal solution is to divide the second chemical volume by two, and multiply the third chemical volume by two to make all the volumes equal 4.

In the second sample test, the optimal solution is to divide the first chemical volume by two, and divide the second and the third chemical volumes by two twice to make all the volumes equal 1.

题意比较好理解

题意：对每个数进行*2或/2的操作，使得最后所有的数都是相等的，求最少的操作次数

思路：我们可以枚举可能是从所有的数，分别记录一下把这个数能到达的数及到达需要的次数记录下来，去找的时候

注意奇偶性，偶数可以×2除2操作，奇数只能乘，最后枚举可以到达的数中次数最小的即可

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#define MAX 100005

typedef long long ll;
using namespace std;
int a[MAX];
int sum[MAX];
int num[MAX];
int main()
{
	int n;
	cin>>n;
	memset(sum,0,sizeof(sum));
	memset(num,0,sizeof(num));
	for(int t=1;t<=n;t++)
	{
		scanf("%d",&a[t]);
	}
	int maxn=100000;
	for(int t=1;t<=n;t++)
	{
		    int k = a[t];
            int pre = 0;
            while(k)
			{
                int s = 0;
                while(k% 2 == 0)
				{
                    k/= 2;
                    s++;
                }
                int y = k;
                int x1 = 0;
                while(y <= maxn)
				{
                    num[y]++;
                    sum[y]+=pre+abs(s - x1);
                    x1++;
                    y*=2;
                }
                pre+=s+1;
                k/= 2;
            }
	}
	int minn=0x3f3f3f3f;

	for(int t=1;t<=maxn;t++)
	{
		if(num[t]==n)
		minn=min(minn,sum[t]);
	}
	cout<<minn<<endl;

	return 0;
}