Codeforces Round #731 (Div. 3) F. Array Stabilization (GCD version)

Posted 2021-08-09 yueshehanjiang

F. Array Stabilization (GCD version)

题意：

给t组样例
(t <= 1e4)
每组样例给n
a[1] , a[2] , ...... a[n] 
(a[i] <= 1e6 , t组样例n的总和 <= 2e5)

定义一个新数组b[]数组
b[i]等于gcd(a[i],a[(i+1)%n]) [ 1 <= i <= n ]
每一次操作可以把b复制给a
然后重复上述过程

问最少操作多少次使得a数组中的所有数都相等

思路：

因为涉及到环
我们可以在a数组之后在加一个a数组
即在输入的时候 a[i+n] = a[i]
这样可以不用考虑(i + 1) % n 的问题

可以发现

第1次操作之后
b[1] = gcd(a[1],a[2])
第2次操作之后
b[1] = gcd(a[1],a[2],a[3])
........
第n-1次操作之后
b[1] = gcd(a[1],a[2],a[3],.....a[n])

也就是说 经过x-1次操作之后
b[i] = gcd(a[i],a[i+1],a[i+2],......a[i+x])

也就是说  最多n-1次操作之后
一定可以使得a数组中的数都相等

那么很明显可以二分操作
假设当前操作为mid
如果在mid次操作中可以使得所有a[i]都相等
说明可以把mid变小
即r = mid 
否则可以让
l = mid 

查询区间最大公约数可以线段树或者st表或者树状数组

我这里用的是线段树

线段树时间复杂度nlogn
二分时间复杂度logn

所以整体时间复杂度nlognlogn

这题给了4s

所以是可以过的

一点题外话
最后25min想到了二分
但是不知道怎么查询区间最大公约数
最后5min想到了线段树
可惜为时已晚

时间复杂度：O nlognlogn

#include<bits/stdc++.h>
#define fer(i,a,b) for(re i = a ; i <= b ; ++ i)
#define re register int
#define pll pair<int,int> 
#define x first 
#define y second 
#define sf(x) scanf("%d",&x)
#define sfl(x) scanf("%lld",&x)
typedef long long ll ;
using namespace std;
const int N =  1e6 + 10 , M = 1010 , inf = 0x3f3f3f3f , mod = 1e9 + 7 ;
int t ;
int n ;
int a[N] ;
int s[N] ;

struct Node
{
    int l, r;
    ll d ;
}tr[N * 4];

ll gcd(ll a, ll b)
{
    return b ? gcd(b, a % b) : a;
}

void push_up(int u)
{
    tr[u].d = gcd(tr[u << 1].d,tr[u << 1 | 1].d) ;
}

void build(int u , int l , int r)
{
    if(l == r)
    {
        tr[u] = {l,r,a[l]} ;
        return ;
    }
    else
    {
        tr[u] = {l,r} ;
        int mid = r + l >> 1 ;
        build(u << 1 , l , mid) ;
        build(u << 1 | 1 , mid + 1 , r) ;
        push_up(u) ;
    }
}

ll query(int u , int l , int r)
{
    if(tr[u].l >= l && tr[u].r <= r)
    {
        return tr[u].d ;
    }
    
    ll res = 0 ;
    int mid = tr[u].l + tr[u].r >> 1 ;
    
    if(l <= mid) res = gcd(res,query(u << 1 , l , r)) ;
    if(r > mid) res = gcd(res,query(u << 1 | 1 , l , r)) ;
    
    return res ;
}

bool check(int mid)
{
    map<int,int> q ;
    
    for(int i = 1 ; i <= n ; i ++)
    {
        int l = i , r = i + mid ;
        q[abs(query(1,l,r))] ++ ;
    }
    
    return q.size() == 1 ;
}

int main()
{
    cin >> t ;
    
    while(t--)
    {
        cin >> n ;
        
        fer(i,1,n)
        {
            sf(a[i]) ;
            a[i + n] = a[i] ;
        }
        
        build(1, 1, 2 * n);
        
        int l = 0 , r = n - 1 ;
        
        while(l < r)
        {
            int mid = r + l >> 1 ;
            if(check(mid)) r = mid ;
            else l = mid + 1 ;
        }
        
        cout << l << "\\n" ;
    }
    return 0;
}