Leetcode---351周赛

周赛题目

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;
}

最后，不要忘记点赞评论加收藏哦！！！！