周赛题目
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，则返回0return 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;
}
