Codeforces 1325 E. Ehab‘s REAL Number Theory Problem —— 思维，bfs最小环，有丶东西

This way

题意：

问你最少选择多少个数使得它们的笛卡尔积是完全平方数。每个数不会超过7个因子

题解：

每个数不会超过7个因子也就是说不会超过两个质因子，当有3个质因子的时候，变会至少有$2^3$种组合可能，与题意有悖。
那么我们将每个数的奇数次质因子处理出来，分为以下三种情况：
1.有0个奇数次质因子，此时这个数就是完全平方数，直接输出1
2.有2个奇数次质因子，此时将这两个点连边
3.有1个奇数次质因子，此时我们可以找一个非素数（我选择1）连边
最终只需要找最小环即可。使用bfs找最小环，首先将大小为2的环判掉，因为这个比较难搞，之后的话就记录从哪里转移过来的，如果下一个点是这个点的话就continue掉即可。
但是此时会出现一种情况：

从这里开始的时候，我们很难找到下面这个环。
但是我们又可以发现，两个相连的数不会都大于1000，也就是说每个环里面一定有至少一个1~1000的数。接下来我们枚举1~1000作为起点，然后做一遍即可。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
const int inf=1e9;
#define ll long long 
#define pa pair<int,int>
vector<int>son[N],vec;
int a[N];
int cnt,p[N],np[N],dis[N];
int hav[N],vis[N],ans=inf;
vector<int>used;
void bfs(int s){
    queue<pa>Q;
    Q.push({s,0});
    vis[s]=1;
    while(!Q.empty()){
        int u=Q.front().first,fa=Q.front().second;Q.pop();
        used.push_back(u);
        for(int ne:son[u]){
            if(ne==fa)continue;
            if(vis[ne]){
                ans=min(ans,dis[ne]+dis[u]+1);
                continue;
            }
            vis[ne]=1;
            dis[ne]=dis[u]+1;
            Q.push({ne,u});
        }
    }
}
map<pa,bool>mp;
int main()
{
    for(ll i=2;i<N;i++){
        if(!np[i]){
            p[++cnt]=i;
            for(ll j=i*i;j<N;j+=i)
                np[j]=1;
        }
    }
    
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        int v=sqrt(a[i]);
        if(a[i]==v*v||a[i]==(v+1)*(v+1)||a[i]==(v-1)*(v-1))return 0*printf("1\n");
        int x=a[i];
        for(int j=1;j<=cnt&&p[j]<=sqrt(x)+1;j++){
            if(!np[x])
                break;
            int f=0;
            while(x%p[j]==0)
                x/=p[j],f^=1;
            if(f)
                vec.push_back(p[j]);
        }
        if(!np[x]&&x!=1)
            vec.push_back(x);
        if(vec.size()==0)return 0*printf("1\n");
        else if(vec.size()==1){
            if(hav[vec[0]]&1)
                ans=min(ans,2);
            hav[vec[0]]|=1;
            hav[1]=2;
            son[1].push_back(vec[0]),son[vec[0]].push_back(1);
        }
        else {
            if(mp.count({vec[0],vec[1]}))ans=min(ans,2);
            mp[{vec[0],vec[1]}]=mp[{vec[1],vec[0]}]=1;
            son[vec[0]].push_back(vec[1]),son[vec[1]].push_back(vec[0]);
            hav[vec[0]]|=2;
            hav[vec[1]]|=2;
        }
        vec.clear();
    }
    for(int i=1;i<=1000;i++){
        if(!(hav[i]&2))continue;
        bfs(i);
        for(int j:used)
            vis[j]=dis[j]=0;
        used.clear();
    }
    printf("%d\n",ans-inf?ans:-1);
    return 0;
}