导弹防御系统（dfs+贪心）

题意：
为了对抗附近恶意国家的威胁，R国更新了他们的导弹防御系统。

一套防御系统的导弹拦截高度要么一直 严格单调 上升要么一直 严格单调 下降。

例如，一套系统先后拦截了高度为3和高度为4的两发导弹，那么接下来该系统就只能拦截高度大于4的导弹。

给定即将袭来的一系列导弹的高度，请你求出至少需要多少套防御系统，就可以将它们全部击落。

输入格式
输入包含多组测试用例。

对于每个测试用例，第一行包含整数n，表示来袭导弹数量。

第二行包含n个不同的整数，表示每个导弹的高度。

当输入测试用例n=0时，表示输入终止，且该用例无需处理。

输出格式
对于每个测试用例，输出一个占据一行的整数，表示所需的防御系统数量。

数据范围
1≤n≤50
输入样例：
5
3 5 2 4 1
0
输出样例：
2
样例解释
对于给出样例，最少需要两套防御系统。

一套击落高度为3,4的导弹，另一套击落高度为5,2,1的导弹。

思路就是：
搜索 枚举每一个数然后归纳到一个上升还是下降的序列里面， 这里在归纳的时候可以利用贪心思想进行归纳

#include  <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 60;
int n ;
int up[N], down[N];
int g[N];
bool dfs(int depth , int u , int su , int sd)
{
   
    if(su + sd > depth) return false;
     if(u == n ) return true;
    //枚举上升序列
    bool flag = false;
     for(int i = 1 ; i <= su ; i ++)
     
         if(up[i] < g[u])
         {
             int t = up[i];
             up[i] = g[u];
             if(dfs(depth,u+1,su,sd)) return true;
             up[i] = t;
             flag = true;
             break;
         }
         
     
     
     if(!flag)
     {
         up[su + 1] = g[u];
         if(dfs(depth,u+1,su+1, sd)) return true;
     }
    //枚举下降序列
    
    flag = false;
    
    for(int i = 1; i <= sd ; i ++)
    
       if(down[i] > g[u])
        {
            int t = down[i];
            down[i] = g[u];
            if(dfs(depth,u+1,su , sd)) return true;
            down[i] = t;
            flag= true;
            break;
        }
        
        
    
    
    if(!flag){
        down[sd+1] = g[u];
        if(dfs(depth,u+1,su,sd + 1)) return true;
    }
    return false;
}

int main()
{
  
    while(  cin >> n , n)
    {
        for(int i = 0 ; i < n ; i ++)
        cin >> g[i];
        
        int depth = 0 ; 
        while(!dfs(depth,0,0,0)) depth++;
        
        cout << depth << endl;
    }
    
    return 0;
}