牛客刷题系列之进阶版（跳石板,最近公共祖先,手套,扑克牌大小)

很多小伙伴为了刷题发愁
今天为大家推荐一款刷题神奇哦：刷题面试神器牛客
各大互联网大厂面试真题。从基础到入阶乃至原理刨析类面试题 应有尽有，赶快来装备自己吧！助你面试稳操胜券，solo全场面试官

一：跳石板

• 题目：（题目链接）

#include<iostream>
#include<vector>
#include<math.h>
using namespace std;
void _get(int a, vector<int>& v)
{
    for (int i = 2; i <= sqrt(a); i++)
    {
        if (a % i == 0)
        {
            v.push_back(i);
            if (a / i != i)
                v.push_back(a / i);
        }
    }
}
int get(int a, int b)
{
    vector<int> v(b + 1, 0); //创造一个数组
    v[a] = 1;
    for (int i = a; i < b; i++)
    {
        if (v[i] == 0)//假如该位置没有被访问，则跳过
            continue;

        vector<int> vv;
        _get(i, vv); //获取到 i的所有约数

        for (int j = 0; j < vv.size(); j++)
        {
            if ((vv[j] + i)<=b&&v[vv[j] + i] == 0)  //假如 该位置加上约数的值 的位置 没有被访问过
                v[vv[j] + i] = v[i] + 1;
            else {
                if ((vv[j] + i) <= b)
                {
                    int min = v[vv[j] + i] > v[i]+1 ? v[i]+1 : v[vv[j] + i];
                    v[vv[j] + i] = min;
                }
               
            }
        }

    }
    return v[b]-1;
}
int main()
{
    int a, b;
    cin >> a >> b;
    cout << get(a, b);
    return 0;
}

• 思路：

主要运用到了贪心的算法，只要每一步都是最优的，最后得到的结果也肯定是最优的了

1. 基于这个思路，我们可以创造一个数组来记录到达该点需要至少需要几步
2. 然后从起点开始，以自己的约数步往前走，假如自己的约数+起点 没有走过，则该点的步数直接是起点的步数加1
3. 若已经走过了，则是原来的步数和起点的步数加1之间的最小值
4. 一直走到目标位置为止

二：最近公共祖先

• 题目：（题目链接）
  

class LCA {
public:
    int getLCA(int a, int b) {
        // write code here
        while(a!=b)
        {
            if(a>b)
                a/=2;
            else
                b/=2;
        }
        return a;
    }
};

三：手套

• 题目：（题目链接）
  
• 代码实现：

class Gloves {
public:
    size_t min(size_t a,size_t b)
    {
        return a>b? b:a;
    }
    int findMinimum(int n, vector<int> left, vector<int> right) {
        // write code here
        size_t LeftSum =0,RightSum=0; //左手套和右手套的总和
        size_t LeftMin =-1,RightMin =-1; //左右手套的最小值
        size_t sum=0; 
        for(int i=0;i<n;i++)
        {
             if(left[i] * right[i] !=0)     //两边都有该类型的手套
             {
                  LeftSum+=left[i];
                 RightSum += right[i];
                 
                 LeftMin = min(left[i],LeftMin);
                 RightMin = min(right[i],RightMin);
             }
            else //只有一边有的类型，就肯定要先拿了，所以加在sum里
                sum += left[i] + right[i];          
        }
        return min(RightSum - RightMin+1,LeftSum - LeftMin+1)+ sum +1;
    }
};

• 思路：

1. 想要获得全部类型的手套，最少要拿的个数是 全部手套和 - 最小个数的手套 +1
2. 只有一边有的类型，就肯定要先拿了，所以加在sum里

• 重点：
  
  要想到将手套的状态分为两类：

3. 只有一边才有的

4. 两边都有

只要想到这点，这题就解开了

四：扑克牌大小

• 题目：（题目链接）
  
• 代码：

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string get(string& tem)
{
     if(tem.find("joker JOKER") != string::npos) //假如字符串中有王炸，直接输出
     {
            return "joker JOKER";
     }
    
    //找到两手牌
    int a = tem.find('-');//找到-的下标
    string s1 = tem.substr(0,a); //substr
    string s2 = tem.substr(a+1);//substr默认第二个参数是end
    
    int count1 = count(s1.begin(),s1.end(),' ')+1;
    int count2 = count(s2.begin(),s2.end(),' ')+1;//找到两手牌的牌数 ，用’ ‘
    
    if(count1 == count2) // 类型相同
    {
        string s("345678910JQKA2");
        string first1 = s1.substr(0,s1.find(' '));
        string first2 = s2.substr(0,s2.find(' '));
        if(s.find(first1) > s.find(first2))
            return s1;
        else
            return s2;
    }
    else //类型不同
    {
          //谁有炸弹谁赢
        if(count1 ==4)
            return s1;
        else if(count2 ==4)
            return s2;
        else
            return "ERROR";
    }
        
}
int main()
{
    string tem;
    getline(cin,tem);
    cout<< get(tem); 
    return 0;
}

该题主要是运用了对string类型内的函数

1. substr(开始的下标，结束的下标) ，结束的下标不算进串内
2. find(字符串或者字符) ，返回所在的下标，假如不存在则返回 string::npos
3. 还运用到了algorithm库内的函数 count(开始的迭代器，结束时的迭代器，要记录的东西)

想和博主一样刷优质面试和算法题嘛，快来刷题面试神器牛客吧，期待与你在牛客相见