解析：暴力解法，一个一个遍历和比较，如1 2 3 3 2 1，最开始先拿1和2比较，再比较2和3，依次向后进行比较；当非递增非递减序列停止的时候count++。注意为了避免a[i+1]的越界，我们在数组后加一个零，因为由题干可知，所有的数据都比0大且0在第n个位置，所以不会对结果有影响。

从这道题可以抽象出来一个模型：在一个数组中截取一段连续的性质相同的序列，可以采用while–if–while模型。

while(A)
{
if(B)
{
   while(A&&B)
   {
     ++i;
   }
}
if(C)
{
   while(A&&C)
   {
     ++i;
   }
}
//.......
}

该模型的意思是，找到同时满足A和B的序列，其中A为i前进条件，B为元素所满足的条件。当序列中下一个元素不满足B的时候，同时退出while与if语句。方便查找满足另一个条件C的序列。

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    int n = 0;
    cin >> n;
    vector<int> arr;
    //多开辟一个空间，防止越界情况的发生
    arr.resize(n+1);
    int i = 0;
    int count = 0;
    for(int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    i = 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;
    return 0;
}

答案解析：基本思路和上面一样

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
int main()
{
    int n;
    cin >> n;
    // 注意这里多给了一个值，是处理越界的情况的比较，具体参考上面的解题思路
    vector<int> a;
    a.resize(n + 1);//这里有个坑，这个题越界了牛客测不出来，给n,并且不写a[n] = 0;不会报错，但是最好写上
    a[n] = 0;
    //读入数组
    int i = 0;
    for (i = 0; i < n; ++i)
        cin >> a[i];
    i = 0;
    int count = 0;
    while (i < n)
    {
        // 非递减子序列
        if (a[i] < a[i + 1])
        {
            while (i < n && a[i] <= a[i + 1]){
                i++;
            }
            count++;
            i++;
        }
        else if (a[i] == a[i + 1])
        {
            i++;
        }
        else // 非递增子序列
        {
            while (i < n && a[i] >= a[i + 1]){
                i++;
        	}
            count++;
            i++;
        }
    }
    cout << count << endl;
    return 0;
}

解析：整体思路可以先将整个字符串逆置，再从前往后依次将每个单词逆置。使用string类中的getline函数输入字符串，再使用reverse函数将整个字符串逆置，这个函数有两个参数，参数为迭代器这里可以将迭代器理解为指针，``reverse函数要带上头文件algorithm。如上面示例，整个字符串逆置之后为.gnijieb ekil I`，再依次将每个单词逆置。注意不能越界。

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main() {
    string s1;
    getline(cin,s1);//输入字符串
    //s1.begin()代表字符串开始位置，s1.end()代表字符串结束位置，这里可以将迭代器理解为指针，那么在字符串.gnijieb ekil I中s1.begin()指向开始位置'.'，s1.end()指向字符串结尾即指向'\0'位置。
    reverse(s1.begin(),s1.end());//迭代器为左闭右开，即[s1.begin(),s1.end())，所以逆置的时候不包括'\0'
    for(int i = 0; i < s1.size(); i++)
    {
        int tmp = i;//tmp记录每次逆置的开始位置
        while(i < s1.size() && s1[i] != ' ')//当s1[i] == ' '时或者当i < s1.size()，结束循环，进行逆置
        {
            i++;
        }
        
        //逆置，字符串.gnijieb ekil I 
        //第一次逆置tmp = 0，i = 8，即s1[i] == ' '，左闭右开，即对[0,7]之间的字符串逆置，逆置之后字符串为beijing. ekil I;
        //第二次逆置，tmp = 9,i = 13,即s1[i] == ' '，左闭右开,即对[9,12]之间的字符串逆置，逆置之后字符串为beijing. like I;
        //第三次逆置，tmp = 14,i = 15,即i < s1.size()不成立，对[14]这个字符串进行处理，逆置之后字符串为beijing. like I;
        reverse(s1.begin() + tmp,s1.begin() + i); //左闭右开
    }
    cout << s1;
}

答案解析：

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

思路二：直接利用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;
}