UVA - 1289 Stacking Plates （分析+离散化）

问题

分析

分析参照：https://blog.csdn.net/BUAA_Alchemist/article/details/86932466（大佬的分析，条例十分清晰）
代码参照：https://blog.csdn.net/hao_zong_yin/article/details/79807322

自己的理解： 首先先将堆分开，期间不合并，之后只和合并，不分开，开始有n个堆，分开后最多有m个堆，分开操作x=m-n，合并最后只剩1个堆，所以分开是m-n次，合并是m-1次,总的操作次数2m-n-1=2x+n-1次，所以最少操作方案就是使m最小的方案（m最大是每个盘子自己一个堆），怎么让m最小？首先从堆的顶端开始拿盘子分出一个新的堆，每次都拿最小的（连续两个同样大的盘子操作相同，不分开考虑），如果连续两次操作都在同一个堆上，就把两个操作合并。如果同时遇到多个堆的顶端是一样的，那就要考虑哪一个是最后操作的，假如说有k个堆上面的盘子大小相同，他们都要将盘子拿下来分出一个新的堆（不能直接堆到别的堆顶部），但要记录最后一次操作（也许下一次操作还在这个堆，两次操作可能合并成一次）
状态（计算最少的分开操作）:dp[i][j]是前面小于等于i小的盘子已经分开时，大小为i的盘子，最后一次的堆的编号是j的分成的堆数量最小值（m的值）
其中 ，要使用离散化简化时间
1.不使用离散化的代码

#include<iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;
const int maxn=2505,maxv=10005,maxp=55,INF=0x3f3f3f3f;
int kase=0,n,m,x,x2,t1,t2,pre[maxv],vis[maxp][maxv],dp[maxv][maxp];
vector<int> piles[maxp],heap[maxv];
set<int> collect;
//清理所有的存储空间
void clear(){
    for(int i=1;i<=n;++i) piles[i].clear();
    for(int i=1;i<maxv;++i) heap[i].clear();
    collect.clear();
    memset(pre,0,sizeof(pre));
    memset(vis,0,sizeof(vis));
//    memset(dp,INF,sizeof(dp));
}

int main(void){
    while(cin>>n){
        for(int i=1;i<=n;++i){
            scanf("%d",&m);
            for(int j=0;j<m;++j){
                scanf("%d",&x);
                piles[i].push_back(x);
                collect.insert(x);  //所有的盘子大小的集合
            }
        }
        int p=0;
        for(auto iter=collect.begin();iter!=collect.end();++iter){
            x=*iter;
//            exist[x]=1;
            pre[x]=p;  //记录前一个盘子的大小
            p=x;
        }
        for(int i=1;i<=n;++i){
            for(int j=0;j<piles[i].size();++j){
                x=piles[i][j];
                if(!vis[i][x]){   //每个堆i中大小为x的盘子只记录一次，不考虑重复
                    vis[i][x]=1;
                    heap[x].push_back(i);  //heap[x]是盘子大小x出现的堆
                }
            }
        }
        x=*collect.begin();
        for(int i=0;i<heap[x].size();++i){
            dp[x][heap[x][i]]=heap[x].size();
        }
        for(auto iter=(++collect.begin());iter!=collect.end();++iter){
            x=*iter;
            int s=heap[x].size();
            for(int i=0;i<heap[x].size();++i){
                x2=pre[x];
                t1=heap[x][i]; //大小x的盘子最后的堆是t1
                int &t=dp[x][t1];
                t=INF;
                for(int j=0;j<heap[x2].size();++j){
                    t2=heap[x2][j];  //上次大小为t的盘子的最后的堆是t2
                    //这一段，如果两种盘子操作的最后一次分开都在同一个堆，那么无法省略操作（除非第二次只有一个，那么就可以减少一次）
                    //如果两种操作最后一次不在一起，如果第一次的结尾的堆是第二次操作中的堆，那么就可以合并，减少一次
                    if(t1==t2){  //两次操作在同一个堆上
                        t=min(t,dp[x2][t2]+((s==1)?0:s));
                    }else{
                        t=min(t,dp[x2][t2]+s-vis[t2][x]);
                    }
                }
            }
        }
        //比较最后的结果，选出最优解
        int ans=INF,l=*collect.rbegin();
        for(int i=0;i<heap[l].size();++i){
            ans=min(ans,dp[l][heap[l][i]]);
        }
        printf("Case %d: %d\n", ++kase, 2*ans-n-1);
        clear();
    }
}

2.使用离散化

#include<iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;
const int maxn=2505,maxv=10005,maxp=55,INF=0x3f3f3f3f;
int kase=0,n,m,x,x2,t1,t2,order[maxv],d,vis[maxp][maxn],dp[maxn][maxp];
vector<int> piles[maxp],heap[maxn];
set<int> collect;
void clear(){
    for(int i=1;i<=n;++i) piles[i].clear();
    for(int i=1;i<=d;++i) heap[i].clear();
    collect.clear();
//    memset(pre,0,sizeof(pre));
    memset(order,0,sizeof(order));
    memset(vis,0,sizeof(vis));
//    memset(dp,INF,sizeof(dp));
}

int main(void){
    while(cin>>n){
        for(int i=1;i<=n;++i){
            scanf("%d",&m);
            for(int j=0;j<m;++j){
                scanf("%d",&x);
                piles[i].push_back(x);
                collect.insert(x);  //所有的盘子大小的集合
            }
        }
        int p=0;
        d=0;
        //离散化，压缩不用的空间，就是把10,20,23，40等效变为1，2，3，4
        for(auto iter=collect.begin();iter!=collect.end();++iter){
            x=*iter;
            order[x]=++d;
//            exist[x]=1;
//            pre[x]=p;
//            p=x;
        }
        for(int i=1;i<=n;++i){
            for(int j=0;j<piles[i].size();++j){
                x=order[piles[i][j]];
                if(!vis[i][x]){  //每个堆i中大小为x的盘子只记录一次，不考虑重复
                    vis[i][x]=1;
                    heap[x].push_back(i);  //heap[order[x]]是盘子大小x出现的堆
                }
            }
        }
        //初始化最小盘子大小对应的情况
        for(int i=0;i<heap[1].size();++i){
            dp[1][heap[1][i]]=heap[1].size();
        }
        for(x=2;x<=d;++x){  //盘子大小
            int s=heap[x].size();
            x2=x-1;
            for(int i=0;i<heap[x].size();++i){
                t1=heap[x][i]; //大小x的盘子最后的堆是t1
                int &t=dp[x][t1];
                t=INF;
                for(int j=0;j<heap[x2].size();++j){
                    t2=heap[x2][j];  //上次大小为t的盘子的最后的堆是t2
                    //这一段，如果两种盘子操作的最后一次分开都在同一个堆，那么无法省略操作（除非第二次只有一个，那么就可以减少一次）
                    //如果两种操作最后一次不在一起，如果第一次的结尾的堆是第二次操作中的堆，那么就可以合并，减少一次
                    if(t1==t2){  //两次操作在同一个堆上
                        t=min(t,dp[x2][t2]+((s==1)?0:s));
                    }else{
                        t=min(t,dp[x2][t2]+s-vis[t2][x]);
                    }
                }
            }
        }
        //比较最后的结果，选出最优解
        int ans=INF;
        for(int i=0;i<heap[d].size();++i){
            ans=min(ans,dp[d][heap[d][i]]);
        }
        printf("Case %d: %d\n", ++kase, 2*ans-n-1);
        clear();
    }
}