(Codeforces Round #413) Field expansion (搜索+思维优化)

Field expansion

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

In one of the games Arkady is fond of the game process happens on a rectangular field. In the game process Arkady can buy extensions for his field, each extension enlarges one of the field sizes in a particular number of times. Formally, there are n extensions, the i-th of them multiplies the width or the length (by Arkady's choice) by ai. Each extension can't be used more than once, the extensions can be used in any order.

Now Arkady's field has size h × w. He wants to enlarge it so that it is possible to place a rectangle of size a × b on it (along the width or along the length, with sides parallel to the field sides). Find the minimum number of extensions needed to reach Arkady's goal.

Input

The first line contains five integers a, b, h, w and n (1 ≤ a, b, h, w, n ≤ 100 000) — the sizes of the rectangle needed to be placed, the initial sizes of the field and the number of available extensions.

The second line contains n integers a1, a2, ..., an (2 ≤ ai ≤ 100 000), where ai equals the integer a side multiplies by when the i-th extension is applied.

Output

Print the minimum number of extensions needed to reach Arkady's goal. If it is not possible to place the rectangle on the field with all extensions, print -1. If the rectangle can be placed on the initial field, print 0.

Examples

input

3 3 2 4 4
2 5 4 10

output

1

input

3 3 3 3 5
2 3 5 4 2

output

0

input

5 5 1 2 3
2 2 3

output

-1

input

3 4 1 1 3
2 3 2

output

3

Note

In the first example it is enough to use any of the extensions available. For example, we can enlarge h in 5 times using the second extension. Then h becomes equal 10 and it is now possible to place the rectangle on the field.

只要h或者w大于a或者b即可，组合方式有两种，h> a&&w> b或者h> b&&w> a，搜索的时候每个值乘给谁又有两种情况，故普通搜索最终复杂度为 O(2^ 100000 )，但是假若输入值均为2，故  log  2  100000 ≈ 17  ，即复杂度实际应该在  O( 2^34) ，但是依旧可怕，随即我们想到，如果剩余的值都为最小值2的话，那么我们只要把h,w都一直到乘到比a,b大就可以了，对于大于等于3的值，最高在O(2^22)的复杂度内就完成了。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstring>
#include<string>
#include<vector>
#include<cmath>
#include<map>
using namespace std;
typedef long long ll;
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn = 2e6+5;
const int ff = 0x3f3f3f3f;

int a,b,h,w,n;
ll c[maxn];

bool cmp(int x,int y)
{
	return x> y;
}

int dfs(ll p,ll q,int x)
{
	if(p>= a&&q>= b)
		return x-1;
	if(x == n+1)
		return -1;
	
	if(c[x] == 2)//特判
	{
		while(x<= n&&p< a)
			p*= 2,x++;
		while(x<= n&&q< b)
			q*= 2,x++;
		if(p< a||q< b)
			return -1;
		return x-1;
	}
	
	int s1 = -1,s2 = -1;
	if(p< a)//只有p比a小的时候才对p乘继续搜
		s1 = dfs(p*c[x],q,x+1);
	if(q< b)
		s2 = dfs(p,q*c[x],x+1);
	
	if(s1 == -1||s2 == -1)
		return max(s1,s2);
	else
		return min(s1,s2);
}

int main()
{
	cin>>a>>b>>h>>w>>n;
	for(int i = 1;i<= n;i++)
		scanf("%I64d",&c[i]);
	sort(c+1,c+n+1,cmp);
	
	int ans1 = dfs(h,w,1);
	int ans2 = dfs(w,h,1);
	
	if(ans1 == -1||ans2 == -1)
		cout<<max(ans1,ans2)<<endl;
	else
		cout<<min(ans1,ans2)<<endl;
	
	return 0;
}