letcode——8.22九坤

letcode九坤投资专场竞赛（easy+medium）

01. 可以读通讯稿的组数

• 通过的用户数287
• 尝试过的用户数340
• 用户总通过次数291
• 用户总提交次数825
• 题目难度****Easy

校运动会上，所有参赛同学身上都贴有他的参赛号码。某班参赛同学的号码记于数组 nums 中。假定反转后的号码称为原数字的「镜像号码」。如果 两位同学 满足条件：镜像号码 A + 原号码 B = 镜像号码 B + 原号码 A，则这两位同学可以到广播站兑换一次读通讯稿的机会，为同班同学加油助威。请返回所有参赛同学可以组成的可以读通讯稿的组数，并将结果对10^9+7取余。

注意：

1. 镜像号码中如存在前置零，则忽略前置零。
2. 同一位同学可有多次兑换机会。

示例 1：

输入：nums = [17,28,39,71]

输出：3

解释：
共有三对同学，分别为 [17,28]、[17,39]、[28,39]。其中：
第一对同学：17 + 82 = 71 + 28；
第二对同学：17 + 93 = 71 + 39；
第三对同学：28 + 93 = 82 + 39。

示例 2：

输入：nums = [71, 60]

输出：1

解释：
共有一对同学，为 [71, 60]。
因为 71 + 6 = 17 + 60，此处 60 的镜像号码为 6，前导零被忽略。

提示：

• 0 <= nums.length <= 10^6
• 0 <= nums[i] <= 10^9

被这个题卡了，主要还是stl有点不熟练

unorder_map

把限制条件转换一下，变成：镜像号码 A - 原号码 A = 镜像号码 B - 原号码 B

这么改了之后就变成了每个号码所带的一个属性：镜像号码-原号码的值，当这个两个号码的这个属性相同时，就说明这两个号码可以组成一对。怎么存储这个属性，我们可以用map，关键字是每个号码的属性，这个属性在当前有多少个元素满足作为键值，当发现这个属性在map中已经存在，那么让答案加上之前的当键值，再让当前属性对应的满足条件的元素个数+1。

class Solution {
    unordered_map<long long,int> p;
public:
    long long rev(int x){
        long long ret = 0;
        while (x) {
            ret=ret * 10 + x % 10;
            x=x/10;
        }
        return ret;
    }//求出镜像号码
    int numberOfPairs(vector<int>& nums) {
        int mo=1e9+7;
        long long ret=0;
        for(int i=0;i<nums.size();i++) {
            long long tmp=nums[i] - rev(nums[i]);//temp作为关键字
            ret=ret+p[tmp];//答案加上当前的键值，代表nums[i]依次和已经查找出来的属性相同号码组成一组
            p[tmp]++;//当前已经查找出来具有该属性的元素个数+1
        }
        return ret % mo;
    }
};

02. 池塘计数

• 通过的用户数314
• 尝试过的用户数320
• 用户总通过次数319
• 用户总提交次数398
• 题目难度****Medium

最近的降雨，使田地中的一些地方出现了积水，field[i][j] 表示田地第 i 行 j 列的位置有：

• 若为 W, 表示该位置为积水；
• 若为 ., 表示该位置为旱地。

已知一些相邻的积水形成了若干个池塘，若以 W 为中心的八个方向相邻积水视为同一片池塘。

请返回田地中池塘的数量。

示例 1：

输入: field = [".....W",".W..W.","....W.",".W....","W.WWW.",".W...."]

输出：3

解释：如下图所示，共有 3 个池塘：

示例 2：

输入: field = ["W....W",".W..W.","..W.W.","W..W..","W.W...",".W...."]

输出：1

解释：如下图所示，共有 1 个池塘：

提示：

• 1 <= field.length, field[i].length <= 100
• field 中仅包含 W 和 .

标准水题，个人感觉比第一题简单，几乎裸的深搜或者广搜，本题采用dfs

DFS

遍历数组，每次从一个未被标记且值为‘W’的节点出发，查找和它相连的所有方块，并标记，统计进行操作次数

class Solution {
public:
    int r,c;
    int dir[8][2]={-1,0,-1,1,0,1,1,1,1,0,1,-1,0,-1,-1,-1};
    bool check(int& x,int& y)
    {
        if(x>=0&&x<r&&y>=0&&y<c)
            return true;
        return false;
    }
    void dfs( vector<vector<bool>>&flag,vector<string>&field,int x,int y)
    {
        flag[x][y]=true;
        int dx,dy;
        for(int i=0;i<8;i++)
        {
            dx=x+dir[i][0];
            dy=y+dir[i][1];
            if(check(dx,dy)&&field[dx][dy]=='W'&&!flag[dx][dy])
            {
                dfs(flag,field,dx,dy);
            }
        }
    }
    int lakeCount(vector<string>& field) {
         r=field.size();
         c=field[0].size();
      vector<vector<bool>>flag(r,vector<bool>(c,false));
        int ans=0;
        for(int i=0;i<r;i++)
            for(int j=0;j<c;j++)
            {
                if(field[i][j]=='W'&&!flag[i][j])
                {
                    dfs(flag,field,i,j);
                    ans++;
                }
            }
        return ans;
    }
};

03. 数字默契考验

• 通过的用户数225
• 尝试过的用户数278
• 用户总通过次数236
• 用户总提交次数535
• 题目难度****Medium

某数学兴趣小组有 N 位同学，编号为 0 ~ N-1，老师提议举行一个数字默契小测试：首先每位同学想出一个数字，按同学编号存于数组 numbers。每位同学可以选择将自己的数字进行放大操作，每次在以下操作中任选一种（放大操作不限次数，可以不操作）：

