乘除后判断，分解质因数，每个计算器对应一个优先队列

3490.小平方(操作后比较，能乘就不要除，精度很可怕)

#include <bits/stdc++.h>
using namespace std;
#define int long long int
int n;
int fun(int x){//平方后除以n 余数小于n的一半
   // return x*x%n<n/2;
   
    // double y=x*x%n;
    // return y-(n*1.0/2)<1e-2;//同样不ok
 
    return x*x%n*2<n;
}
signed main(){//1~n-1
    scanf("%d",&n);
    int cnt=0;
    for(int i=1;i<n;i++){
        if(fun(i))cnt++;
    }
    printf("%d",cnt);
    return 0;
}

3491.完全平方数（质因子分解，各质因子的幂次

对n分解质因数，n的每个质因数的幂次都应该是偶数，不是就要靠x补上

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

const int N=1e6+5;
int cnt;//质因子个数
int num[N];//num[i]代表质因子prime[i]的幂次
int prime[N];//存放从2开始的所有的质因子
int n;
void fun(int x){
	for(int i=2;i*i<=x;i++){
		if(x%i==0){
			prime[cnt]=i;
			while(x%i==0){
				x/=i;
				num[cnt]++;
			}
			cnt++;
		}
	}
	if(x!=1){//如果x已经被分解完了，最后x应该是1，而不是0，所以应该判断是否为1
		prime[cnt]=x;
		num[cnt]++;
	}
}
signed main(){
    scanf("%lld",&n);
    fun(n);
    int res=1;
    for(int i=0;i<=cnt;i++){//n分解出来的所有质因子
        if(num[i]&1){
            res*=prime[i];
        }
    }
    printf("%lld",res);
    return 0;
}

求质因子个数

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

const int N=1e6+5;
signed main(){
    int n;
    cin>>n;
    if(n==1){
        cout<<"0";
        return 0;
    }
    int res=0;
    int x=n;
    for(int i=2;i*i<=n;i++){
        if(n%i==0){
            res++;
            while(n%i==0){
                n/=i;
            }
        }
        
    }
    if(n!=1)res++;//判断是否为0就错了
    cout<<res;
    return 0;
}

3492.负载均衡(优先队列）

输入样例：

2 6
5 5
1 1 5 3
2 2 2 6
3 1 2 3
4 1 6 1
5 1 3 3
6 1 3 4

输出样例：

2
-1
-1
1
-1
0

当一个任务在a时刻来临，
在此之前可能会有很多的任务分别在不同的计算机上执行，
但是只需要关注计算机 $b$ 的情况
如果之前有任务 在计算机$b$ 上执行，记录在优先队列中{结束时间和占用的运算力}
为什么存储在优先队列中，因为可能有多个任务占用计算机$b$ ，但是释放时间不同
释放时间早的，更有可能释放，如果释放时间 $为t，t>a$ 不能释放，那么后面的t+x就更加不可行 (每个计算机对应一个优先队列)
再次需要用到计算机b时，判断是否可以释放占用的运算力

#include <bits/stdc++.h>
using namespace std;
const int N=2e5+10;
int n,m;
int p[N];
#define PII pair<int,int>
priority_queue<PII,vector<PII>,greater<PII> > Q[N];
signed main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++){
		cin>>p[i];//存放此时第i台计算机的运算能力
	}
	int a,b,c,d;
	for(int i=1;i<=m;i++){//第i个任务
	cin>>a>>b>>c>>d;
//		在此之前可能会有很多的任务分别在不同的计算机上执行，
//		但是只需要关注计算机b的情况
//		如果之前有任务 在计算机b上执行，记录在优先队列中{结束时间和占用的运算力}
//		为什么存储在优先队列中，因为可能有多个任务占用计算机b，但是释放时间不同
//		释放时间早的，更有可能释放，如果释放时间为t，t>a不能释放，那么后面的t+x就更加不可行
//		每个计算机对应一个优先队列
//		再次需要用到计算机b时，判断是否可以释放占用的运算力
		while(!Q[b].empty()&&Q[b].top().first<=a){
			p[b]+=Q[b].top().second;//释放运算完毕任务占用的 云算力
			Q[b].pop();
		}
		if(p[b]<d)cout<<"-1"<<endl;
		else{
			Q[b].push({a+c,d});
			p[b]-=d;
			cout<<p[b]<<endl;
		}
	}
	
	return 0;
}