HDU 6049 Sdjpx Is Happy 贪心 区间DP 从简单的情况着手思考

题意：给定一个全排列，玩家可以将其分成若干块，并对每一块排序，且可以进行一次块交换。问玩家最多可以将原排列分成几个块，使得对原排列进行合法操作后能够生成1~N的顺序排列。

比赛的时候没有开这道题，赛后补题的时候发现没有遇到过这种题型，仔细琢磨之后，把问题分解了一步一步想，还是不难的。

首先我们不考虑交换操作，这显然是一个贪心问题。从左往右扫，一旦能切开，就切开。我们将切完之后的第 i 块称作 block i。那么，答案至少是块的总个数。

引入交换操作之后，可以发现，为了使答案更好，又因为跨块换是不对的，我们只能试着将每一块细分。细分块的时候只有两种情况，一种是 A | B | C，另一种是 A | B。

第一种：需要交换 A C。则原块能被切成 A块 C块 以及 B的最大合法切法（程序里面用dp[i][j]进行了预处理，i, j表示区间的范围）。故答案增加了1+dp[i][j]。

第二种：需要交换 A B。原块被切成了 A块 B块，答案增加了1。

代码实现细节：

block[i]: 点 i 所在的块。

l[i]: 块 i 的左端点。

r[i]: 块 i 的右端点。

fi[i][j]: 区间[i, j]的最小值。

fa[i][j]: 区间[i, j]的最大值。

check1(i, j): 区间[i, j]是否是一个连续数字的排列。

check2(i, j): 区间[i, j]是否是从 i 到 j 的一个排列。

dp[i][j]: 区间[i, j]能被划分为成最大块数，使得对每一块进行排序后，最后区间[i, j]能够成为一个顺序排列（不一定得是 i 到 j 的）。

在判断 A | B | C 情况时，要满足：

1. A B C 属于同一块。

2. A B C 三块均不为空。

3. A B C 各自均为连续数字的一个排列。

4. (A的最小值)=(B的最大值+1)。

5. (B的最小值)=(C的最大值+1)。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=3005;
int T,n,dp[maxn][maxn],fa[maxn][maxn],fi[maxn][maxn],a[maxn],l[maxn],r[maxn],now,block[maxn];
inline bool check1(int i,int j) {
    return (fa[i][j]-fi[i][j])==(j-i);
}
inline bool check2(int i,int j) {
    return check1(i,j)&&fi[i][j]==i;
}
void print() {
    puts("fi:");
    for (int i=1;i<=n;++i)
        for (int j=1;j<=n;++j)
            printf("%d%c",fi[i][j],j==n?'\n':' ');
    puts("fa:");
    for (int i=1;i<=n;++i)
        for (int j=1;j<=n;++j)
            printf("%d%c",fa[i][j],j==n?'\n':' ');
    puts("dp:");
    for (int i=1;i<=n;++i)
        for (int j=1;j<=n;++j)
            printf("%d%c",dp[i][j],j==n?'\n':' ');
    puts("block:");
    for (int i=1;i<=n;++i)
        printf("%d%c",block[i],i==n?'\n':' ');
}
int main()
{
    scanf("%d",&T);
    while (T--) {
        memset(dp,0,sizeof dp);
        scanf("%d",&n);
        for (int i=1;i<=n;++i) {
            scanf("%d",&a[i]);
            fi[i][i]=fa[i][i]=a[i];
            dp[i][i]=1;
        }
        for (int i=1;i<=n;++i)
            for (int j=i+1;j<=n;++j) {
                fa[i][j]=max(fa[i][j-1],a[j]);
                fi[i][j]=min(fi[i][j-1],a[j]);
            }
        now=1;
        for (int i=1;i<=n;++i) {
            l[now]=!l[now]?i:l[now];
            block[i]=now;
            r[now]=i;
            if (check2(1,i))
                ++now;
        }
        for (int i=1;i<=n;++i) {
            int cnt=1;
            for (int j=i+1;j<=n;++j) {
                if (a[j]<fi[i][j-1])
                    cnt=0;
                if (check1(i,j))
                    dp[i][j]=++cnt;
            }
        }
        int res=block[n];
        for (int i=1;i<=n;++i) {
            int bi=block[i];
            if (l[bi]==r[bi])
                continue;
            if (check2(l[bi],i)) {
                res=block[n]+1;
                break;
            }
        }
        for (int i=1;i<=n;++i)
            for (int j=i;j<=n;++j) {
                int bi=block[i],bj=block[j];
                if (bi!=bj||l[bi]==i||r[bj]==j)
                    continue;
                if (!dp[i][j]||!dp[l[bi]][i-1]||!dp[j+1][r[bi]])
                    continue;
                if (fi[l[bi]][i-1]!=fa[i][j]+1||fa[j+1][r[bi]]+1!=fi[i][j])
                    continue;
                res=max(res,block[n]+dp[i][j]+1);
            }
        printf("%d\n",res);
    }
    return 0;
}