2024-02-17、18（状态压缩dp）

最新推荐文章于 2024-10-11 12:01:25 发布

m0_73165551

最新推荐文章于 2024-10-11 12:01:25 发布

阅读量366

点赞数 6

分类专栏：日志文章标签：动态规划算法

本文链接：https://blog.csdn.net/m0_73165551/article/details/136139172

版权

日志专栏收录该内容

40 篇文章 0 订阅

订阅专栏

2024-02-07（计数类DP、数位统计DP、状态压缩DP、树形 DP、记忆化搜索）-CSDN博客两个状态压缩dp的题目

1064. 小国王 - AcWing题库

import java.util.*;

public class Main{
    static int N = 12, M = 1 << 10, K = 110;
    //这个s是一个二进制数
    static int n, m;//n是行数，m是国王的个数
    static long[][][] f = new long[N][K][M];//排完前i行，并且已经放了j个国王，并且第i行的状态是s的方案的集合
    static List<Integer> state = new ArrayList<>();//用来存所有可能的状态
    static ArrayList<Integer>[] head = new ArrayList[M];//用来存一个状态可能到的所有状态
    static int[] cnt = new int[M];//每个合法状态中1的个数
    
    //用来判断这一行的这个状态state是不是合法状态（即不能有两个相邻的1）
    public static boolean check(int state){
        for(int i = 0; i < n; i ++){//从第1格开始枚举这一行中每一格的状态
            if((state >> i & 1) == 1 && (state >> i + 1 & 1) == 1)  return false;//有相邻的1，返回false
        }
        //没有相邻的1，返回true
        return true;
    }
    
    //用来计算一行的这个状态state有多少个1
    public static int count(int state){
        int res = 0;
        for(int i = 0; i < n; i ++){
            if((state >> i & 1) == 1) res ++;//有1加1
        }
        return res;//返回1的个数
    }
    
    //开始main函数
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        //找到所有的合法状态
        for(int i = 0; i < 1 << n; i ++){
            if(check(i)){//如果这个状态合法
                state.add(i);//那么将这个状态存到合法状态的集合里面，也就是state
                cnt[i] = count(i);//然后记录这个合法状态中1的个数
            }
        }
        
        //找到每个合法状态所有可能到的状态
        for(int i = 0; i < state.size(); i ++){
            for(int j = 0; j < state.size(); j ++){
                int a = state.get(i);//合法状态
                int b = state.get(j);//合法状态
                //判断能不能到
                if((a & b) == 0 && check(a | b)){
                    //由于一个状态可能到达多个状态
                    //如果这个状态还没有开始存可能到达的状态，那么就建立一个新的链表来存放
                    if(head[i] == null) head[i] = new ArrayList<>();
                    //如果这个状态以及建立好了链表，那么就在这个链表里面接着存放
                    head[i].add(j);
                }
            }
        }
        
        //初始化
        f[0][0][0] = 1;//所有都不选，一个都不放，状态是0的情况，存在
        
        //开始dp
        for(int i = 1; i <= n + 1; i ++){//行数
            for(int j = 0; j <= m; j ++){//国王的个数
                //注意这里的a和b与上面的a和b的含义是不一样的
                for(int a = 0; a < state.size(); a ++){//遍历每一个合法状态,这里的a指的是合法状态集合中第几个合法状态
                    for(int b : head[a]){//遍历这个合法状态可能到的所有合法状态
                        int c = cnt[state.get(a)];
                        if(j >= c){
                            //这里的a其实代表着最后一行能由什么状态得到
                            f[i][j][a] += f[i - 1][j - c][b];
                        }
                    }
                }
            }
        }
        
        //输出结果
        System.out.print(f[n + 1][m][0]);
    }
}

327. 玉米田 - AcWing题库

import java.util.*;

public class Main{
    static int N = 14, M = 1 << 12, mod = (int)1e8;
    static int n, m;
    static List<Integer> state = new ArrayList<>();//所有合法状态
    static ArrayList<Integer>[] head = new ArrayList[M];//所有合法状态可能到的合法状态
    static int[][] f = new int[N][M];//所有已经摆放完前i行，且第i行的状态是s的所有拜访方案的集合
    static int[] g = new int[M];//土地损坏
    
