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

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

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

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

#include<iostream>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
#include<algorithm>
#include<list>
#include<stack>
using namespace std;
int a[55]={0};
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    sort(a,a+n);
    int num=0;
    for(int i=0;i<n;++i){
        if(i==0||a[i]>a[i-1]){
            num++;
        }
        if(num==3){
            cout<<a[i]<<endl;
            return 0;
        }
    }
    cout<<-1<<endl;
    return 0;
}

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

输入描述:
输入一个正整数N, N <= 50。接下来N个整数表示坐标，正数表示X轴的正方向，负数表示X轴的负方向。绝对值小于等于100

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

#include<iostream>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
#include<algorithm>
#include<list>
#include<stack>
using namespace std;
int a[55]={0};
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>a[i];
    }
    int max=0;
    int del=1;
    for(int i=1;i<n-1;++i){
        int cur=abs(a[i]-a[i-1])+abs(a[i]-a[i+1])-abs(a[i-1]-a[i+1]);
        if(cur>max){
            max=cur;
            del=i;
        }
    }
    int s=0;
    for(int i=1;i<n;++i){
        if(i==del){
            continue;
        }else if(i-1==del){
            s+=abs(a[i]-a[i-2]);
        }else{
            s+=abs(a[i]-a[i-1]);
        }
    }
 
    cout<<s<<endl;
    return 0;
}

 

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

输入描述:
首先输入一个正整数N三维坐标系内的点的个数.(N <= 50) 接下来N行，每一行输入 c x y z，c为'R', 'G', 'B' 的其中一个。x，y，z是该点的坐标。(坐标均是0到999之间的整数)

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

#include<iostream>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
#include<algorithm>
#include<list>
#include<stack>
using namespace std;
 
double culs(double a,double b,double c){
    double p=(a+b+c)/2;
    return sqrt(p*(p-a)*(p-b)*(p-c));
}
int n;
struct P{
    double x;
    double y;
    double z;
    char c;
}tri[55];
int main()
{
     
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>tri[i].c>>tri[i].x>>tri[i].y>>tri[i].z;
    }
    double max=0;
    for(int i=0;i<n;++i){
        for(int j=i+1;j<n;++j){
            for(int k=j+1;k<n;++k){
                if((tri[i].c==tri[j].c&&tri[j].c==tri[k].c)||(tri[i].c!=tri[j].c&&tri[j].c!=tri[k].c&&tri[i].c!=tri[k].c)){
                    double a=sqrt((tri[i].x-tri[j].x)*(tri[i].x-tri[j].x)+(tri[i].y-tri[j].y)*(tri[i].y-tri[j].y)+(tri[i].z-tri[j].z)*(tri[i].z-tri[j].z));
                    double b=sqrt((tri[i].x-tri[k].x)*(tri[i].x-tri[k].x)+(tri[i].y-tri[k].y)*(tri[i].y-tri[k].y)+(tri[i].z-tri[k].z)*(tri[i].z-tri[k].z));
                    double c=sqrt((tri[k].x-tri[j].x)*(tri[k].x-tri[j].x)+(tri[k].y-tri[j].y)*(tri[k].y-tri[j].y)+(tri[k].z-tri[j].z)*(tri[k].z-tri[j].z));
                    double s=culs(a,b,c);
                    if(s>max){
                        max=s;
                    }
                }
                 
            }
        }
    }
     
    cout<<fixed<<setprecision(5)<<max<<endl;
    return 0;
}

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

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

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

/*
 对于一个数，如果其后面有比它小的数，那么就一定要进行一次将它放到最后面的操作。从最小的数开始对每个数进行一次这样的检查和操作即可。
*/
#include<iostream>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
#include<algorithm>
#include<list>
#include<stack>
using namespace std;
int a[55]={0};
int n;
int b[55]={0};
int main()
{
    cin>>n;
    for(int i=0;i<n;++i){
        cin>>a[i];
        b[i]=a[i];
    }
    sort(b,b+n);
    int num=0;
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            if(a[j]==b[i]){
                bool tag=false;
                for(int k=j+1;k<n;++k){
                    if(a[k]<a[j]){
                        tag=true;
                    }
                }
                if(tag) {
                    num++;
                    int tmp=a[j];
                    for(int t=j;t<n-1;++t){
                        a[t]=a[t+1];
                    }
                    a[n-1]=tmp;
                    j--;
                }
            }
        }
    }
    cout<<num<<endl;
    return 0;
}

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

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

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

/*
用动态规划，dp[i][j]表示有i个数且有j个小于号的排列的个数，
考虑i个数的情况,可以看成是在i-1个数的基础上添加一个最大的数i，这个数有四种方法：
(1)放在开头，相当于添加了一个加号，共有dp[i-1][j]种
(2)放在结尾，相当于添加了一个减号，共有dp[i-1][j-1]种
(3)放在原先的减号中间，相当于多了一个加号，共有dp[i-1][j]*j种
(4)放在原先的加号中间，相当于多了一个减号共有dp[i-1][j-1]*((i-1-1)-(j-1))=dp[i-1][j-1]*(i-j-1)种。

以上四种综合得转移方程：dp[i][j]=dp[i-1][j]*(j+1)+dp[i-1][j-1]*(i-j);
*/

#include<iostream>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
#include<algorithm>
#include<list>
#include<stack>
using namespace std;
int dp[1005][1005];
int main()
{
     
    int n,k;
    while(cin>>n>>k){
        memset(dp,0,sizeof(dp));
        dp[1][0]=1;
        for(int i=2;i<=n;++i){
            for(int j=0;j<i;++j){
                if(j==0){
                    dp[i][j]=1;
                }else{
                    dp[i][j]=((j+1)*dp[i-1][j]+(i-j)*dp[i-1][j-1])%2017;
                }
            }
        }
        cout<<dp[n][k]<<endl;
    }
     
    return 0;
}