2017百度春季实习生五道编程题[全AC]

[编程题] 买帽子

时间限制：1秒
空间限制：32768K
度度熊想去商场买一顶帽子，商场里有N顶帽子，有些帽子的价格可能相同。度度熊想买一顶价格第三便宜的帽子，问第三便宜的帽子价格是多少？
输入描述:
首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）


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

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

输出例子:

30

#include<iostream>  
#include<algorithm>  
#include<unordered_map>
#include<string>
#include<vector>  
using namespace std;

int main() {
	vector<int>test(1001, 0);
	int n; cin >> n;
	while (n--) {
		int a; cin >> a;
		test[a] = 1;
	}
	int result = 0;
	for (int i = 0; i < 1001; ++i) {
		if (test[i] > 0) {
			if (result == 2) { cout << i << endl; return 0; }
			result++;
		}
	}
	cout << -1 << endl;

	//system("pause");	
	return 0;
}

[编程题] 度度熊回家

时间限制：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

#include<iostream>
#include<algorithm>  
#include<cmath>
using namespace std;
int main(){
    int n;cin>>n;
    int result=0;
    vector<int>temp(n,0);
    cin>>temp[0];
    for(int i=1;i<n;++i){
        cin>>temp[i];
        result+=abs(temp[i]-temp[i-1]);
    }
    int maxx=0;
    for(int i=1;i<temp.size()-1;++i){
        maxx=max(maxx,abs(temp[i]-temp[i-1])+abs(temp[i]-temp[i+1])-abs(temp[i+1]-temp[i-1]));
    }

    cout<<result-maxx<<endl;
}

[编程题] 寻找三角形

时间限制：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

#include<iostream>  
#include<algorithm>  
#include<unordered_map>
#include<cmath>
#include<string>
#include<vector>  
using namespace std;

double juli(vector<int>a, vector<int>b) {
	int a1 = a[0] - b[0];
	int a2 = a[1] - b[1];
	int a3 = a[2] - b[2];
	return sqrt((1.0*a1*a1) + (1.0*a2*a2) + (1.0*a3*a3));
}
double space(vector<int>a, vector<int>b, vector<int>c) {
	double a1 = juli(a, b);
	double a2 = juli(a, c);
	double a3 = juli(b, c);
	double p = (a1 + a2 + a3) / 2.0;
	return sqrt(1.0*p*(p - a1)*(p - a2)*(p - a3));
}
int main() {
	int N; cin >> N;
	double result = 0;
	vector<vector<int>>R;
	vector<vector<int>>G;
	vector<vector<int>>B;
	while (N--) {
		char temp; vector<int>a(3,0);
		cin >> temp>>a[0]>>a[1]>>a[2];
		if (temp == 'R')R.push_back(a);
		else if (temp == 'G')G.push_back(a);
		else if (temp == 'B')B.push_back(a);	
	}
	if (R.size() >= 3) {
		for (int i = 0; i < R.size() - 2; ++i) {
			for (int j = i + 1; j < R.size() - 1; ++j) {
				for (int z = j + 1; z < R.size(); ++z) {
					result = std::max(result, space(R[i], R[j], R[z]));
				}
			}
		}
	}
	if (G.size() >= 3) {
		for (int i = 0; i < G.size() - 2; ++i) {
			for (int j = i + 1; j < G.size() - 1; ++j) {
				for (int z = j + 1; z < G.size(); ++z) {
					result = std::max(result, space(G[i],G[j], G[z]));
				}
			}
		}
	}
	if (B.size() >= 3) {
		for (int i = 0; i < B.size() - 2; ++i) {
			for (int j = i + 1; j <B.size() - 1; ++j) {
				for (int z = j + 1; z < B.size(); ++z) {
					result = std::max(result, space(B[i], B[j], B[z]));
				}
			}
		}
	}
	if (R.size() && G.size() && B.size()) {
		for (int i = 0; i < R.size(); ++i) {
			for (int j = 0; j < G.size(); ++j) {
				for (int z = 0; z < B.size(); ++z) {
					result = max(result, space(R[i], G[j], B[z]));
				
				}
			
			}
		}
	}
	printf("%.5f", result);
//	system("pause");
}

[编程题] 有趣的排序

时间限制：1秒
空间限制：32768K
度度熊有一个N个数的数组，他想将数组从大到小排好序，但是萌萌的度度熊只会下面这个操作：
任取数组中的一个数然后将它放置在数组的最后一个位置。
问最少操作多少次可以使得数组从小到大有序？
输入描述:
首先输入一个正整数N，接下来的一行输入N个整数。(N <= 50, 每个数的绝对值小于等于1000)


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

输入例子:
4
19 7 8 25

输出例子:
2

思路：

例如 19 7  8  25 的正确顺序是7 8 19 25  可以发现7-8顺序是对的，但8-17是错的，所以只能保持7-8不变，其余的都需要动，所以是4-2次

同理，如果一个n个数字组成的序列，从小到大，前m个是稳定的，那么最终结果就是n-m

#include<iostream>
#include<algorithm>  
#include<vector>
#include<map>
using namespace std;
int main(){
    int n;cin>>n;
    vector<int>temp(n,0);
    map<int,int>mapping;
    for(int i=0;i<n;++i){
        cin>>temp[i];
        mapping[temp[i]]=i;
    }
    sort(temp.begin(),temp.end());
    int i=0;
    while(i+1<=n-1&&mapping[temp[i]]<mapping[temp[i+1]]){
        ++i;
    }
    cout<<n-i-1<<endl;
}

[编程题] 不等式数列

时间限制：1秒
空间限制：32768K
度度熊最近对全排列特别感兴趣,对于1到n的一个排列,度度熊发现可以在中间根据大小关系插入合适的大于和小于符号(即 '>' 和 '<' )使其成为一个合法的不等式数列。但是现在度度熊手中只有k个小于符号即('<'')和n-k-1个大于符号(即'>'),度度熊想知道对于1至n任意的排列中有多少个排列可以使用这些符号使其为合法的不等式数列。
输入描述:
输入包括一行,包含两个整数n和k(k < n ≤ 1000)


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

输入例子:
5 2

输出例子:
66

动态规划问题…………参考了博客

#include <iostream>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <map>
#include <limits.h>

using namespace std;

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