DFS之迭代加深、双向DFS、IDA*

迭代加深

170. 加成序列 - AcWing题库

剪枝1：优先枚举较大的数

剪枝2：排除等效冗余

import java.util.*;
 
public class Main{
    static int N = 110, n;
    static int[] path = new int[N];
    static boolean[] st = new boolean[N];
    
    //当前是第几层，最大层数
    public static boolean dfs(int u, int length){
        if(u == length) return path[u - 1] == n;
        
        Arrays.fill(st, false);//每次都要重置，用于冗余性剪枝
        for(int i = u - 1; i >= 0; i --){//从大到小开始枚举，优化搜索顺序
            for(int j = i; j >= 0; j --){
                int s = path[i] + path[j];
                if(s <= n && s > path[u - 1] && !st[s]){
                    st[s] = true;
                    path[u] = s;
                    if(dfs(u + 1, length)) return true;
                    
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(true){
            n = sc.nextInt();
            if(n == 0) break;
            
            path[0] = 1;
            int length = 1;//每次往下的深度
            while(!dfs(1, length)) length ++;
            
            for(int i = 0; i < length; i ++){
                System.out.print(path[i] + " ");
            }
            System.out.println();
        }
    }
}

双向DFS

171. 送礼物 - AcWing题库

import java.util.*;
 
public class Main{
    //cnt表示前半段的方案数
    static int N = 50, n, m, cnt, k;
    static int[] w = new int[N];
    static int[] weights = new int[1 << 25];//前半段不同的重量组合
    static long ans;//一次能搬运的最大物品重量之和
    
    //翻转数组，经过排序之后，这个函数令从小到大排序变成从大到小排序
    public static void reverse(){
        for(int i = 0; i < n / 2; i ++){
            int temp = w[i];
            w[i] = w[n - 1 - i];
            w[n - 1 - i] = temp;
        }
    }
    
    //数组去重后得到的元素数量
    public static int unique(){
        int t = 0;
        for(int i = 0; i < cnt; i ++){
            if(i == 0 || weights[i] != weights[i - 1]) weights[t ++] = weights[i];
        }
        return t;
    }
    
    //前半段的所有方案：当前枚举到第u个数，总重量为s
    public static void dfs1(int u, int s){
        if(u >= k){
            weights[cnt ++] = s;
            return;
        }
        
        //选当前这个数
        if((long)s + w[u] <= m) dfs1(u + 1, s + w[u]);
        
        //不选当前这个数
        dfs1(u + 1, s);
    }
    
    //遍历第二段，寻找第一段中是否有合适的方案值
    public static void dfs2(int u, int s){
        if(u >= n){
            //二分查找第一段方案与第二段方案加起来小于m的最大值
            int l = 0, r = cnt - 1;
            while(l < r){
                int mid = (l + r + 1) >> 1;
                if((long)weights[mid] + s <= m) l = mid;
                else r = mid - 1;
            }
            if((long)weights[l] + s <= m) ans = Math.max(ans, weights[l] + s);
            return;
        }
        
        //选当前这个数
        if((long)s + w[u] <= m) dfs2(u + 1, s + w[u]);
        
        //不选当前这个数
        dfs2(u + 1, s);
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        m = sc.nextInt();//力气最大值
        n = sc.nextInt();//礼物数
        
        for(int i = 0; i < n; i ++){
            w[i] = sc.nextInt();//每件礼物的重量
        }
        
        Arrays.sort(w, 0, n);//排序
        reverse();//翻转
        
        k = n / 2 + 2;//前半段的数
        
        dfs1(0, 0);//找出前半段重量的所有方案，第0个数开始，一开始总重量为0
        
        Arrays.sort(weights, 0, cnt);//排序
        cnt = unique();//前半段方案去重后的数量
        
        dfs2(k, 0);
        System.out.print(ans);   
    }
}

 

IDA*

基本思想就是剪枝：对未来所需要的步数进行一个估计（估计值<=真实值） 

180. 排书 - AcWing题库

 

 java的arrayCopy用法_static void arraycopy用法-CSDN博客

Arrays.copyOf() 用法-CSDN博客 

import java.util.*;
 
public class Main{
    static int N = 15, n;
    static int[] q = new int[N];//书的摆放顺序
    static int[][] w = new int[5][N];//每层的复原数组
    
    //求出错误后继的个数，然后由于每次调换最多修正3个错误后继
    public static int f(){
        int tot = 0;
        for(int i = 0; i < n - 1; i ++){
            if(q[i + 1] != q[i] + 1) tot ++;
        }
        return (tot + 2) / 3;
    }
    
    public static boolean dfs(int u, int depth){
        if(u + f() > depth) return false;//当前层数加估计层数大于最大层数
        if(f() == 0) return true;//错误后继为0
        
        for(int len = 1; len <= n; len ++){
            for(int l = 0; l + len - 1 < n; l ++){
                int r = l + len - 1;
                for(int k = r + 1; k < n; k ++){//移到k的后面
                    w[u] = Arrays.copyOf(q, N);//拷贝
                    
                    int y = l;
                    for(int x = r + 1; x <= k; x ++) q[y ++] = w[u][x];
                    for(int x = l; x <= r; x ++) q[y ++] = w[u][x];
                    if(dfs(u + 1, depth)) return true;
                    
                    q = Arrays.copyOf(w[u], N);//恢复现场
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while(T -- > 0){
            n = sc.nextInt();
            for(int i = 0; i < n; i ++){
                q[i] = sc.nextInt();
            }
            
            int depth = 0;//这里是因为w数组从0开始
            //迭代加深
            while(depth < 5 && !dfs(0, depth)) depth ++;
            
            if(depth >= 5) System.out.println("5 or more");
            else System.out.println(depth);
        }
    }
}

 

181. 回转游戏 - AcWing题库

 

import java.io.*;
 
public class Main{
    static int N = 24;
    static int[] q = new int[N];//棋盘状态
    //棋盘每个位置的编号
    static int[][] op = {
        {0, 2, 6, 11, 15, 20, 22},
        {1, 3, 8, 12, 17, 21, 23},
        {10, 9, 8, 7, 6, 5, 4},
        {19, 18, 17, 16, 15, 14, 13},
        {23, 21, 17, 12, 8, 3, 1},
        {22, 20, 15, 11, 6, 2, 0},
        {13, 14, 15, 16, 17, 18, 19},
        {4, 5, 6, 7, 8, 9, 10},
    };
    //中间8个数的编号
    static int[] center = {6, 7, 8, 11, 12, 15, 16, 17};
    //每个操作的反向操作
    static int[] opposite = {5, 4, 7, 6, 1, 0, 3, 2};
    //操作方案
    static int[] path = new int[100];
    
    //估价函数，找到中间八个格子中最多的数
    public static int f(){
        int[] sum = new int[4];
        for(int i = 0; i < 8; i ++) sum[q[center[i]]] ++;
        
        int s = 0;
        for(int i = 1; i <= 3; i ++) s = Math.max(s, sum[i]);
        return 8 - s;//最少还要进行的操作的数量
    }
    
    //移动函数
    public static void operation(int x){//x表示第几个操作
        int t = q[op[x][0]];
        for(int i = 0; i < 6; i ++) q[op[x][i]] = q[op[x][i + 1]];
        q[op[x][6]] = t;
    }
    
    public static boolean dfs(int u, int depth, int last){
        if(u + f() > depth) return false;
        if(f() == 0) return true;
        
        for(int i = 0; i < 8; i ++){
            if(opposite[i] == last) continue;//如果是反向操作，立即停止
            operation(i);
            path[u] = i;
            if(dfs(u + 1, depth, i)) return true;
            operation(opposite[i]);
        }
        return false;
    }
    
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String cur = "";
        while(!(cur = br.readLine()).equals("0")){
            //题目中说了每个测试用例占一行
            String[] arr = cur.split(" ");
            for(int i = 0; i < 24; i ++) q[i] = Integer.parseInt(arr[i]);
            
            int depth = 0;
            int last = -1;//上一次的操作
            while(!dfs(0, depth, last)) depth ++;
            
            if(depth == 0) System.out.println("No moves needed");
            else{
                for(int i = 0; i < depth; i ++) System.out.print((char)(path[i] + 'A'));
                System.out.println();
            }
            //无论哪种情况都要输出中间格子的数
            System.out.println(q[center[0]]);
        }
    }
}