牛客网 百度2017春招笔试真题编程题集合

1、买帽子
度度熊想去商场买一顶帽子，商场里有N顶帽子，有些帽子的价格可能相同。度度熊想买一顶价格第三便宜的帽子，问第三便宜的帽子价格是多少？
输入描述:

首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）

输出描述:

如果存在第三便宜的帽子，请输出这个价格是多少，否则输出-1

输入例子1:

10
10 10 10 10 20 20 30 30 40 40

结构体+排序即可

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct hat{
    int p;//价格
    int c;//次数
    hat(int p_, int t_):p(p_), c(t_){}
    bool operator == (const int &x)const{
        return p==x;
    }
    bool operator< (const hat&h)const{
        return p<h.p;
    }
};
int main(){
    vector<hat> v_h;
    int n;
    cin>>n;
    for (int i = 0; i < n; ++i) {
        int p;
        cin>>p;
        vector<hat>::iterator it=find(v_h.begin(), v_h.end(), p);
        if(it==v_h.end()) {
            v_h.push_back(hat(p, 1));
        }
        else{
            it->c++;
        }
    }
    sort(v_h.begin(), v_h.end());
    if(v_h.size()<3)cout<<"-1"<<endl;
    else cout<<v_h[2].p<<endl;
    return 0;
}

2、 度度熊回家
一个数轴上共有N个点，第一个点的坐标是度度熊现在位置，第N-1个点是度度熊的家。现在他需要依次的从0号坐标走到N-1号坐标。
但是除了0号坐标和N-1号坐标，他可以在其余的N-2个坐标中选出一个点，并直接将这个点忽略掉，问度度熊回家至少走多少距离？
输入描述:

输入一个正整数N, N <= 50。

接下来N个整数表示坐标，正数表示X轴的正方向，负数表示X轴的负方向。绝对值小于等于100

输出描述:

输出一个整数表示度度熊最少需要走的距离。

输入例子1:

4
1 4 -1 3

输出例子1:

4

这里一个一个试就是最简单的办法了。。。

#include <iostream>
#include <vector>
using namespace std;
int get_len(int t, vector<int>exam){
    exam.erase(exam.begin()+t);
    int sum=0;
    for (int i = 1; i < exam.size(); ++i) {
        sum += abs(exam[i]-exam[i-1]);
    }
    return sum;
}
int main()
{
    int n;
    cin>>n;
    vector<int> n_v;
    for (int i = 0; i < n; ++i) {
        int t;
        cin>>t;
        n_v.push_back(t);
    }
    int min_len=0x3f3f3f3f;
    for (int i = 1; i < n-1; ++i) {
        min_len = min(get_len(i, n_v), min_len);
    }
    cout<<min_len<<endl;
    return 0;
}

3、寻找三角形
三维空间中有N个点，每个点可能是三种颜色的其中之一，三种颜色分别是红绿蓝，分别用’R’, ‘G’, ‘B’表示。
现在要找出三个点，并组成一个三角形，使得这个三角形的面积最大。
但是三角形必须满足：三个点的颜色要么全部相同，要么全部不同。
输入描述:

首先输入一个正整数N三维坐标系内的点的个数.(N <= 50)

接下来N行，每一行输入 c x y z，c为’R’, ‘G’, ‘B’ 的其中一个。x，y，z是该点的坐标。(坐标均是0到999之间的整数)

输出描述:

输出一个数表示最大的三角形面积，保留5位小数。

输入例子1:

5
R 0 0 0
R 0 4 0
R 0 0 3
G 92 14 7
G 12 16 8

输出例子1:

6.00000

