poj-1836

最新推荐文章于 2020-11-27 12:02:51 发布
最新推荐文章于 2020-11-27 12:02:51 发布
阅读量470 收藏 1
点赞数
分类专栏： POJ DP 文章标签： poj DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyfcauc/article/details/38122249
版权
POJ 同时被 2 个专栏收录
233 篇文章 0 订阅
订阅专栏
DP
22 篇文章 0 订阅
订阅专栏 
//380K 79MS    G++
#include <cstdio>
#include <cstring>

using namespace std;

double soldiers[1005];

struct soldierInfo{
    double prevHeight;
    int num;
};

typedef struct soldierInfo soldierInfo;

soldierInfo aux[1005];

int tmpSolider[1002];

int soldierNum;

int lengthMAX;

#define INF 999999

// void solve() {
//     int beginSoldierId = 1;
//     lengthMAX = -INF;
//     memset(aux, 0, sizeof(aux));
//     while(1) {
//         if (beginSoldierId > soldierNum){
//             break;
//         }
//         int thisTimeSoldierNum = 0;
//         if (aux[beginSoldierId].num == 0) {
//             printf("C %d", beginSoldierId);
//             int i = 0;
//             aux[beginSoldierId].num = 1;
//             aux[beginSoldierId].prev
//             tmpSolider[thisTimeSoldierNum++] = beginSoldierId;
//             for (i = beginSoldierId; i <= soldierNum; i++) {
//                 if (soldiers[i] < soldiers[beginSoldierId]) {
//                     if (aux[i].num > 0) {
//                         for (int i = 0; i < thisTimeSoldierNum; i++) {
//                             int soldierId = tmpSolider[i];
//                             aux[soldierId].num = thisTimeSoldierNum - i + aux[i].num;
//                         }
//                         break;
//                     } else {
//                         tmpSolider[thisTimeSoldierNum++] = i;
//                         // thisTimeSoldierNum++;
//                     }
//                 }
//             }
//             if (i == soldierNum + 1) {
//                 printf("B %d\n", beginSoldierId);
//                 for (i = 0; i < thisTimeSoldierNum; i++) {
//                     printf("V %d %d\n", tmpSolider[i], thisTimeSoldierNum - i);
//                     int soldierId = tmpSolider[i];
//                     aux[soldierId].num = thisTimeSoldierNum - i;
//                 }
//             }
//         }
//         printf("%d %d\n", aux[beginSoldierId].num, beginSoldierId);
//         lengthMAX = lengthMAX > aux[beginSoldierId].num ? lengthMAX : aux[beginSoldierId].num;
//         beginSoldierId++;
//     }
//     printf("%d\n", soldierNum - lengthMAX);
// }

int DP[1005];
int DP2[1005];

