拦截导弹（LIS，贪心，动态规划）：

//LIS解法，将导弹拦截问题转化为最长上升子序列问题（最长不递增子序列）
#include
#include
int Height[101];  //发射过来的导弹高度
int MaxLen[101];  //发射第i颗导弹处记录的最大不上升子序列的个数
int Maxint[101];  //用来记录发射第i颗导弹需要的最大拦截导弹系统的个数
void LIS(int k){  //拦截导弹问题即找出最长不上升子序列问题
	memset(MaxLen,0,sizeof(MaxLen));
	memset(Maxint,0,sizeof(Maxint));
	for(int i = 1;i <= k; i++){
		MaxLen[i] = 1;
        Maxint[i]=1;
		//遍历其前所有导弹高度
		for(int j = 1;j < i;j++){
			//如果当前导弹高度小于等于j号导弹
			if(Height[i] <= Height[j]){
				//把当前导弹放在j号导弹后，其最长不增子序列长度为j号导弹结尾的最长不增子序列长度 + 1
				int preMax = MaxLen[j] + 1;
				if(preMax > MaxLen[i]){
					MaxLen[i] = preMax;
				}
			}
			else{  //如果当前导弹高度大于j号导弹高度，那么我们就需要增加导弹系统拦截
                int preMaxint = Maxint[j] + 1;
				if(preMaxint > Maxint[i]){
					Maxint[i] = preMaxint;
				}
			}
		}
	}
}
int main()
{
	int N,i;  //N表示发射过来的导弹数量
	while(scanf("%d",&N)!=EOF){
		//输入导弹高度
		for(i = 1;i <= N;i++){
			scanf("%d",&Height[i]);
		}
		LIS(N);
		int Max = -1;
		int ans = -1;
		//输出最长不增子序列的长度即能拦截的导弹数
		for(i = 1;i <= N;i++){
			if(Max < MaxLen[i]){
				Max = MaxLen[i];
			}
			if(ans < Maxint[i]){
				ans = Maxint[i];
			}
		}
		if(N != 0){
			printf("%d  %d\n",Max,ans);
		}
	}
	return 0;
}
/*
    //用于解此题的还有动态规划和贪心算法求解：
    //动态规划求解：
    for(int i=1; i<=n; i++)
    {
        for(int j=0; j>x;int j;  //x表示导弹高度
    
            //利用sum表示当前至少有多少系统，并在每次导弹发射时遍历这些系统所能拦截的最大高度，
            //进行比较后如果能拦截，即x<=dp[j]则更新该系统的最大拦截高度值，否则则遍历下一个最大拦截高度值，
            //如果都没有，那么就是遍历到了最后，此时j=sum+1>sum，则增加一个新系统去拦截该导弹
    
            //这里每次都拿已有的最大高度值去和新发射的导弹高度值进行比较，
            //即从问题的初始状态出发，直接去求每一步的最优解，
            //通过若干次的贪心选择，最终得出整个问题的最优解（体现了贪心算法的思想）
    
            for(j=1;j<=sum;j++)
            {
                if(x<=dp[j])  //这里的dp[j]表示该系统在j处能拦截的最大高度
                {
                    dp[j]=x;  //更新该系统下一个能拦截的最大高度
                    break;
                }
            }
            if(j>sum) //前面的系统不能拦截
            {
                dp[++sum]=x;//新加一个系统并且赋值下一次能拦截的高度
            }
        }
        cout<

#include
#include 
using namespace std;
int arry[10][10];
int count=0;  //存储方案结果数量
bool check(int k,int j){  //判断节点是否合适（k代表行，j代表列）
    for(int i=0;i<8;i++){  //检查行列冲突（其实这里只检查列冲突即可，行是遍历来的，是不会产生冲突的）
         if(arry[i][j]==1){
            return false;
         }
    }
    for(int i=k-1,m=j-1; i>=0 && m>=0; i--,m--){  //检查左对角线
        if(arry[i][m]==1){
            return false;
        }
    }
    for(int i=k-1,m=j+1; i>=0 && m<=7; i--,m++){  //检查右对角线
        if(arry[i][m]==1){
            return false;
        }
    }
    return true;
}
void print(){  //打印结果
    cout<<"方案"<7){//八皇后的解
        count++;
        print();//打印八皇后的解
        return;
    }
    for(int m=0;m<8;m++){  //深度回溯,递归算法
        if(check(i,m)){  //检查皇后摆放是否合适
            arry[i][m]=1;
            findQueen(i+1);  //合适则置一，并往下递归调用求解
            arry[i][m]=0;  //清零，以免回溯的时候出现脏数据（这一步是找到结果之后进行的操作，防止影响下一个结果，恢复到上一步的初始状态）
        }
    }
}
int main() {
    findQueen(0);  //从第0行开始，如果是i，则表示前i行没有摆放的皇后，不会影响后面的排列，变成8-i个皇后在没有限制的8-i行寻找位置
    cout<<"八皇后问题共有："<

#include 
int F(int n)
{
    int i, s1 = 1, s2 = 1, s3 = 1;
    for (i = 3; i <= n; i++)
    {
        s3 = s1 + s2;
        if (s3 > 10007) 
            s3 -= 10007;
        s1 = s2;
        s2 = s3;
    }
    return s3;
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d", F(n));
    return 0;
}

#include 
using namespace std;
 int main()
 {
 	int L,M;
 	int num[10001]={0};
 	int n=0;
	cin>>L>>M;
	int a[100],b[100];
	for(int i=0;i>a[i]>>b[i];
		for(int j=a[i];j<=b[i];j++)
		{
			num[j]=1;
		}
	}
	for(int i=0;i<=L;i++)
	{
		if(num[i]==0)
		{
			n++;
		}
	}
	cout<