CERC2013(C)_Magical GCD

题意是这样的，给你一个序列a[i]，需要你选一段连续的序列a[i]到a[j]，使得长度乘以这个段的gcd最大。

一开始总是以为是各种神奇的数据结构，诶，后来才发现，机智才是王道啊。

可以这样考虑，每次我对于某一个数，保存若干个值，以i为右端点的区间且gcd为某一值的时候这个区间最大的左端点位置是哪里？

但是你也许会认为这样做状态会不会有点多？更新是不是n方的呢？

其实不是的，因为我们可以从左到右来递推。

什么意思呢？对于每一个数，它与前面构成的gcd一定不会太多（约数肯定不会太多），所以我们最多也只需要保存每一个约数为gcd的时候左边最远能够拓展的位置。

其实远远不要保存每一个约数的位置，因为实际上很多的约数都不是gcd，这样我们就可以由左边的所有状态和右边的一个gcd一次来递推了。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#define maxn 100100
using namespace std;
typedef long long ll;
 
struct node{
    ll num,pos;
}cur;
 
ll gcd(ll x,ll y) { return y==0?x:gcd(y,x%y); }
 
ll a[maxn],n,m,k,t,ans;
vector<node> f[maxn];
 
int main()
{
    cin>>t;
    while (t--)
    {
        cin>>n;
        for (ll i=1; i<=n; i++) cin>>a[i],f[i].clear();
        ans=max(n,a[1]);
        cur.num=a[1],cur.pos=1;
        f[1].push_back(cur);
        for (int i=2; i<=n; i++)
        {
            for (unsigned j=0; j<f[i-1].size(); j++)
            {
                cur.num=gcd(a[i],f[i-1][j].num);
                cur.pos=f[i-1][j].pos;
                bool flag=false;
                for (unsigned k=0; k<f[i].size(); k++)
                {
                    if (f[i][k].num==cur.num)
                    {
                        f[i][k].pos=min(f[i][k].pos,cur.pos);
                        flag=true;
                        break;
                    }
                }
                if (!flag) f[i].push_back(cur);
            }
            cur.num=a[i];
            cur.pos=i;
            bool flag=false;
            for (unsigned k=0; k<f[i].size(); k++)
            {
                if (f[i][k].num==cur.num)
                {
                    f[i][k].pos=min(f[i][k].pos,cur.pos);
                    flag=true;
                    break;                    
                }
            }
            if (!flag) f[i].push_back(cur);
 
            for (unsigned j=0; j<f[i].size(); j++)
                ans=max(ans,f[i][j].num*(i-f[i][j].pos+1));
        }
        cout<<ans<<endl;
    }
    return 0;
}