算法基础课(acwing):状态压缩DP，树形DP，记忆化搜索

最新推荐文章于 2024-11-14 19:06:32 发布

Chen_Mu_Pro

最新推荐文章于 2024-11-14 19:06:32 发布

阅读量745

点赞数 10

文章标签：算法

本文链接：https://blog.csdn.net/chen_mu233/article/details/137706157

版权

状态压缩DP：

状态压缩是利用二进制形成一个整数来表示一个集合的状态，如10010这个二进制数，就可以表示成是1的位置干过事或走过，是0的位置没干过事或没走过，然后将10010转化成十进制数18存储，但光存储状态还不够，还需要一个限制条件，或者说加上一维，就是最后走过或做过的事要存储在第二维。

例题-蒙德里安的梦想

求把 N×M的棋盘分割成若干个 1×2 的长方形，有多少种方案。

例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3 时，共有 3 种方案。

如下图所示：

输入样例：

输出样例：

解题思路及其代码：

我们先放横着的方块，再放竖着的方块，放横着的方块的合法方案数就是总方案数

接下来事状态表示，f[i][j]表示了横着的小方块从i-1列突出到第i列的的状态是j，其中j是一个二进制数，用来表示哪一行的小方块是横着放的，其位数和棋盘的行数一致。

然后是状态转移，因为第i列的状态已经由状态j固定了，所以我们要观察i-2列到i-1列。从i-2列伸出到i-1列的横的小方块我们设为状态k，状态j 和状态k 的横的小方块不能有重复，即j和k不能有同一行重复是1，且剩下空的位置是偶数，才能放的下竖的小方块。

代码：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N=12,M=1<<N;

int n,m;
long long f[N][M];
bool st[M];

int main(){
    
    while(cin>>n>>m,n||m){
        memset(f,0,sizeof f);
        
        for(int i=0;i<1<<n;i++){//预处理每一个状态是否有奇数个连续小方块，如果有，说明这个状态不合法
            st[i]=true;
            int cnt=0;
            for(int j=0;j<n;j++){
                if(i>>j&1){
                    if(cnt%2==1){
                        st[i]=false;
                    }
                    cnt=0;
                }
                else cnt++;
            }
            if(cnt%2==1)st[i]=false;


        }
        
        f[0][0]=1;
        for(int i=1;i<=m;i++){
            for(int j=0;j<1<<n;j++){
                for(int k=0;k<1<<n;k++){
                    if((j&k)==0&&st[j|k]){
                        f[i][j]+=f[i-1][k];//是i-1状态是k的所有合法摆法的累加
                    }
                }
            }
        }
        cout<<f[m][0]<<endl;
    }
    
}

例题-最短Hamilton路径

给定一张 n个点的带权无向图，点从 0∼n−1 标号，求起点 0 到终点 n−1的最短 Hamilton 路径。

Hamilton 路径的定义是从 0 到 n−1不重不漏地经过每个点恰好一次。

输入格式

第一行输入整数 n。

接下来 n 行每行 n 个整数，其中第 i 行第 j个整数表示点 i 到 j 的距离（记为 a[i,j]）。

对于任意的 x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x]，并且 a[x,y]+a[y,z]≥a[x,z].

输出格式

输出一个整数，表示最短 Hamilton 路径的长度。

数据范围

1≤n≤20
0≤a[i,j]≤10e7

输入样例：

输出样例：

解题思路与代码：

这道题就是一道典型的状态压缩DP问题，用2进制数表示走过的状态，用最后一个走到的位置来约束

f[M][N]则表示在i的状态下，最后到达j的最短距离。

然后从0开始搜索并计算所有的状态。

代码：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N=20,M=1<<N;

int n;
int w[N][N];
int f[M][N];//在i的状态下，最后到达j的最短距离

int main(){
    cin>>n;
    
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>w[i][j];
        }
    }
    
    memset(f,0x3f,sizeof f);
    f[1][0]=0;
    
    for(int i=0;i<1<<n;i++){//循环所有状态 
        for(int j=0;j<n;j++){//循环所有在每个i状态下最后到达的值j
            if(i>>j&1){//如果在i这个状态下j是被用到的话
                for(int k=0;k<n;k++){
                    if(i-(1<<j)>>k&1){//在i这个状态下除去j，即将i这个状态下的j变成0，看看i这个状态下k有没有被用到
                        f[i][j]=min(f[i][j],f[i-(1<<j)][k]+w[k][j]);
                    }
                }
            }
        }
    }
    
    cout<<f[(1<<n)-1][n-1];
}

