Codeforces1154G-Minimum Possible LCM（贪心）

原题链接：http://codeforces.com/problemset/problem/1154/G

题目原文：

G. Minimum Possible LCM

time limit per test

4 seconds

memory limit per test

1024 megabytes

input

standard input

output

standard output

You are given an array aa consisting of nn integers a1,a2,…,ana1,a2,…,an.

Your problem is to find such pair of indices i,ji,j (1≤i<j≤n1≤i<j≤n) that lcm(ai,aj)lcm(ai,aj) is minimum possible.

lcm(x,y)lcm(x,y) is the least common multiple of xx and yy (minimum positive number such that both xx and yy are divisors of this number).

Input

The first line of the input contains one integer nn (2≤n≤1062≤n≤106) — the number of elements in aa.

The second line of the input contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤1071≤ai≤107), where aiai is the ii-th element of aa.

Output

Print two integers ii and jj (1≤i<j≤n1≤i<j≤n) such that the value of lcm(ai,aj)lcm(ai,aj) is minimum among all valid pairs i,ji,j. If there are multiple answers, you can print any.

Examples

input

Copy

5
2 4 8 3 6

output

Copy

1 2

input

Copy

5
5 2 11 3 7

output

Copy

2 4

input

Copy

6
2 5 10 1 10 2

output

Copy

1 4

题目大意：

        求最小公倍数最小的一组。

解题思路：

        一开始的思路是，先将数组排序，先把a[0],a[1]当成最小的一组，min = LCM，然后遍历一遍看是否有相同的一组且优于min。然后for (i = 0; a[i] < min && i < n; i++)遍历找最优解。

#include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;

const int N = int(2e6 + 5);
const long long INF = 0x3f3f3f3f3f3f3f3fLL;

typedef long long Long;
typedef pair<Long, Long> Node;

bool cmp(const Node &a, const Node &b)
{
	return a.first < b.first || a.first == b.first && a.second < b.second;
}

int n;
Node a[N];

template<typename T>
T gcd(T a, T b)
{
	return b == 0 ? a : gcd(b, a % b);
}

template<typename T>
T lcm(T a, T b)
{
	return a / gcd(a, b) * b;
}

int main()
{
	int i, j, flaga, flagb;
	Long minv;
	while (scanf("%d", &n) != EOF)
	{
		minv = INF;
		for (i = 0; i < n; i++)
		{
			scanf("%I64d", &a[i].first);
			a[i].second = i + 1;
		}
		sort(a, a + n, cmp);
		minv = min(minv, lcm(a[0].first, a[1].first));
		flaga = a[0].second;
		flagb = a[1].second;
		for (i = 1; i < n; i++)
		{
			if (a[i].first == a[i - 1].first && a[i].first < minv)
			{
				minv = a[i].first;
				flaga = a[i - 1].second;
				flagb = a[i].second;
				break;
			}
		}
		for (i = 0; a[i].first < minv && i < n; i++)
		{
			for (j = i + 1; a[j].first < minv && j < n; j++)
			{
				if (lcm(a[i].first, a[j].first) < minv)
				{
					minv = lcm(a[i].first, a[j].first);
					flaga = a[i].second;
					flagb = a[j].second;
				}
			}
		}
		// printf("%I64d\n", minv);
		printf("%d %d\n", min(flaga, flagb), max(flagb, flaga));
	}
	return 0;
}

 这样做能过掉64组数据，显然时间复杂度不是最优的。

        正确的思路：定义 a[i] 用于定义 i 在数组中出现的index，这样可以方便只遍历 i 的倍数。具体键代码。

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = int(1e7 + 5);
const long long INF = 0x3f3f3f3f3f3f3f3fLL;

typedef long long LL;

template<typename T>
T gcd(T a, T b)
{
	return b == 0 ? a : gcd(b, a % b);
}

template<typename T>
T lcm(T a, T b)
{
	return a / gcd(a, b) * b;
}

int n;
int p[N];

void init()
{
	memset(p, 0, sizeof(p));
}

int main()
{
	int i, j, x, flaga, flagb;
	LL minv;
	while (scanf("%d", &n) != EOF)
	{
		init();
		minv = INF;
		for (i = 1; i <= n; i++)
		{
			scanf("%d", &x);
			if (p[x] && x < minv)
			{
				minv = x;
				flaga = p[x];
				flagb = i;
			}
			p[x] = i;
		}
		for (i = 1; i < N && i < minv; i++)
		{
			LL v =  0;
			int pos;
			for (j = i; j < N && j < minv; j += i)
			{
				if (p[j])
				{
					if (v == 0)
					{
						v = j;
						pos = p[j];
					}
					else if (v / i * j < minv)
					{
						minv = v / i * j;
						flaga = pos;
						flagb = p[j];
					}
					else break;
				}
			}
		}
		if (flaga > flagb) swap(flaga, flagb);
		printf("%d %d\n", flaga, flagb);
	}
	return 0;
}