    //判断一行的状态是否合法（即相邻两个格子不能同时为1）
    public static boolean check(int state){
        for(int i = 0; i <= m; i ++){
            if((state >> i & 1) == 1 && (state >> i + 1 & 1) == 1) return false;
        }
        return true;
    }
    
    //开始main函数
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        for(int i = 1; i <= n; i ++){
            for(int j = 0; j < m; j ++){
                int t = sc.nextInt();
                g[i] += (t ^ 1) << j;//把坏的地变成1
            }
        }
        
        //找到所有合法的状态
        for(int i = 0; i < 1 << m; i ++){
            if(check(i)){
                state.add(i);//如果状态合法，加进合法状态的集合中
            }
        }
        
        //找到每个合法状态可能到的所有合法状态
        for(int i = 0; i < state.size(); i ++){
            for(int j = 0; j <state.size(); j ++){
                int a = state.get(i);
                int b = state.get(j);
                if((a & b) == 0){
                    if(head[i] == null) head[i] = new ArrayList<>();
                    head[i].add(j);
                }
            }
        }
        
        //初始化
        f[0][0] = 1;//一定要记得初始化
        
        //开始状态压缩dp
        for(int i = 1; i <= n + 1; i ++){//枚举到n+1行
            for(int a = 0; a < state.size(); a ++){
                for(int b : head[a]){
                    //如果坏的土地（标记为1）和合法状态的1有重合，也就是说&的结果不为0，就跳过这次的合法状态
                    if((g[i] & state.get(a)) != 0) continue;
                    f[i][a] = (f[i][a] + f[i - 1][b]) % mod;
                }
            }
        }
        
        System.out.print(f[n + 1][0]);
    }
}

292. 炮兵阵地 - AcWing题库

与前两题不同的是，这道题求的不是方案数，而是最大值，也就是说把所有子集的最大值与当前行的最大值相加就可以了。

另外，由于攻击范围如图所示，所以在枚举的时候，要枚举到 i -2 行。

import java.util.*;

public class Main{
    static int N = 110, M = 1 << 10, K = 12;
    static int[][][] f = new int[K][M][M];//所有已经摆完前i行，且第i-1行的状态是j，第i行的状态是k的所有拜访方案
    static int[] cnt = new int[M];//用来记录每个合法状态中1的个数
    static int n, m;
    static int[] g = new int[N];//表示地图上山地的位置
    static List<Integer> state = new ArrayList<>();
    
    //判断状态是否合法(一行中)
    public static boolean check(int state){
        for(int i = 0; i < m; i ++){
            if((state >> i & 1) == 1 && ((state >> i + 1 & 1) == 1 | (state >> i + 2 & 1) == 1)) return false;
        }
        return true;
    }
    
    //求出每一个合法状态中有几个1
    public static int count(int state){
        int res = 0;
        for(int i = 0; i < m; i ++){
            if((state >> i & 1) == 1) res ++;
        }
        return res;
    }
    
    //开始main函数
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        //先把山地平原的数据读入
        for(int i = 1; i <= n; i ++){
            String str = sc.next();
            for(int j = 0; j < m; j ++){
                char c = str.charAt(j);
                if(c == 'H') g[i] += 1 << j;//将山地的状态置为1
            }
        }
        
        //求出合法状态
        for(int i = 0; i < 1 << m; i ++){
            if(check(i)){
                state.add(i);
                cnt[i] = count(i);
            }
        }
        
        //开始dp过程
        for(int i = 1; i <= n + 2; i ++){
            for(int j = 0; j < state.size(); j ++){
                for(int k = 0; k < state.size(); k ++){
                    for(int l = 0; l < state.size(); l ++){
                        int a = state.get(j);//第i-1行
                        int b = state.get(k);//第i行
                        int c = state.get(l);//第i-2行
                        //两个合法条件
                        if((a & b) != 0 | (a & c) != 0 | (b & c) != 0) continue;
                        if((g[i - 1] & a) != 0 | (g[i] & b) != 0) continue;
                        //用滚动数组
                        f[i & 1][j][k] = Math.max(f[i & 1][j][k], f[i - 1 & 1][l][j] + cnt[b]);
                    }
                }
            }
        }
        System.out.print(f[n + 2 & 1][0][0]);//多算一行
    }
}

