百度2017春招试题

1.

[编程题] 买帽子

时间限制：1秒

空间限制：32768K

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

输入描述:

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

输出描述:

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

输入例子:

10
10 10 10 10 20 20 30 30 40 40

输出例子:

30

简单题，用STL set不重合数组可以直接做，这里排序，然后计数

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int a[55];
    int n;
    int m = -1;
    while(cin>>n) {
    int flag = 0;
    for(int i = 0; i < n; i++) {
        cin>>a[i];
    }
    sort(a,a+n);
    for(int i = 0; i < n; i++) {
        if(a[i]>m) {
            m = a[i];
            flag++;
        }
        if(flag == 3) break;
    }
    if(flag==3)
        cout<<m<<endl;
    else
        cout<<"-1"<<endl;
    }
    return 0;
}

 

2.

[编程题] 度度熊回家

时间限制：1秒

空间限制：32768K

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

输入描述:

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

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

输出描述:

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

输入例子:

4
1 4 -1 3

输出例子:

4

一看上去有点懵，百度是只直接默认序号是从0开始了啊，这就是所谓程序猿的思维吗，一开始以为第一个点是数轴原点，但是又读了一遍题，没提到原点，半毛钱关系都没。仔细想下，枚举即可，关键去掉的点只与上一条边和下一条边有关，枚举1到n-1个点，比较取出差值最大的距离即可。比如：
-1 1 3 4
 2 0 3 1
下面一行是走的序号，第一个枚举序号1的点，则用1-0加上2-1的距离减去2-0，不经过1，2直接到达0的距离，取出最大的差值。

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    int ans;
    int a[55];
    int sub = 0;
    int Max = -1;
    while(cin>>n) {
        ans = 0;
        for(int i = 0; i < n; i++) {
            cin>>a[i];
        }
        for(int i = 1; i < n; i++) {
            ans+=abs((a[i]-a[i-1]));
        }
    //不走中间点与走中间点之间的差值
    //枚举每个中间点
        for(int i = 1; i < n-1; i++) {//中间点不包括0和n
//            cout<<a[i]-a[i-1]<<" "<<a[i+1]-a[i]<<" "<<a[i+1]-a[i];
            sub = max(sub,abs(a[i]-a[i-1])+abs(a[i+1]-a[i])-abs(a[i+1]-a[i-1]));
        }
        cout<<ans-sub<<endl;
    }
    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位小数。

输入例子:

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

输出例子:

6.00000

也是模拟器

模拟题，先判断是否是个三角形，然后在循环上注意去重点，然后一直往前扫，所以j比i大1，k比j大1，去重边。
最开始写了int，但是结果是小数的，注意精度都要控制double上，然后三个for循环仔细点。。。开始写叉了就错了。找了一会bug。。跟我开始一样。。
最后上海伦公式。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

struct Node {
    char color;
    int x,y,z;
}node[55];

bool IsTriangle(int a,int b,int c) {
    if(a+b>c && a+c>b && b+c>a) {
        return true;
    }
    else
        return false;
}

double dis(Node a,Node b) {
    return sqrt((1.0*(a.x-b.x)*(a.x-b.x))+(1.0*((a.y-b.y)*(a.y-b.y)))+(1.0*((a.z-b.z)*(a.z-b.z))));
}
double solve(int i,int j,int k) {
    double a1 = dis(node[i],node[j]);
    double a2 = dis(node[i],node[k]);
    double a3 = dis(node[j],node[k]);
    double p = 1.0*((a1+a2+a3)/2);
    if(IsTriangle(a1,a2,a3)) {
        double s = sqrt(p*(p-a1)*(p-a2)*(p-a3));
        return s;
    }
    else {
        return -1.0;
    }
}


int main()
{
//    freopen("in.txt","r",stdin);
    int n;
    while(cin>>n) {
        for(int i = 0; i < n; i++) {
            cin>>node[i].color>>node[i].x>>node[i].y>>node[i].z;
        }

    double Max = 0.0;
    //Ïàͬ
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i==j) continue ;
                for(int k = 0; k < n; k++) {
                    if(k==i||k==j) continue;
                        if((node[i].color==node[j].color&&node[j].color==node[k].color)||(node[i].color!=node[j].color&&node[j].color!=node[k].color&&node[i].color!=node[k].color)) {
                            Max = max(Max,solve(i,j,k));
                        }
            }
        }
    }
    printf("%.5f\n",Max);
    }
    return 0;
}

 

 4.

[编程题] 有趣的排序

时间限制：1秒

空间限制：32768K

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

输入描述:

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

输出描述:

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

输入例子:

4
19 7 8 25

输出例子:

2

原始输入的数组str通过排序得到新的数组sub。通过二者的动态比较可以得到：a中按大小顺序已经站好位置的元素的个数，即元素移动中，不需要移动就可以归位的元素.
这些元素就不用管了。
那么剩下的元素个数就是必须经过移动才能归位的元素，即最小的移动次数。
按照这个思路，除了不需要动的元素以外，如果每次按照剩余元素从小到大的顺序依次取出，
比如例子19 7 8 25，7 8 不用动，现在剩余元素19,25，按照从小到大，依次放到末尾，一定可以拍好序，而次数就是这些剩余元素的个数

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;

int main()
{
//    freopen("in.txt","r",stdin);
    int n;
    int str[55];
    int sub[55];
    while(cin>>n) {
        for(int i = 0; i < n; i++) {
            cin>>str[i];
            sub[i]=str[i];
        }
        sort(sub,sub+n);
        int cnt = 0;
        int pos = 0;
        for(int i = 0; i < n; i++) {
            if(str[i]==sub[pos]) {
                pos++;
            }
        }
        cout<<n-pos<<endl;
    }
    return 0;
}

5.

[编程题] 不等式数列

时间限制：1秒

空间限制：32768K

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

输入描述:

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

输出描述:

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

输入例子:

5 2

输出例子:

66

这个思路也是下面评论一个大牛给的，思路就是枚举dp把，每层枚举四种情况，相加即可

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))

先把dp[2]写出来，然后递推把，按照题意dp[1]和dp[0]是不存在的，没有意义

#include <iostream>
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;
const int maxn = 1000+5;
int dp[maxn][maxn];

int main() {
    int n,k;
    while(cin>>n>>k) {
        dp[2][0] = 1;
        dp[2][1] = 1;
        for(int i = 3;i <= n; i++) {
            for(int j = 0; j <=k; j++) {
                if(j==0) dp[i][j] = 1;
                else {
                    dp[i][j] = (dp[i-1][j-1]*(i-j)+dp[i-1][j]*(j+1))%2017;
                }
            }
        }
        cout<<dp[n][k]<<endl;
    }
    }