周赛题目
2748. 美丽下标对的数目
2749. 得到整数零需要执行的最少操作数
2750. 将数组划分成若干好子数组的方式
2751. 机器人碰撞
一、美丽下标对的数目
这题没什么好说的，按照题目的要求直接暴力求解，代码如下
bool gcd(int x,int y){
if(x==1||y==1)
return true;
int s=x>y?y:x;
for(int i=2;i<=s;i++){
if(x%i==0&&y%i==0)
return false;
}
return true;
}
//得到第一个数字
int GetOne(int x){
while(x/10){
x/=10;
}
return x;
}
int countBeautifulPairs(int* nums, int numsSize){
int n=numsSize,count=0;
for(int i=0;i<n;i++){
int x=GetOne(nums[i]);
for(int j=i+1;j<n;j++){
int y=nums[j]%10;
if(gcd(x, y)){
count++;
}
}
}
return count;
}时间复杂度是O(n^2)，空间复杂度是O(1)
这里再提供一种更加优雅的做法---有兴趣的同学可以学习一下
bool gcd(int x,int y){
if(x==1||y==1)
return true;
int s=x>y?y:x;
for(int i=2;i<=s;i++){
if(x%i==0&&y%i==0)
return false;
}
return true;
}
int GetOne(int x){
while(x/10){
x/=10;
}
return x;
}
int countBeautifulPairs(int* nums, int numsSize){
int n=numsSize,count=0;
int cnt[10]={0};
for(int i=0;i<n;i++){
for(int j=1;j<=9;j++){
if(gcd(nums[i]%10,j))
count+=cnt[j];
}
int x=GetOne(nums[i]);
cnt[x]++;
}
return count;
}
二、得到整数零所需要的执行的最小操作数
我们首先要对2^i很敏感，看到这个，我们就要想到这题可能要用到位运算及其相关的知识，其次我们用暴力的思想去试试想一想能不能行，如果nums2>=nums1，那么不可能使得nums1==0，返回-1，如果nums2<nums1，我们就会发现nums1==0不能成立的条件就很难界定了，很显然此路不通
那么既然通过尝试来找到最小操作数行不通，那么我们如果直接暴力枚举最小操作数呢？
这里我们就要将问题进行转换，nums1=k*nums2+(2^i1+2^i2+...+2^ik)，k为枚举次数，移项得nums1-k*nums2=(2^i1+2^i2+...+2^ik)，（因为2的几次幂相加本质就是二进制数的加法运算，方便问题的转化）
假设x=nums1-k*nums2，那么有无最小操作次数的问题就被转化成x二进制位上的1的个数是否能由k次操作得到，要想有答案，那么k必须在[x.bitcount，x]内，否则无解，直接返回-1，（因为当k>x时，后面的每次操作都是在给k+1，而x在不断减小，因为如果x不减小，k是不可能大于x的）
代码如下
int GetOneNum(long long x)//得到x的二进制上有几个1
{
int count=0;
while(x){
x&=(x-1);
count++;
}
return count;
}
int makeTheIntegerZero(int num1, int num2){
for(int k=0;k<36;k++){
long long x=num1-k*(long long)num2;//注意x的范围
if(x<k)
return -1;
if(k>=GetOneNum(x))
return k;
}
return -1;
}至于上面k为什么小于36，这里解释一下：
因为k在[x.bitcount，x]内，我们只考虑左边的不等式，不考虑右边的不等式（因为k>x,我们是直接返回-1的，而k<=x,那么我们可以继续枚举，所以没有必要解右边的不等式）
k>=log(nums1-k*nums2)，（以2为底）考虑到nums1和nums2的范围，我们为了找到k的最大取值，那么nums1取10^9，nums2取-10^9，那么解得k<36
总结：一开始的思路侧重尝试得到答案，之后的思路则将尝试次数作为答案来验证，两种思路本质都是暴力枚举操作次数，但是得到的结果却完全不同，一个是探索结论（将操作次数不固定），一个是验证结论（将操作次数固定）
三、将数组划分成若干好子数组的方式
这题其实比第二题简单，就是要我们将数组拆分成只有一个1的若干个连续子数组，求拆分的方法，很简单的乘法原理，只要数相邻两个1之间的有多少个"缝隙"，然后相乘就行
代码如下
const int MOD=1e9 + 7;
int numberOfGoodSubarraySplits(int* nums, int numsSize){
long long ans=1;
int left=-1,right=-1;//先找到第一个1和最后一个1出现的位置
for(int i=0;i<numsSize;i++){
if(nums[i]){
if(left==-1)
left=i;
right=i;
}
}
if(left==-1)//如果没有1，则返回0
return 0;
for(int i=left+1;i<right;i++){
int j=0;
while(i<right&&nums[i]==0){
i++;
j++;
}
ans=(ans*(j+1))%MOD;
}
return ans%MOD;
}四、机器人碰撞
这题就是个栈的问题，我们先将机器人按照位置大小排序，然后从左往右遍历，向左的机器人进栈，向右的机器人，看栈中有没有元素，如果有看是否碰撞，如果发生碰撞就比较健康值大小，不发生碰撞就进栈，直到遍历完机器人，然后返回栈中存在的机器人的健康值，注意按照原来数组中的顺序
代码如下
typedef struct List{
int position;
int health;
int index;//记录原来的下标
int flag;//0-左，1-右
}List;
typedef struct ST{
int index_1;//记录原来的下标
int index_2;//记录copy中的下标
}ST;
int cmp1(List*p1,List*p2){
return (p1->position)-(p2->position);
}
int cmp2(ST*p1,ST*p2){
return (p1->index_1)-(p2->index_1);
}
int* survivedRobotsHealths(int* positions, int positionsSize, int* healths, int healthsSize, char * directions, int* returnSize){
int n=positionsSize;
List copy[n];
for(int i=0;i<n;i++){
copy[i].position=positions[i];
copy[i].health=healths[i];
copy[i].flag=directions[i]=='R';
copy[i].index=i;
}
qsort(copy,n,sizeof(List),cmp1);
ST stack[n];
int top=0;
for(int i=0;i<n;i++){
if(copy[i].flag==0){//向左
if(top==0||copy[stack[top-1].index_2].flag==0){
stack[top].index_1=copy[i].index;
stack[top++].index_2=i;
}else{
if(copy[stack[top-1].index_2].health>copy[i].health){
copy[stack[top-1].index_2].health--;
}else if(copy[stack[top-1].index_2].health==copy[i].health){
top--;
}else{
top--;
copy[i].health--;
i--;
}
}
}else{
stack[top].index_1=copy[i].index;
stack[top++].index_2=i;
}
}
int*ans=(int*)malloc(sizeof(int)*top);
*returnSize=top;
qsort(stack,top,sizeof(ST),cmp2);
for(int i=0;i<top;i++){
printf("%d ",stack[i].index_1);
ans[i]=copy[stack[i].index_2].health;
}
return ans;
}