524. 愤怒的小鸟 - AcWing题库

这道题是一个重复覆盖问题。根据抛物线的特点，一条抛物线只能经过一列中的一个点，两点确定一条抛物线。

暴力搜索：用某种顺序来枚举到所有的方案

import java.util.*;

class PDD{//用来存储每个小猪点的横纵坐标
    double x, y;
    public PDD(double x, double y){
        this.x = x;
        this.y = y;
    }
}

public class Main{
    static int N = 20, M = 1 << 18;
    static double INF = 1e-8;//代表无穷小，用来比较大小
    static int n, m;//n是小猪数量
    //如果M指的是某种状态，f[M]指的是达成这种状态需要至少多少条抛物线
    static int[] f = new int[M];//比如说110011，就是说编号1256的小猪被覆盖
    static PDD[] q = new PDD[N];//存储小猪（点）的横纵坐标
    static int[][] path = new int[N][N];//path[i][j] 存的是i点和j点构成的抛物线能够构成的状态
    
    //用来判断两个浮点数是否相等
    public static boolean cmp(double a, double b){
        if(Math.abs(a - b) < INF) return true;//两个数相等返回true
        return false;//否则返回false
    }
    
    //开始main函数
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();//共有t组测试数据
        
        while(T -- > 0){
            n = sc.nextInt();//小猪的数量
            m = sc.nextInt();
            
            //输入n个小猪的横纵坐标
            for(int i = 0; i < n; i ++){
                double x = sc.nextDouble();
                double y = sc.nextDouble();
                q[i] = new PDD(x, y);//把坐标存入存储坐标的集合中
                Arrays.fill(path[i], 0);//因为有多组测试数据，所以每一次要将path数组重新置为0
            }
            
            //这里是要遍历任意两点，得到path[i][j]数组
            for(int i = 0; i < n; i ++){
                path[i][i] = 1 << i;//先把自己这一个点得到的所覆盖的状态赋值
                for(int j = 0; j < n; j ++){
                    double x1 = q[i].x, y1 = q[i].y;//把当前枚举的第一个点的横纵坐标拿出来
                    double x2 = q[j].x, y2 = q[j].y;//把当前枚举的第二个点的横纵坐标拿出来
                    //判断这两点的横坐标是否相等
                    if(cmp(x2, x1)) continue;//横坐标相等的两点(垂直)是不能得到一条抛物线的
                    
                    //经过判断，抛物线为y = ax^2 + bx，然后由公式得出a和b的值
                    double a = ((y1 / x1) - (y2 / x2)) / (x1 - x2);
                    double b = (y1 / x1) - a * x1;
                    
                    if(a > 0 || cmp(a, 0.0)) continue;//如果a>=0的话，也是不可以的
                    
                    //接下来就枚举经过ij两点的抛物线得到的path是什么
                    for(int k = 0; k < n; k ++){//枚举每一点，看能不能被覆盖
                        double x = q[k].x;
                        double y = q[k].y;
                        if(cmp((a * x * x + b * x), y)) path[i][j] += 1 << k;//把这个点的位置变成1
                    }
                }
            }
            
            //求最小值，初始化为正无穷
            Arrays.fill(f, 0x3f3f3f3f);
            f[0] = 0;//0这个状态一条抛物线都不用，置为0
            
            //开始枚举所有的二进制状态
            for(int i = 0; i < 1 << n; i ++){
                int x = 0;//用来存储在一个状态中，第一个没有经过的猪（即为0）
                for(int j = 0; j < n; j ++){
                    if((i >> j & 1) == 0){
                        x = j;
                        break;
                    }
                }
                
                for(int j = 0; j < n; j ++){
                    //所有经过点x的抛物线的路径，看那个使得f数组最小
                    f[i | path[x][j]] = Math.min(f[i | path[x][j]], f[i] + 1);
                }
            }
            
            System.out.println(f[(1 << n) - 1]);
        }
    }
}