百度2017春招筆試真題編程題集合

1.買帽子

思路：直接排序數出第三個即可

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <vector>
 4 #include <algorithm>
 5 
 6 using namespace std;
 7 
 8 int main()
 9 {
10     int n;
11     int count = 1;
12     
13     cin >> n;
14     vector<int> nums(n);
 
15     
16     for (int i = 0; i < n; i++)
17         cin >> nums[i];
18        sort(nums.begin(), nums.end());
19     
20     for (int i = 1; i < n; i++)
21     {
22         if (nums[i] != nums[i - 1])
23         {
24             count++;
25             if (count == 3)
26             {
27
 
                 cout << nums[i] << endl;
28                 break;
29             }
30         }
31     }
32     if (count < 3)
33         cout << -1 << endl;
34     
35     return 0;
36 }

2.度度熊回家

思路：直接掃，先算出每個點經過的距離和，然後再減去除去每個點的情況判斷

 1 #include <iostream>
 2
 
 #include <cstdio>
 3 #include <vector>
 4 #include <algorithm>
 5 
 6 using namespace std;
 7 
 8 int main()
 9 {
10     int n;
11     int sum = 0;
12     int res = 99999999;
13     int num;
14     
15     cin >> n;
16     vector<int> nums(n);
17     
18     for (int i = 0; i < n; i++)
19         cin >> nums[i];
20     
21     for (int i = 1; i < n; i++)
22         sum += abs(nums[i] - nums[i - 1]);
23     for (int i = 1; i < n - 1; i++)
24     {
25         num = sum - abs(nums[i] - nums[i - 1]) - abs(nums[i + 1] - nums[i]) + abs(nums[i + 1] - nums[i - 1]);
26         res = min(res, num);
27     }
28     
29     cout << res << endl;
30     
31     return 0;
32 }

3.尋找三角形

思路：海倫公式：

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <vector>
 4 #include <cmath>
 5 #include <algorithm>
 6 
 7 using namespace std;
 8 
 9 struct point
10 {
11     char ch;
12     int x, y, z;
13 };
14 
15 double dis(point a, point b)
16 {
17     return sqrt(1.0 * (b.x - a.x) * (b.x - a.x) + 1.0 * (b.y - a.y) * (b.y - a.y) + 1.0 * (b.z - a.z) * (b.z - a.z));
18 }
19 
20 int main()
21 {
22     int n;
23     double s;
24     double res = 0.0;
25     
26     cin >> n;
27     vector<point> nums(n);
28     
29     for (int i = 0; i < n; i++)
30         cin >> nums[i].ch >> nums[i].x >> nums[i].y >> nums[i].z;
31     
32     for (int i = 0; i < n; i++)
33     {
34         for (int j = 0; j < n; j++)
35         {
36             if (i == j)
37                 continue;
38             
39             for (int k = 0; k < n; k++)
40             {
41                 if (k == j || k == i)
42                     continue;
43                 
44                 if ((nums[i].ch == nums[j].ch && nums[j].ch == nums[k].ch) || (nums[i].ch != nums[j].ch && nums[j].ch != nums[k].ch && nums[i].ch != nums[k].ch))
45                 {
46                     double dx = dis(nums[i], nums[j]);
47                     double dy = dis(nums[i], nums[k]);
48                     double dz = dis(nums[j], nums[k]);
49                     double p = (dx + dy + dz) / 2;
50                     s = sqrt(p * (p - dx) * (p - dy) * (p - dz));
51                     res = max(res, s);
52                 }
53             }
54         }
55     }
56     
57     printf("%.5lf\n", res);
58     
59     return 0;
60 }

4.有趣的排序

思路：按排序之後數前邊對應的位置有多少，然後n減就是改變的次數

 1 #include <iostream>
 2 #include <vector>
 3 #include <algorithm>
 4 
 5 using namespace std;
 6 
 7 int main()
 8 {
 9     int n;
10     
11     cin >> n;
12     vector<int> nums(n);
13     vector<int> num(n);
14     
15     for (int i = 0; i < n; i++)
16     {
17         cin >> nums[i];
18         num[i] = nums[i];
19     }
20     
21     sort(num.begin(), num.end());
22     int count = 0;
23     for (int i = 0; i < n; i++)
24     {
25         if (nums[i] == num[count])
26             count++;
27     }
28     cout << n - count << endl;
29     
30     return 0;
31 }

5.不等式數列

思路：此動態規劃思想來源於網上：

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

參考：http://blog.csdn.net/sb_ihateyou/article/details/71123479

 1 #include <iostream>
 2 #include <cstdio>
 3 
 4 using namespace std;
 5 
 6 int dp[1005][1005];
 7 
 8 int main()
 9 {
10     int n, k;
11 
12     cin >> n >> k;
13     
14     for(int i = 1; i <= n; i++)
15     {
16         for(int j = 0; j < n; j++)
17         {
18             if(j == 0) 
19                 dp[i][j] = 1;
20             else    
21                 dp[i][j] = (dp[i - 1][j - 1] * (i - j) + dp[i-1][j] * (j + 1)) % 2017;          
22         }
23     }
24     cout << dp[n][k] << endl;
25     
26     return 0;
27 }

牛客網