nyoj 16 矩形嵌套 & nyoj 17 单调递增最长子序列

矩形嵌套

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 4

描述

有n个矩形，每个矩形可以用a,b来描述，表示长和宽。矩形X(a,b)可以嵌套在矩形Y(c,d)中当且仅当a<c,b<d或者b<c,a<d（相当于旋转X90度）。例如（1,5）可以嵌套在（6,2）内，但不能嵌套在（3,4）中。你的任务是选出尽可能多的矩形排成一行，使得除最后一个外，每一个矩形都可以嵌套在下一个矩形内。

输入

第一行是一个正正数N(0<N<10)，表示测试数据组数，
每组测试数据的第一行是一个正正数n，表示该组测试数据中含有矩形的个数(n<=1000)
随后的n行，每行有两个数a,b(0<a,b<100)，表示矩形的长和宽

输出

每组测试数据都输出一个数，表示最多符合条件的矩形数目，每组输出占一行

样例输入

1
10
1 2
2 4
5 8
6 10
7 9
3 1
5 8
12 10
9 7
2 2

先把几个矩形排序，然后从最大的矩形开始往前找，如果能嵌套进去，这个矩形的计数就+1.
那么现在问题来了。第一个可能被第二个套，也可能被第三个套，但是第二个和第三个你不知道谁以后被套的更多，
此时选二还是三呢？如果用暴力的话就把每一种可能都来一遍，看看谁更多。当然，这种方法时间复杂度太高，是不可行的。
所以这里就用到动态规划，因为从每一个矩形i开始，被套的最多的个数是一定的，所以就从倒数第二个开始，往下扫描，
可以嵌套的话就更新dp。这里需要注意从某一个点往下扫描的时候，可以嵌套的路径是多条，至于选择哪一条，就要看那一条的dp更大了，（可以想象成DAG图）
不能盲目的遇到可嵌套的就更新。状态转移方程：dp[i] = max(dp[i], dp[j]+1).

#include <stdio.h>
#include <algorithm>
using namespace std;
struct rec
{
    int x, y;
}r[1003];
int dp[1003];
int cmp(rec a, rec b)
{
    if(a.x < b.x)
        return 1;
    if(a.x ==  b.x && a.y < b.y)
        return 1;
    return 0;
}
int main()
{
    int t, i, n, ma, a, b, j;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(i = 0 ; i < n ; i++)
        {
            dp[i] = 1;
            scanf("%d %d", &a, &b);
            if(a < b)
                swap(a, b);
            r[i].x = a;
            r[i].y = b;
        }
        sort(r, r+n, cmp);
        for(i = n-2 ; i >= 0 ; i--)
            for(j = i+1 ; j <= n-1 ; j++)
        {
            if(r[i].x < r[j].x && r[i].y < r[j].y)
                dp[i] = max(dp[i], dp[j]+1);
        }
        ma = -1;
        for(i = 0 ; i < n ; i++)
            ma = max(ma, dp[i]);
        printf("%d\n", ma);
    }
    return 0;
}

单调递增最长子序列

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 4

描述

求一个字符串的最长递增子序列的长度
如：dabdbf最长递增子序列就是abdf，长度为4

输入

第一行一个整数0<n<20,表示有n个字符串要处理
随后的n行，每行有一个字符串，该字符串的长度不会超过10000

输出

输出字符串的最长递增子序列的长度

样例输入

3
aaa
ababc
abklmncdefg

样例输出

1
3
7

这个题和上面那个是一样的，上面那个是从后边往前走，先知道最后一个，慢慢推前边的，

这个用了从前往后走，先知道第一个，慢慢推后边的。（其实都是一回事。。。）

就是说第i位置的单调递增最长子序列的长度是  所有在这个位置前边的位置j、且j位置上的字母小于当前字母的 dp值 +1 ，也可以转化成一个DAG图。

状态转移方程：dp[i] = max(dp[i], dp[j]+1),其中j是小于i的且s[j]<s[i]的所有位置。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int dp[10005];
int main()
{
    int n, i, j, ans, l;
    char s[10005];
    scanf("%d", &n);
    while(n--)
    {
        scanf("%s", s);
        l = strlen(s);
        dp[0] = 1;
        ans = dp[0];//注意这里。如果ans全在循环里判断的话，就容易漏掉这个dp[0].比如只有一个字母的时候，答案就会错。
        for(i = 1 ; i < l ; i++)
        {
            dp[i] = 1;//开始把dp都附为1
            for(j = i-1 ; j >= 0 ; j--)
            {
                if(s[i] > s[j])
                    dp[i] = max(dp[i], dp[j]+1);
            }
            ans = max(ans, dp[i]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

还有一个 拦截导弹。一样的道理。不过这道题开始的时候忘记了比较max。。我去- -wa了好几次。还是考虑的不周全。

拦截导弹

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

描述

某国为了防御敌国的导弹袭击，发展中一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于等于前一发的高度。某天，雷达捕捉到敌国导弹来袭。由于该系统还在试用阶段，所以只用一套系统，因此有可能不能拦截所有的导弹。

输入

第一行输入测试数据组数N（1<=N<=10）
接下来一行输入这组测试数据共有多少个导弹m（1<=m<=20）
接下来行输入导弹依次飞来的高度，所有高度值均是大于0的正整数。

输出

输出最多能拦截的导弹数目

样例输入

2
8
389 207 155 300 299 170 158 65
3
88 34 65

样例输出

6
2

#include <stdio.h>
#include <algorithm>
using namespace std;
int dp[25], a[25];
int main()
{
    int t, n, i, j, ans;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        scanf("%d", &a[1]);
        dp[1] = 1;
        ans = 1;
        for(i = 2 ; i <= n ; i++)
        {
            scanf("%d", &a[i]);
            dp[i] = 1;
            for(j = i-1 ; j >= 1 ; j--)
            {
                if(a[j] > a[i])
                    dp[i] = max(dp[j]+1, dp[i]);
            }
            ans = max(ans, dp[i]);//最后一个不一定是最大的啊。。开始的时候直接没有比较，就是输出了dp[n] - -。如果是5 4 3 2 1 999 的话，dp[n]肯定不是最大的。。。
        }
        printf("%d\n", ans);
    }
    return 0;
}