第四周题解

1.RSA

RSA算法选择两个不同质数的积作为模数。现在有两个正整数 A,B，如果它们是不同的质数，则判定为 full credit；否则，如果A⋅B不是任意大于11的整数的平方的整数倍，则判定 partial credit；否则判定为no credit。

输入格式

一行两个正整数 A,B。

输出格式

full credit 或 partial credit 或 no credit。

样例1输入

13 23

样例1输出

full credit

样例2输入

3 3

样例2输出

no credit

数据规模

所有数据保证 2≤A,B≤10^12

我们要判定一个数n是质数其实非常简单，我们只需要从1~sqrt(n)进行遍历，看看n是否可以对这个数进行整除，就可以知道这个数是否是质数了。

如果两个数不是不同的质数，我们就要对不是质数的数进行查找。因为我们在检测这个数是否是质数的操作中就可以对这个数可以整除的数进行标记，如果某个数被标记的数量超过1次，那就代表这两个数的乘积一定是这个被标记的数的平方的整数倍，否则就不是了。（注意，因为这道题的数据有点大，我们要对一个数的很大的因子进行单独的处理！）

那么我们就可以很容易写出结果了：

#include<bits/stdc++.h>
using namespace std;
long long a,b,point;
int book[10000000],len_a,len_b;
long long hugenum[100],len=0;     //hugenum是表示单独处理的因子
int ans=0,num=0;
void turn_a(long long x){   
	int flag=0;
	for(int i=2;i<=sqrt(x);i++){
		if(!(x%i)){
			len_a=1;
			flag=1;
			book[i]++;
			if(book[i]>1){
				ans=1;  //如果某个数被标记超过1次，那么标记结果为1
			}
			x/=i;
			turn_a(x);   //递归实现对因子进行标记
			break;
		}
	}
	if(!flag){
		if(x>10000000){   
			hugenum[len++]=x;  //对大的因子进行单独处理
		}
		else{
			book[x]++;
			if(book[x]>1){
				ans=1;
			}
		}
	}
}
void turn_b(long long x){   //对b操作同理
	int flag=0;
	for(int i=2;i<=sqrt(x);i++){
		if(!(x%i)){
			flag=1;
			len_b=1;
			book[i]++;
			if(book[i]>1){
				ans=1;
			}
			x/=i;
			turn_b(x);
			break;
		}
	}
	if(!flag){
		if(x>10000000){
			for(int i=0;i<len;i++){
				if(x==hugenum[i]){
					ans=1;
				}
			}
		}
		else{
			book[x]++;
			if(book[x]>1){
				ans=1;
			}			
		}

	}
}
void judge(){    //判断是否是质数
	for(int i=2;i<=sqrt(a);i++){
		if(!(a%i)){
			turn_a(a); 
			break;
		}
	}
	for(int i=2;i<=sqrt(b);i++){
		if(!(b%i)){
			turn_b(b);
			break;
		}
	}
}
int main(){
	cin>>a>>b;
	judge();
	if(!len_a&&!len_b&&a!=b){
		cout<<"full credit";  
	}
	else{
		if(a!=b){
			if(ans){
				cout<<"no credit";
			}
			else{
				cout<<"partial credit";
			}			
		}
		else{
			cout<<"no credit";
		}
	}
    return 0;
}

---

2.数组操作

给你一个有 n 个元素的数组 a 。你可以对它进行如下操作，次数不限。

从一个偶数大小为 2k 的数组中选择一些从位置 l 开始的子数组(1≤l≤l+2⋅k−1≤n,1≤ n,k≥1) ，对于 00 到 k−1（包括）之间的每一个 i ，将值 a_l+k+i 分配给 a_l+i 。

例如，如果 a=[2,1,3,4,5,3] ，然后选择 l=1 和 k=2 ，应用这个操作，数组将变成 a=[3,4,3,4,5,3]。

请找出使数组中所有元素相等所需的最少操作数（可能是零）。

输入格式

输入由多个测试用例组成。第一行输入一个整数 t(1≤t≤2×10^4)表示测试用例的数量。

每个测试用例的包含 (n+1)个整数：

第一个整数 n(1≤n≤2×10^5) 表示数组的长度。

此后 n 个整数 a_1,a_2,…,a_n(1≤a_i≤n) 表示数组的元素。

输出格式

输出 t 行，每行一个整数表示用给定的操作使数组中所有元素相等所需的最小操作数。

样例输入

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

样例输出

0
1
1
2
0

数据规模

保证所有测试用例的 n 之和不超过 200000。

提示

在第一个测试中，所有元素都是相等的，因此不需要任何操作。

在第二个测试中，你可以应用一个操作，k=1，l=1，设置 a_1←a_2 ，通过 1 个操作，数组变成 [1,1][1,1]。

在第三个测试中，你可以应用一个操作，k=1，l=4，设置 a_4←a_5 ，然后数组变成 [4,4,4,4,4][4,4,4,4,4]。

在第四个测试中，你可以应用一个操作，k=1，l=3，设置 a_3←a_4 ，数组变成 [4,2,3,3][4,2,3,3]，然后你可以应用另一个操作，k=2，l=1，设置 a_1←a_3,a_2←a_4， 数组变成 [3,3,3,3][3,3,3,3]。

在第五次测试中，只有一个元素，因此不需要任何操作。

这道题其实最难的就是理解题意了。题意其实很简单，就是我们可以选一段子数组，然后，我们让子数组后面的与子数组有相同数量的数组复制到这段数组上，最后，我们要求最少多少步可以让整个数组变成一样的数。

那么我们可以发现，其实这个数组最后的数字必然是这个数组的最后一个数。（因为是向后复制的，最后一个数没有后继）那么我们就可以根据贪心策略，从这个数组最后一个数往前遍历，找最大的连在一起的子串，如果不相同就将这个子串复制到前面去，直到遍历到最前面的一个数为止。

那么我们就可以写出代码了：

#include<bits/stdc++.h>
using namespace std;
int num[200005];
inline int findans(int len){
	int now=len,pointnum=num[len],count=1,op=0;
	if(le