Codeforces 1154G Minimum Possible LCM

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

题目大意：

　　给定n个数，在这些数中选2个数，使这两个数的最小公倍数最小，输出这两个数的下标（如果有多组解，任意输出一组即可）。

分析：

　　直接2个循环两两配对一下肯定要超时的，这里可以考虑枚举公因数，因为LCM是与最大公因数相关的，如果我们枚举了所有的公因数，那么我们就枚举了所有的LCM。

　　对于每一个公因数d，含有因子d的数从小到大排序为x₁，x₂，x₃……x_n，共有n个。

　　首先计算一下前两个数的GCD，有2种可能：

　　1：如果GCD(x₁，x₂) == d，那就没必要再计算GCD(x_i，x_j) (1 < i < j <= n)了，只要计算一下LCM(x₁，x₂)即可，因为如果GCD(x_i，x_j) == d，LCM(x_i，x_j)肯定大于LCM(x₁，x₂)；如果GCD(x_i，x_j) == d_ > d，LCM(x_i，x_j)有可能小于LCM(x₁，x₂)，不过这个等d枚举到了d_再算也是一样的。

　　2：如果GCD(x₁，x₂) == d_ > d，没必要再计算LCM(x₁，x₂)，可以等到枚举到d_再计算，也没必要再计算GCD(x_i，x_j)，因为如果GCD(x_i，x_j) == d，LCM(x_i，x_j) = x_i * x_j / d > x₁ * x₂ / d > x₁ * x₂ / d_ = LCM(x₁，x₂)；如果GCD(x_i，x_j) > d，也不需要。

代码如下：

 #include <bits/stdc++.h>
 using namespace std;

 #define Rep(i, n) for (int i = 0; i < (n); ++i)
 #define rRep(i, n) for (int i = (n) - 1; i >= 0; --i)
 #define For(i, s, t) for (int i = (s); i <= (t); ++i)
 #define rFor(i, t, s) for (int i = (t); i >= (s); --i)
 #define foreach(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
 #define rforeach(i, c) for (__typeof(c.rbegin()) i = c.rbegin(); i != c.rend(); ++i)

 #define INIT() std::ios::sync_with_stdio(false);std::cin.tie(0);
 #define pr(x) cout << #x << " = " << x << "  "
 #define prln(x) cout << #x << " = " << x << endl
 #define EL() printf("\n")
 #define GL(s) getline(cin, (s))
 #define SHOW_VECTOR(v) {std::cerr << #v << "\t:"; for(const auto& xxx : v){std::cerr << xxx << " ";} std::cerr << "\n";}
 #define SHOW_MAP(v) {std::cerr << #v << endl; for(const auto& xxx: v){std::cerr << xxx.first << " " << xxx.second << "\n";}}

 template<typename T1, typename T2>
 istream &operator>>(istream &in, pair<T1, T2> &p) {
     in >> p.first >> p.second;
     return in;
 }

 template<typename T>
 istream &operator>>(istream &in, vector<T> &v) {
     for (auto &x: v)
         in >> x;
     return in;
 }

 template<typename T1, typename T2>
 ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
     out << "[" << p.first << ", " << p.second << "]" << "\n";
     return out;
 }

 #define LOWBIT(x) ((x)&(-x))

 #define ALL(x) x.begin(),x.end()

 #define ms0(a) memset(a,0,sizeof(a))
 #define msI(a) memset(a,inf,sizeof(a))
 #define msM(a) memset(a,-1,sizeof(a))

 #define MP make_pair
 #define PB push_back
 #define ft first
 #define sd second

 inline int gc(){
     static const int BUF = 1e7;
     static char buf[BUF], *bg = buf + BUF, *ed = bg;

     if(bg == ed) fread(bg = buf, , BUF, stdin);
     return *bg++;
 } 

 inline int ri(){
     int x = , f = , c = gc();
     for(; c<||c>; f = c=='-'?-:f, c=gc());
     for(; c>&&c<; x = x* + c - , c=gc());
     return x*f;
 }

 typedef long long LL;
 typedef pair< int, int > PII;
 typedef pair< LL, LL > PLL;
 typedef map< int, int > MII;
 const double EPS = 1e-;
 const double PI = acos(-1.0);
 const LL mod = 1e9 + ;
 const LL inf = 0x7fffffff;
 const LL infLL = 0x7fffffffffffffffLL;
 const LL ONE = ;
 const int maxN = 1e7 + ;

 struct A{
     int pos;
     int cnt = ;
 };

 LL n, ret = infLL;
 A a[maxN];
 PLL ans;

 inline LL gcd(LL x,LL y){
     LL t;
     if(!(x && y))return -;
     while(y){
         t=x%y;
         x=y;
         y=t;
     }
     return x;
 }

 inline LL lcm(LL x,LL y){
     LL t = gcd(x,y);
     if(t == -)return -;
     return x/t*y;
 }

 int main(){
     INIT();
     cin >> n;
     For(i, , n) {
         LL x;
         cin >> x;
         if(a[x].cnt == ) {
             a[x].pos = i;
             ++a[x].cnt;
         }
         else if(a[x].cnt == ) {
             if(x < ret) {
                 ret = x;
                 ans = MP(a[x].pos, i);
             }
             ++a[x].cnt;
         }
     }

     // Enumerate common factor d
     For(d, , maxN) {
         LL x1 = ;
         for(int x2 = d; x2 < maxN; x2 += d){
             if(!a[x2].cnt) continue;
             if(!x1) x1 = x2;
             else{
                 // x1,x2为前2个有公因子d的数
                 if(gcd(x1, x2) == d){
                     LL tmp = x2 / d * x1;
                     if(tmp < ret){
                         ret = tmp;
                         ans = MP(a[x2].pos, a[x1].pos);
                     }
                 }
                 break;
             }
         }
     }

     if(ans.ft > ans.sd) swap(ans.ft, ans.sd);
     cout << ans.ft << " " << ans.sd;
     return ;
 }