UVA-1579 Matryoshka （区间DP）

题目大意：n个俄罗斯套娃，都有相应的编号，每次可将两个相邻的套娃组合成一组，每次合成只能小的放到大的里面，并且是逐层嵌套。问将这n个套娃分成若干个组，并且每组都是编号从1开始的连续序列，最少需要几步。

题目分析：很显然的区间DP，只不过每次DP未必是在整个区间，而是在子区间上。

 

代码如下：

# include<iostream>
# include<cstdio>
# include<queue>
# include<cstring>
# include<algorithm>
using namespace std;

const int INF=1000000000;

int a[505];
int n,vis[505];
int dp[505][505];

int getStep(int l1,int r1,int l2,int r2)
{
    priority_queue<int>q1,q2;
    for(int i=l1;i<=r1;++i) q1.push(a[i]);
    for(int i=l2;i<=r2;++i) q2.push(a[i]);
    int res=0;
    while(!q1.empty()&&!q2.empty()){
        int t1=q1.top();
        int t2=q2.top();
        ++res;
        if(t1>t2) q1.pop();
        else q2.pop();
    }
    return res;
}

int dfs(int l,int r)
{
    if(dp[l][r]!=-1) return dp[l][r];
    if(l==r) return dp[l][r]=0;
    dp[l][r]=INF;
    for(int i=l+1;i<=r;++i){
        int step=getStep(l,i-1,i,r);
        dp[l][r]=min(dp[l][r],dfs(l,i-1)+dfs(i,r)+step);
    }
    return dp[l][r];
}

int solve()
{
    int l=0,ans=0;
    memset(dp,-1,sizeof(dp));
    memset(vis,0,sizeof(vis));
    vis[a[0]]=1;
    for(int i=1;i<n;++i){
        if(vis[a[i]]){
            for(int j=1;j<=i-l;++j)
                if(!vis[j]) return INF;
            ans+=dfs(l,i-1);
            memset(vis,0,sizeof(vis));
            vis[a[i]]=1;
            l=i;
            //cout<<i<<' '<<a[i]<<endl;
        }else
            vis[a[i]]=1;
    }
    for(int i=1;i<=n-l;++i) if(!vis[i]) return INF;
    ans+=dfs(l,n-1);
    return ans;
}

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;++i) scanf("%d",a+i);
        int ans=solve();
        if(ans==INF) printf("impossible\n");
        else printf("%d\n",ans);
    }
    return 0;
}

　　

转载于:https://www.cnblogs.com/20143605--pcx/p/5260055.html