int solve2() {

    memset(DP, 0, sizeof(DP));
    memset(DP2, 0, sizeof(DP2));

    // jiang
    for (int i = soldierNum; i >= 1; i--) {
        if (i == soldierNum) {
            DP[i] = 1;
        } else {
            int MAXLEN = 1;
            for (int j = i+1; j <= soldierNum; j++) {
                // printf("%d %d %lf %lf\n", i, j, soldiers[i], soldiers[j]);
                if (soldiers[j] < soldiers[i]) {
                    int length = DP[j] + 1;
                    MAXLEN = MAXLEN > length ? MAXLEN: length;
                }
            }
            DP[i] = MAXLEN;
        }
        // printf(" < %d %d\n", DP[i], i);
    }

    //sheng
    for (int i = 1; i <= soldierNum; i++) {
        if (i == 1) {
            DP2[i] = 1;
        } else {
            int MAXLEN2 = 1;
            for (int j = 1; j <= i-1; j++) {
                // printf("%d %d %lf %lf\n", i, j, soldiers[i], soldiers[j]);
                if (soldiers[j] < soldiers[i]) {
                    int length = DP2[j] + 1;
                    MAXLEN2 = MAXLEN2 > length ? MAXLEN2: length;
                }
            }
            DP2[i] = MAXLEN2;
        }
        // printf(" > %d %d\n", DP2[i], i);
    }

    int MAXLEN3 = DP2[soldierNum] > DP[1] ? DP2[soldierNum] : DP[1];
    // printf("%d\n", MAXLEN3);

    if (soldierNum >= 3) {
        for (int split = 2; split <= soldierNum-1; split++) {
            // memset(DP, 0, sizeof(DP));
            // memset(DP2, 0, sizeof(DP2));
            // //jiang
            // int maxlength1 = 0;
            // int jiangBegin = split;
            // for (int i = soldierNum; i >= split + 1; i--) {
            //     if (soldiers[i] < soldiers[split]) {
            //         if (i == soldierNum) {
            //             DP[i] = 1;
            //         } else {
            //             int MAXLEN = 1;
            //             for (int j = i+1; j <= soldierNum; j++) {
            //                 // printf("%d %d %lf %lf\n", i, j, soldiers[i], soldiers[j]);
            //                 if ((soldiers[j] < soldiers[i]) &&
            //                     (soldiers[j] < soldiers[split]) &&
            //                     (soldiers[i] < soldiers[split])) {
            //                     int length = DP[j] + 1;
            //                     MAXLEN = MAXLEN > length ? MAXLEN: length;
            //                 }
            //             }
            //             DP[i] = MAXLEN;
            //         }
            //     }
            //     if (maxlength1 < DP[i]) {
            //         maxlength1 = DP[i];
            //         jiangBegin = i;
            //     }
            //     // maxlength1 = DP[i] > maxlength1 ? DP[i]: maxlength1;
            //     // printf(" > %d %d\n", DP[i], i);
            // }

            // //sheng
            // int maxlength2 = 0;
            // int shengEnd = split;
            // for (int i = 1; i <= split-1; i++) {
            //     if (soldiers[i] < soldiers[split]) {
            //         if (i == 1) {
            //             DP2[i] = 1;
            //         } else {
            //             int MAXLEN2 = 1;
            //             for (int j = 1; j <= i-1; j++) {
            //                 // printf("%d %d %lf %lf\n", i, j, soldiers[i], soldiers[j]);
            //                 if ((soldiers[j] < soldiers[i]) &&
            //                     (soldiers[j] < soldiers[split]) &&
            //                     (soldiers[i] < soldiers[split])) {
            //                     int length = DP2[j] + 1;
            //                     MAXLEN2 = MAXLEN2 > length ? MAXLEN2: length;
            //                 }
            //             }
            //             DP2[i] = MAXLEN2;
            //         }
            //     }
            //     if (maxlength2 < DP2[i]) {
            //         maxlength2 = DP2[i];
            //         shengEnd = i;
            //     }
            //     // maxlength2 = DP2[i] > maxlength2 ? DP2[i]: maxlength2;
            //     // printf(" < %d %d\n", DP2[i], i);
            // }

            int maxlength1 = 0;
            int maxlength2 = 0;
            int jiangBegin = split;
            int shengEnd = split;
            //sheng
            for (int i = 1; i <= split-1; i++) {
                if (soldiers[split] > soldiers[i]) {
                    if (maxlength1 < DP2[i]) {
                        shengEnd = i;
                        maxlength1 = DP2[i];
                    }
                }
            }

            //jiang
            for (int i =soldierNum; i >= split+1; i--) {
                if (soldiers[split] > soldiers[i]) {
                    if (maxlength2 < DP[i]) {
                        jiangBegin = i;
                        maxlength2 = DP[i];
                    }
                }
            }

            int heightEqualNum = 0;
            int heightEqualNum1 = 0;
            for (int i = shengEnd + 1; i <= jiangBegin -1; i++) {
                if (soldiers[i] == soldiers[split]) {
                    heightEqualNum++;
                    if (heightEqualNum >=2) {
                        heightEqualNum1 = 1;
                        break;
                    }
                }
            }
            // printf("%d %d\n", shengEnd, jiangBegin);
            // printf("%d %d %d %d\n", split, maxlength1, maxlength2, heightEqualNum);
            int tmpMAXLEN = maxlength1 + maxlength2 + 1 + heightEqualNum1;
            MAXLEN3 = tmpMAXLEN > MAXLEN3 ? tmpMAXLEN: MAXLEN3;
            // printf("%d %d\n", split, MAXLEN3);
        }
    }

    printf("%d\n", soldierNum - MAXLEN3);
}

int main() {
    while(scanf("%d", &soldierNum) !=EOF) {
        for (int i = 1; i <= soldierNum; i++) {
            scanf("%lf", &soldiers[i]);
        }
        // solve();
        solve2();
    }
}

发现自己现在对DP又有点手生了，连基本的最长递增序列的求法都给忘了。

这道题难不在DP本身，而在于一些细节处理，题目的要求比较苛刻：

调整队列以后，每个士兵都能至少看到最左边或者最右边的人，注意，是或者，并且又是左右两边，这样就不是一个单纯的求最长递增/递减序列了，

因为可以在中间找一个最高的士兵，然后向两边递减，这就成了一个最长递增序列和最短递增序列的组合了

比如 对于队列 S：

3 4 5 1 2 5 4 3
这组队列可以这样排：

3 4 5 4 3, 最高的士兵5在中间，然后向左与右递减，但是，注意了，这还不是最优的解！因为题目只要求了能看到最左/最右，那么可以这么排：

3 4 5 5 4 3,

这样排，两个身高为5的士兵在中间，分别可以看到最左/右，是一个最优解（最长的队列）。

