队伍的水平值等于该队伍队员中第二高水平值，为了所有队伍的水平值总和最大的解法，也就是说每个队伍的第二个值是尽可能大的值。所以实际值把最大值放到最右边，最小是放到最左边。
【解题思路】：
本题的主要思路是贪心算法，贪心算法其实很简单，就是每次选值时都选当前能看到的局部最优解，所以这里的贪心就是保证每组的第二个值取到能选择的最大值就可以，我们每次尽量取最大，但是最大的数不可能是中位数，所以退而求其次，取每组中第二大的
例如 现在排序后 有 1 2 5 5 8 9 ，那么分组为1 8 9 和 2 5 5
关系arr[arr.length-2*(i+1)

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
    // IO型OJ可能会有多组测试用例，所以这里要持续接收输入多组测试用例。
    int n;
    while (cin >> n)
    {
        long long sum = 0;
        vector<int> a;
        a.resize(3 * n);
        for (int i = 0; i < (3 * n); i++)
        {
            cin >> a[i];
        }
        std::sort(a.begin(), a.end());
        for (int i = 0; i < n; i++) {
            sum += a[a.size() - (2 * (i + 1))];
        }
        cout << sum << endl;
    }
}

【答案解析】

解题思路：

1. 本题依次比较整个数组
2. a[i+1]>a[i] ，则进入非递减序列判断，直到遍历到下一个值不大于等于为止count++，然后进行下一位置的判断
3. a[i+1]<a[i]，则进入非递增序列判断，直到遍历到下一个值不小于等于为止count++，然后进行下一位置的判断
4. a[i+1] == a[i]不进行操作，++i进行下一位置遍历，因为相等既可以属于非递增序列，也可以属于非递减 序列。
   本题注意点：本题开始比较a[i+1]与a[i]进行比较，为了避免越界，数组定义为n+1个，同时给a[n] = 0; a[n] =0带来的影响，我们分为三种情况讨论：
5. 若到a[n-1] 的最后一组是非递减序列，当i==n-1，a[i] >a[i+1]，因为前面的数都是大于0的，这个输入条件已经说明了(去看看题目输入条件描述)，里面的循环结束，i++，count++，i==n，外面的循环结束。
6. 若到a[n-1] 的最后一组是非递增序列，当i==n-1，a[i] >a[i+1]，因为前面的数都是大于0的，这个输入条件已经说明了(去看看题目输入条件描述)，循环再走一次，i++， i== n，里面的循环结束，i++，count++，i==n+1，外面的循环结束。
7. 第三种情况 1 2 1 2 1最后一个数是单独的情况，后面补个0，序列变成1 2 1 2 1 0，当走完全面的序列 i==n-1时，a[i] > a[i+1],进入判断出一个非递增序列，count++，i++,循环结束。
8. 也就是说数组最后一个位置多增加一个0，不会影响第1、2情况的判断，主要是帮助第3情况的正确判断。

#include<iostream>
#include<vector> 
using namespace std;
 
// 本题牛客测试用例不全，至少应该增加以下两组测试用例
// 输入： 
// 4
// 1 3 2 3 
// 输出：2
 
// 输入： 
// 6 
// 3 2 1 1 2 3 
// 输出：2

#include <iostream>
using namespace std;

int main() 
{
    int n = 0;
    cin>>n;
    int arr[n+1];
    for(int i=0;i<n;i++)
    {
        cin>>arr[i];
    }
    arr[n] = 0;
    int i = 0;
    int count = 0;
    while(i<n)
    {
        if(arr[i]<arr[i+1])
        {
            while(i<n && arr[i]<=arr[i+1])
            {
                ++i;
            }
            count++;
            ++i;
        }
        else if(arr[i] == arr[i+1])
        {
            ++i;
        }
        else
        {
            while(i<n && arr[i]>=arr[i+1])
            {
                ++i;
            }
            count++;
            ++i;
        }
    }
    cout << count << endl;
    return 0;
}

【答案解析】

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

int main()
{
    string s1;
    getline(cin, s1);
    auto start = s1.begin();
    auto end = start;
    for (int i = 0; i < s1.size(); i++)
    {
        if (*(end + i) == ' ')
        {
            reverse(start, end + i);
            start = end + i + 1;
        }
    }
    reverse(start, s1.end());
    reverse(s1.begin(), s1.end());
    cout << s1.c_str() << endl;
    return 0;
}

【解题思路1】：
先将整个字符串逆置过来，再遍历字符串，找出每个单词，对单词逆置。这里我们使用了stl算法中的reverse，所以这里使用迭代器遍历string

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
    string s;
    // 注意这里要使用getline，cin>>s遇到空格就接收结束了
    getline(cin, s);
    // 翻转整个句子
    reverse(s.begin(), s.end());
    // 翻转单词
    auto start = s.begin();
    while (start != s.end())
    {
        auto end = start;
        while (end != s.end() && *end != ' ')
            end++;
        reverse(start, end);
        if (end != s.end())
            start = end + 1;
        else
            start = end;
    }
    cout << s << endl;
    return 0;
}

【解题思路2】：
第二思路是一个比较讨巧的思路，直接利用cin>>s接收输入，遇到空格就结束了，自然就分割开了每个单词，其次将每次接收到的单词拼接到之前串的前面就逆置过来了

#include <iostream>
#include <string>
using namespace std;
// cin读取string时自动会被空格分隔开，用另一个字符串存储进行逆序输出
int main()
{
    string s1, s2;
    cin >> s2;
    while (cin >> s1)
        s2 = s1 + " " + s2;
    cout << s2 << endl;
    return 0;
}

【答案解析】：
【解题思路】：
本题思路很简单，首先想清楚原理：N进制数，每个进制位的值分别是X0* N ^ 0，X1 * N ^ 1, X2* N ^ 2…，X0，X1，X2就是这些进制位的值，就是就是进行取模余数就是当前低进制的位的值是多少，通过除掉进制数，进入下一个进制位的计算。

#include <iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
    string s, table = "0123456789ABCDEF";
    int m, n;
    cin >> m >> n;
    bool flag = false;
    // 如果是负数，则转成正数，并标记一下
    if (m < 0)
    {
        m = 0 - m;
        flag = true;
    }
    // 按进制换算成对应的字符添加到s
    while (m)
    {
        s += table[m % n];
        m /= n;
    }
    if (flag)
        s += '-';
    reverse(s.begin(), s.end());
    cout << s << endl;
    return 0;
}