树形DP：

在树形图里面，DP的过程其实和dfs深度优先搜索的过程类似，我们可以用dfs的方式来实现树形图里的DP实现。

例题-没有上司的舞会

Ural 大学有 N 名职员，编号为 1∼N。

他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。

每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N

现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。

在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。

输入格式

第一行一个整数 N。

接下来 N 行，第 i 行表示 i 号职员的快乐指数 Hi。

接下来 N−1 行，每行输入一对整数 L,K，表示 K 是 L 的直接上司。（注意一下，后一个数是前一个数的父节点，不要搞反）。

输出格式

输出最大的快乐指数。

数据范围

1≤N≤6000
−128≤Hi≤127

输入样例：

输出样例：

解题思路及其代码

这道题的状态表示可以有两种状态，一种是选这个人，那么他的下属就不会去，另一种是不选这个人，那么他的下属就有去和不去两种情况

我们用邻接表来存储树的数据

f[i][2]表示根节点为i的点有两种选法，一种是选i，一种是不选i，选i是f[i][1],不选i是f[i][0],返回的是以i为根节点的树happy指数的最大值。

用dfs递归处理每一个根节点的树happy指数的最大值。

代码：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 6010;

int n;
int happy[N];
int f[N][2];//表示根节点是i，f[i][0]表示不选i的最大值，f[i][1]表示不选i的最大值
int h[N],e[N],ne[N],idx;//邻接表
bool have_father[N];//i有没有父节点

void add(int a,int b){//邻接表的数据插入
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u){
    f[u][1]=happy[u];
    
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        
        dfs(j);
        
        f[u][0]+=max(f[j][0],f[j][1]);
        f[u][1]+=f[j][0];
    }
    
}

int main(){
    cin>>n;
    memset(h,-1,sizeof h);
    
    for(int i=1;i<=n;i++)cin>>happy[i];
    
    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        
        have_father[a]=true;
        add(b,a);
        
    }
    
    int root=1;
    while(have_father[root])root++;//找到根节点
    
    dfs(root);
    
    cout<<max(f[root][0],f[root][1]);
    
    return 0;
}

记忆化搜索

记忆化搜索，本质还是 动态规划，只是实现方式采用了 深度优先搜索 的形式，但是它不像 深度优先搜索那样重复枚举所有情况，而是把已经计算的子问题保存下来，这样就和动态规划的思想不谋而合了。（转自英雄哪里出来）

说白了就是所有的枚举情况只会被计算一次，不会重复计算。

例题-滑雪

给定一个 R 行 C 列的矩阵，表示一个矩形网格滑雪场。

矩阵中第 i 行第 j 列的点表示滑雪场的第 i 行第 j 列区域的高度。

一个人从滑雪场中的某个区域内出发，每次可以向上下左右任意一个方向滑动一个单位距离。

当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。

下面给出一个矩阵作为例子：

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

在给定矩阵中，一条可行的滑行轨迹为 24−17−2−1。

在给定矩阵中，最长的滑行轨迹为 25−24−23−…−3−2−1沿途共经过 25个区域。

现在给定你一个二维矩阵表示滑雪场各区域的高度，请你找出在该滑雪场中能够完成的最长滑雪轨迹，并输出其长度(可经过最大区域数)。

解题思路及其代码

用记忆化搜索递归来求

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N=310;

int n,m;
int w[N][N];
int f[N][N];
int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};//偏移量

int dp(int x,int y){//记忆化搜索
    if(f[x][y]!=-1)return f[x][y];
    
    f[x][y]=1;
    
    for(int i=0;i<4;i++){
        int a=x+dx[i],b=y+dy[i];
        
        if(a>=1&&a<=n&&b>=1&&b<=m&&w[x][y]>w[a][b]){
            f[x][y]=max(f[x][y],dp(a,b)+1);
        }
    }
    
    return f[x][y];
}

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++)cin>>w[i][j];
    }
    
    memset(f,-1,sizeof f);
    
    int res=0;
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            res=max(res,dp(i,j));
        }
    }
    
    cout<<res;
    
    return 0;
}