思路：穷举所有可能情况

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
struct trangle{
    char color;
    int p1, p2, p3;
    trangle(char color_, int p1_, int p2_, int p3_):color(color_), p1(p1_), p2(p2_), p3(p3_){}
};
int main()
{
    int n;
    cin>>n;
    vector<trangle> v_t;
    for (int i = 0; i < n; ++i) {
        char color;
        int p1, p2, p3;
        cin>>color>>p1>>p2>>p3;
        v_t.push_back(trangle(color, p1, p2, p3));
    }
    double maxs = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                if((v_t[i].color==v_t[j].color && v_t[i].color==v_t[k].color) ||
                        (v_t[i].color!=v_t[j].color && v_t[i].color!=v_t[k].color && v_t[j].color!=v_t[k].color) ){
                    //满足条件
                    double c1 = pow(v_t[i].p1-v_t[j].p1, 2)+pow(v_t[i].p2-v_t[j].p2, 2)+pow(v_t[i].p3-v_t[j].p3, 2);
                    double c2 = pow(v_t[i].p1-v_t[k].p1, 2)+pow(v_t[i].p2-v_t[k].p2, 2)+pow(v_t[i].p3-v_t[k].p3, 2);
                    double c3 = pow(v_t[k].p1-v_t[j].p1, 2)+pow(v_t[k].p2-v_t[j].p2, 2)+pow(v_t[k].p3-v_t[j].p3, 2);
                    double c = (sqrt(c1)+sqrt(c2)+sqrt(c3))/2;
                    double area = sqrt(c*(c-sqrt(c1))*(c-sqrt(c2))*(c-sqrt(c3)));
//                    cout<<area<<endl;
                    maxs = max(area, maxs);
                }
            }
        }
    }
    printf("%.5lf", maxs);
}

4、有趣的排序
度度熊有一个N个数的数组，他想将数组从小到大 排好序，但是萌萌的度度熊只会下面这个操作：
任取数组中的一个数然后将它放置在数组的最后一个位置。
问最少操作多少次可以使得数组从小到大有序？
输入描述:

首先输入一个正整数N，接下来的一行输入N个整数。(N <= 50, 每个数的绝对值小于等于1000)

输出描述:

输出一个整数表示最少的操作次数。

输入例子1:

4
19 7 8 25

输出例子1:

2

整体思路：找到最小的和第二小的，比较，如果第二小的在第一小的位置的前面，就把第二小的放在最后

这个思路是参考下面这个博客的，好方法，贴出来：https://blog.csdn.net/qq_25073253/article/details/71480822

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
int main()
{
    int n;
    cin>>n;
    vector<int> p_v;
    map<int, int> p_m;
    for (int i = 0; i < n; ++i) {
        int p;
        cin>>p;
        p_v.push_back(p);
        p_m[p] = i;
    }
    int index = n;
    int count = 0;
    sort(p_v.begin(), p_v.end());
    for (int i = 0; i < n-1; ++i) {
        if(p_m[p_v[i]]>p_m[p_v[i+1]]){
            //最小的和次小的比较
            //本来比较小的下标应该在前面，现在反过来了，就把它后面的这个放在最后
            p_m[p_v[i+1]] = ++index;
            count++;
        }
    }
    cout<<count<<endl;
}

/*
 * 思路很简单，使用vector来装数组，使用map放value和index。
 * 首先，对vector进行排序，这样我们就发现，vector中的值在map的索引号应该逐渐增大
 * 当发现vector中较大的值对应的map中的索引好较小，应该把vector中较大的值对应的map中的
 * 索引号以vector.size()为基增大
 */

下面这个是用结构体代替了map结构

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct point{
    int p;
    int index;
    point(int p_, int index_):p(p_), index(index_){}
    bool operator <(const point &a)const{
        return p<a.p;
    }
};
int main()
{
    vector<point> p_v;
    int n;
    cin>>n;
    for (int i = 0; i < n; ++i) {
        int p;
        cin>>p;
        p_v.push_back(point(p, i));
    }
    int index_n = n;
    int count = 0;
    sort(p_v.begin(), p_v.end());
    for (int i = 0; i < n-1; ++i) {
        if(p_v[i].index>p_v[i+1].index){
            p_v[i+1].index = index_n++;
            count++;
        }
    }
    cout<<count<<endl;
}