1. 将自己的数字乘以 2
2. 将自己的数字乘以 3

若最终所有同学可以通过操作得到相等数字，则返回所有同学的最少操作次数总数；否则请返回 -1。

示例 1：

输入：numbers = [50, 75, 100]
输出：5
解释：
numbers[0] * 2 * 3 = 300 操作两次；
numbers[1] * 2 * 2 = 300 操作两次；
numbers[2] * 3 = 300 操作一次。共计操作五次。

示例 2：

输入：numbers = [10, 14]
输出：-1
解释：无法通过操作得到相同数字。

提示：

• 1 <= numbers.length <= 10^5
• 1 <= numbers[i] <= 10^9

数学知识

结论

在求解这个题之前我们需要进行下面这个结论的数学推导：

• 两个整数，x和y通过进行以下两种操作都变成z：

1. 将自己的数乘以2
2. 将自己的数乘以3
3. 结论：将x和y不断除以2或者除以3，直到他们没有2或者3的因子后得到p和q两个数，那么x和y变成相同大小的数z当且仅当p等于q

证明

*假设我们可以通过上诉操作将x，y变成z，那么存在2^m1 * 3^n1 p2^m2 * 3^n2 *q，那么必然存在p *2^(m1-m2) *3(n1-n2)q和q *2^(m2-m1) *3(n2-n1)，因为p和q都不存在2,3的因子，所以m1-m2,m2-m1,n1-n2,n2-n1都必须不小于0，所以m1m2,n1n2，最终得到p==q。

思路和代码细节

直接干讲思路不好描述，具体细节代码中体现

代码一

比赛时写的代码，有点丑

class Solution {
public:
    int helper(int x)
    {
        while(x&&(x%2==0||x%3==0))
        {
            if(x&&x%2==0)
                x/=2;
            if(x&&x%3==0)
                x/=3;
        }
        return x;
    }//去除所有2,3因子，此处的x是否等于0的判断这个题可以去掉，因为数据保证大于0，下面的代码也是如此
    int minOperations(vector<int>& numbers) {
        //依次对比相邻的两个数x，y，并将这两个数转换为进行多次操作后的最小相同数z
        long long ans=0,num=numbers[0];//num用于实时记录进行多次操作后的z，ans存储操作次数
        int a,b=helper(numbers[0]);//a，b分别记录去除因子后的x和y，初始化b，至于为什么要这么初始化看下面就明白了
        for(int i=1;i<numbers.size();i++)
        {
            a=b;
            b=helper(numbers[i]);//存储求得的p或q，后续只需求下一位的去除2,3因子的数，避免了重复求解
            if(a==b)//判断是否能构成z
            {
                long long x1=num/a,x2=numbers[i]/b;//num代表将i前面i-1个元素都更新为了num,x1和x2记录x，y分别是p（q）的多少倍
                       /*
                       对x1和x2进行分析，他们都可以表现为2^m*3^n的形式,此处可以分为两种情况：
                       1.x1中的m1和n1都大于或小于或等于x2中的m2，n2,即（m1-m2）*（n1-n2)>=0
                       2.（m1>m2）*（n1-n2)<0
                     这两种情况我们最终的z都可以表示为p*2^(max(m1,m2))*3^(max(n1,n2)),因为我们始终保证i前方的元素相同，所以操作次数就是用（i-1）*其中一个的操作次数加上第i个数的操作次数
                       */
                int y12=0,y13=0,y22=0,y23=0;//y12，y13分别代表m1，n1，y22和y23分别代表m2和n2
                while(x1&&(x1%2==0||x1%3==0))
                {
                    if(x1%2==0&&x1)
                    {
                        y12++;
                        x1/=2;
                    }
                    if(x1%3==0&&x1)
                    {
                        y13++;
                        x1/=3;
                    }
                }
                while(x2&&(x2%2==0||x2%3==0))
                {
                    if(x2%2==0&&x2)
                    {
                        y22++;
                        x2/=2;
                    }
                    if(x2%3==0&&x2)
                    {
                        y23++;
                        x2/=3;
                    }
                }
                ans+=i*(max(y12,y22)-y12+max(y13,y23)-y13)+max(y12,y22)-y22+max(y13,y23)-y23;//加上当前的操作次数
                num=a*pow(2,max(y12,y22))*pow(3,max(y13,y23));//更新num的值
            }
            else
            {
                return -1;
            }
        }
        return ans;
    }
};

代码二

看了一下排在前面的大佬的代码，和我的比起来不知道简洁多少，不做解说，自行观赏

思路有点差异

class Solution {
public:
    int minOperations(vector<int>& A) {
        int n = A.size();
        vector<int> B(n), C(n);
        for(int i = 0; i < n; ++i) {
            for( ; A[i] % 2 == 0; A[i] /= 2, ++B[i]);
            for( ; A[i] % 3 == 0; A[i] /= 3, ++C[i]);
            if(A[i] != A[0])
                return -1;
        }
        int ans = 0;
        int uppB = *max_element(B.begin(), B.end());
        int uppC = *max_element(C.begin(), C.end());
        for(int i = 0; i < n; ++i) {
            ans += uppB - B[i];
            ans += uppC - C[i];
        }
        return ans;
    }
};

= A[0])
return -1;
}
int ans = 0;
int uppB = *max_element(B.begin(), B.end());
int uppC = *max_element(C.begin(), C.end());
for(int i = 0; i < n; ++i) {
ans += uppB - B[i];
ans += uppC - C[i];
}
return ans;
}
};