这样，考虑到这些因素，本题就变得有些麻烦了，

先要对整个数组求一次 最长递增/递减序列， 

相应的DP数组:

DP1[]对应递增，DP1[i] 表示 以S[i] 结尾的（从S[1]开始的）递增序列的最长长度。

DP2[]对应递减，DP2[i]表示 以S[i]开头的（以S[N]结束的）递减序列的最长长度，

可以得到这两种方式下的最长序列 LX LY，

然后还有枚举每个士兵，考虑以此士兵最为最后队列的中间最高者进行求队列长度，

如果以士兵 i 作为中间最高者，那么就要求其左边的最长递增序列和右边的最长递减序列，要注意的是，这里的递增序列最大值不能搞过S[i]， 同样递减序列最大值也不能超过S[i], 我在这里犯迷糊了，还又重新求了一次递增和递减，其实根本不用的，因此之前的DP1和DP2已经包含了这个信息：

对于S[i]左边， 只需求出最大的DP1[j], 且S[j] <S[i] 即可，同样，右边，只需求出最大的DP2[j], S[j] < S[i]即可，

还有一个细节： 因为要考虑 i左边/右边可以有一个和自己一样身高的士兵（只能一边有，不能两边都有），

这个一样身高的士兵，如果有的话，且符合题目需求的话，必然在最后的队列是和i紧挨的（不挨的话，就不可能递增/递减了）, 因此，

设i 左边的最长递增序列的结束位置是 left, i右边的最长递减序列的开始位置是 right,

那么 如果有符合条件的同样身高士兵m, 那么分布只能是这样的：

....left.....m.....i.....right 或  .....left....i....m.....right, 

通过这个就可以检测是否有士兵m了，遍历从 left+1 到 right-1的序列，如果有 >1（包含 i 本身，因此要>1表示除了i还有别的一样身高的士兵）个 和i同样身高的士兵，那么就有m存在，但只能选择一个m（如果有两个m，就不满足题了）， 

到了这一步，基本完成了，但还有个细节， 如果 左边/右边的最长递增/递减 序列有多个同等长度的最长序列，那么left 和 right应该 选择 left最小 ，right最大的序列，

这样能保证挑选m的序列最长，如果有m存在，就一定能找到. 还有就是考虑i在最左和最右的情况了， 这时候，左边/右边有一边不用考虑，

左边最长递增序列长度L1和和右边最长递减序列长度L2的初始值要是0（比如 5 6 9, 选6做i的话，左边，右边都没有比i小的递增/递减序列）

最后的长度是 L1 + L2 + 1 （如果有m存在） + 1(i 本身就是最终序列的一部分)


结合之前的LX LY ，以及遍历每个点的最后长度，找到的最长序列就是最终序列，

要出列的人数，就是原来队列长度减去最终序列长度即可.

这道题很考察细节，以后应该多练练这种题.

