百度2017秋招笔试编程题

1.[编程题] 买帽子

时间限制：1秒
空间限制：32768K

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

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

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

输入例子1:
10
10 10 10 10 20 20 30 30 40 40

输出例子1:
30

#include <iostream>
using namespace std;
int a[51];
void quicksort(int left, int right) {
    int i,j,t,key;
    if(left > right)
        return;
    key = a[left];
    i = left;
    j = right;
    while(i != j) {
        while(a[j] >= key && i < j)
            --j;

        while(a[i] <= key && i < j)
            ++i;
        if(i<j) {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    a[left] = a[i];
    a[i] = key;
    quicksort(left, i-1);
    quicksort(i+1, right);
    return;
}
int main() {
    int N;
    cin >> N;
    for(int i = 0; i < N; ++i) {
        cin >>a[i];
    }
    quicksort(0, N-1);
    int tmp = 2;
    for(int i = 0; i+1 < N; ++i) {
        if(a[i] < a[i+1])
            --tmp;
        if(tmp == 0) {
            cout << a[i+1];
            return 0;
        }
    }
    cout << -1;
    return 0;
}

2.[编程题] 度度熊回家

时间限制：1秒
空间限制：32768K

一个数轴上共有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<algorithm>
#include<cmath>
#include<limits.h>
using namespace std;
int main() {
    int N;
    cin >> N;
    vector<int> num(N);
    int total = 0;
    for(int i = 0; i < N; ++i) {
        cin >> num[i];
    }
    for(int i=0; i+1 < N; ++i) {
        total += abs(num[i+1]-num[i]);
    }
    int mx = 0;
    for(int i = 1; i+1 < N; ++i) {
        mx = max(mx, abs(num[i] - num[i-1]) + abs(num[i+1] - num[i]) - abs(num[i+1] - num[i-1]));
    }
    cout<<total-mx;
    return 0;
}

3.[编程题] 寻找三角形

时间限制：1秒
空间限制：32768K

三维空间中有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<algorithm>
#include<cmath>
#include<iomanip>
using namespace std;

double distance(vector<int> p1, vector<int> p2) {
    int a1 = p1[0] - p2[0];
    int a2 = p1[1] - p2[1];
    int a3 = p1[2] - p2[2];
    return sqrt((1.0*a1*a1) + (1.0*a2*a2) + (1.0*a3*a3));
}

double help(vector<int> p1, vector<int> p2, vector<int> p3) {
    double a, b, c, p;
    a = distance(p1, p2);
    b = distance(p1, p3);
    c = distance(p2, p3);
    p = (a+b+c)/2;
    return sqrt(1.0*p*(p-a)*(p-b)*(p-c));
}

int main() {
    int N, zero = 1;
    cin >> N;
    vector<vector<int> > num(N, vector<int>(3));
    vector<char> idx(N);
    double res = 0;
    for(int m = 0; m < N; ++m) {
        cin>>idx[m]>>num[m][0]>>num[m][1]>>num[m][2];
    }
    for(int i = 0; i < N; ++i) {
        for(int j = i+1; j < N; ++j) {
            for(int k = j+1; k < N; ++k) {
                if( (idx[i]!=idx[j] && idx[i]!=idx[k] && idx[j]!=idx[k]) || (idx[i]==idx[j] && idx[j]==idx[k]) ) {
                    if(zero) {
                        res = help(num[i], num[j], num[k]);
                        zero = 0;
                    }
                    else {
                        res = max(res, help(num[i], num[j], num[k]));
                    }
                }
            }
        }
    }
    cout<<setiosflags(ios::fixed)<<setprecision(5)<<res<<endl;
    return 0;
}

4.[编程题] 有趣的排序

时间限制：1秒
空间限制：32768K

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

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

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

输入例子1:
4
19 7 8 25

输出例子1:
2

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    cin>>n;
    vector<int> num(n), numcp(n);
    for(int i=0; i<n; ++i) {
        cin>>num[i];
    }
    numcp = num;
    sort(numcp.begin(), numcp.end());
    int idx, last, ans = 0;
    last = find(num.begin(), num.end(), numcp[0]) - num.begin();
    for(int i=1; i<n; ++i) {
        idx = find(num.begin(), num.end(), numcp[i]) - num.begin();
        if(idx>last) {
            last = idx;
        } else {
            ans = n - i;
            break;
        }
    }
    cout<<ans;
    return 0;
}

5.[编程题] 不等式数列

时间限制：1秒
空间限制：32768K

度度熊最近对全排列特别感兴趣,对于1到n的一个排列,度度熊发现可以在中间根据大小关系插入合适的大于和小于符号(即 ‘>’ 和 ‘<’ )使其成为一个合法的不等式数列。但是现在度度熊手中只有k个小于符号即(‘<”)和n-k-1个大于符号(即’>’),度度熊想知道对于1至n任意的排列中有多少个排列可以使用这些符号使其为合法的不等式数列。

输入描述:
输入包括一行,包含两个整数n和k(k < n ≤ 1000)

输出描述:
输出满足条件的排列数,答案对2017取模。

输入例子1:
5 2

输出例子1:
66

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n,k;
    cin>>n>>k;
    int dp[1001][1001] = {0};
    dp[1][0] = 1;
    dp[2][0] = 1;
    dp[2][1] = 1;
    for(int i = 3; i <= n; ++i) {
        for(int j = 0; j <= k; ++j) {
            dp[i][j] = (dp[i-1][j-1]*(i-j) + (dp[i-1][j]*(j+1))) % 2017;
        }
    }
    cout<<dp[n][k];
    return 0;
}

dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i - 1][j] * (j + 1)) % 2017;
dp[i][j]表示有i个数字及j个小于号所能组成的数量(大于号数量当然是i - j - 1次，后面需要使用)
而加入第i + 1个数字时，分以下四种情况：
1.如果将i+1插入当前序列的开头，即有了1<2，加入后成为3>1<2，会发现等于同时加入了一个大于号！(此时可以无视1与2之间的关系，因为i+1>i)
2.如果将i+1插入当前序列末尾,即1<2变成了 1<2<3，会发现等于同时加入了一个小于号！ (此时可以无视1与2之间的关系，因为i+1>i)
3.如果将i+1加入一个小于号之间，即已经有 1<2了，向中间加入3,会发现变成了1<3>2，等于同时加入了一个大于号！
4.如果将i+1加入一个大于号中间，即有了2>1，变成了2<3>1，等于同时加入了一个小于号！
综上所述，dp[i][j]等于以上四种情况之和：
dp[i - 1][j] //将i加在开头等于加入一个大于号，即要求i-1个数时已经有了j个小于号
dp[i - 1][j - 1] //将i加在末尾等于加入一个小于号，即要求i-1个数时已经有了j-1个小于号
dp[i - 1][j] * j //将i加在任意一个小于号之间，等于加入了一个大于号；即要求i-1个数时已经有了j个小于号，每个小于 号都可以进行这样的一次插入
dp[i - 1][j - 1] * (i- j - 1) //将i加载任意一个大于号之间，等于加入了一个小于号；即要求i-1个数时有了j-1个小于号，而此时共有
(i - 1) - (j - 1)- 1个大于号，每个大于号都要进行一次这样的操作
合并同类项即为
dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i - 1][j] * (j + 1))
最后要记得取模.