fyfcauc
关注
专栏目录
POJ-1836-Alignment
Ninaye的博客
09-29 166
Alignment Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 16185   Accepted: 5291 Description In the army, a platoon is composed by n soldiers. During the mor
POJ - 1836 Alignment （动态规划）
weixin_34014555的博客
06-30 140
https://vjudge.net/problem/POJ-1836 题意 求最少删除的数，使序列中任意一个位置的数的某一边都是递减的。 分析 任意一个位置的数的某一边都是递减的，就是说对于数h[i]，有h[1] ~ h[i]严格单增，或h[i] ~ h[n]严格单减。一开始读错题意，以为使总体递增或递减，使劲wa。。。求两个方向的LIS，用n^2解法即可。 #includ...
Alignment POJ - 1836
Phantom_matter的博客
11-27 162
有一支N个新兵的部队，他们的序号从左到右分别为1到N，每个新兵都有一个身高ai，现在，我们希望给这支部队尽量少的踢掉几个新兵，剩下的新兵靠拢，使得每个剩下的任意一个位置的新兵向左或者向右其中的某一边的身高是严格递减的。Input 第一行输入一个N，表示新兵的个数（2≤N≤1000）。 第二行输入N个浮点数ai，分别表示这N个新兵的身高（0.5≤ai≤2.5）。Output 输出一个整数，表示最少需要踢掉的新兵数目。 Sample Input 6 0.7 1.9 1.6 1.9 1.6 0.7 Samp.
POJ - 1836 Alignment
jerans的博客
02-07 255
Alignment Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 16494   Accepted: 5406 Description In the army, a platoon is composed by n soldiers. During the m
POJ-1836 Alignment
xu0_zy的博客
03-06 191
Alignment 原题链接 Time Limit: 1000MS Memory Limit: 30000K Total Submissions: 17800 Accepted: 5859 Description In the army, a platoon is composed by n soldiers. During the morning inspect...
E - Alignment POJ - 1836
东风clz
10-15 405
E - Alignment  POJ - 1836  In the army, a platoon is composed by n soldiers. During the morning inspection, the soldiers are aligned in a straight line in front of the captain. The captain is not sa...
Alignment POJ - 1836 最长上升、下降子串
qq_45891413的博客
11-23 155
有一支N个新兵的部队，他们的序号从左到右分别为1到N，每个新兵都有一个身高ai，现在，我们希望给这支部队尽量少的踢掉几个新兵，剩下的新兵靠拢，使得每个剩下的任意一个位置的新兵向左或者向右其中的某一边的身高是严格递减的。 Input 第一行输入一个N，表示新兵的个数（2≤N≤1000）。 第二行输入N个浮点数ai，分别表示这N个新兵的身高（0.5≤ai≤2.5）。 Output 输出一个整数，表示最少需要踢掉的新兵数目。 Sample Input 6 0.7 1.9 1.6 1.9 1.6 0.7 Sampl
POJ-1836 Alignment---LIS
weixin_34128839的博客
05-08 74
题目链接： https://cn.vjudge.net/problem/POJ-1836 题目大意： 题意：令到原队列的最少士兵出列后，使得新队列任意一个士兵都能看到左边或者右边的无穷远处。就是使新队列呈三角形分布就对了。 解题思路： 求出每一位结束的最长上升子序列和每一位开始的最长下降子序列，求出最大值，然后用队伍长度减去即可。 1 #include<iostream&g...
poj-1836-Alignment
大桶爆米花eee
04-14 201
AlignmentTime Limit: 1000MS Memory Limit: 30000K Total Submissions: 16881 Accepted: 5519 DescriptionIn the army, a platoon is composed by n soldiers. During the morning inspection, the so
POJ1836-Alignment
07-31
【标题】"POJ1836-Alignment"是一道源于北京大学在线编程平台POJ的算法竞赛题目。这道题目要求参赛者编写程序解决一种排列对齐问题，以实现优化的计算策略。 【描述】"北大POJ1836-Alignment"是一个典型的计算机...
北大POJ1836-Alignment【O(nlogn)】
05-11
北大POJ1836-Alignment【O(nlogn)】
POJ-1836 Alignment (Romania OI 2002 线性dp 最长上升子序列)
hmc0411的博客
11-12 897
最长上升子序列的一道应用题，不错的入门题。题意：一排士兵战成一排，至少移走多少个士兵，才可以保证每一个士兵都可以从左或右看到无穷远的地方。
[DP动归]-POJ-1836-士兵排队（最长升序子串）
邂逅黛玛姑娘
01-07 1079
题目链接：点击打开链接 题目描述：- =，第一遍因为英语渣看错题意我会乱说？。。嘛，总之题意就是让几个士兵出列，剩下的士兵都可以看到左侧或者右侧的无穷远处（身高构成一个三角形的构型）。如图。 题目坑点：注意！我被坑了好几次！（泪目）。中间最高的两位是允许酱紫的，但是如果不是中间的那两个大高个，剩下的人就必须严格单调递增或递减。这里我看到的另一个博客，写的不错：（但是注意：他给的samp
poj-1054
fyfcauc的专栏
09-01 716
//25008K 1891MS G++ #include #include #include #include using namespace std; int W; int H; const int MAX = 5010; struct Flatten { int x; int y; }; typedef struct Flatten Flatten; Flatten fl
poj-1947
fyfcauc的专栏
09-06 551
//540K 32MS G++ #include #include using namespace std; const int MAX = 155; int DPRemoveMin[MAX][MAX]; int DPRemoveMinRangeFrom[MAX][MAX]; int childListHead[MAX]; struct Node { int par
poj-2057
fyfcauc的专栏
09-03 546
// 252K 32MS C++ #include #include #include #include #include #include using namespace std; const int MAX = 2005; // dp[i][0]表示以该点为根的节点找不到房子时要爬行最少的距离, 这个值有什么用呢? // 这个值就是用去计算房子落在其他叶子节点
poj-2231
fyfcauc的专栏
09-18 543
//264K 47MS C++ #include #include #include const int MAX = 10005; long long cowLocation[10005]; int cmp(const void * a, const void * b) { return *((long long *)a) - *((long long *)b); } long l
POJ - 1661
最新发布
09-18
根据提供的引用内容，这个问题讨论的是POJ-1661题，这是一个dp问题。题目给定了一系列平台的高度和人的起始位置，要求从起始位置跳到地面的最短时间。通过设置状态dp[i]表示从第i个平台的左边跳到地面所需的最小时间，dp[i]表示从第i个平台的右边跳到地面所需的最小时间，然后分别计算左右走所需的最小时间，最后取左右走中的较小值作为结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值