【算法练习 粘木棍】DFS搜索分组

以题目为例，之前的想法是，有n个木棍，要粘成m个木棍，就找1-m的全排列，并且长度为n的全排列，m=3，n=2时，1 1 2，就是前两个木棍组成一根木棍，最后一根木棍单独。但是全排列会有全为1，全为2的情况，并且1 2 2和2 1 1的情况是重复的，这种方法显然不行。

回到n个木棍本身，需要分成m组，那么对每一根木棍，它可能属于第1-m组，所以在遍历每一根木棍时，还要遍历这根木棍的分组，所以在dfs循环里面要写两个循环，外层循环遍历第几个木棍，内层循环遍历这根木棍放第几个组别。

// 外层遍历木棍：n个木棍
for (int i = u; i < n; i++) {
	// 内层遍历分组：m个分组
	for (int j = 0; j < m; j++) {
		if (vis[i] == 1) {
			continue;
		}
		// 把第 i 个木棍给第 j 组
		d[j] += sticks[i];
		vis[i] = 1;
		dfs(u + 1);
		// 一样的回溯
		// 第 i 个木棍也回溯，不给第 j 组了
		d[j] -= sticks[i];
		vis[i] = 0;
	}
}

为了方便理解代码中的过程，用List记录下了每个组中的木棍，并在每次遍历完所有木棍后进行打印。

可以看到，第一次遍历完所有的木棍，所有木棍都放在第一组，第二组是空的。第二次遍历完时，第一组木棍只有10 20，第二组木棍有40。后续一样的道理。可以看到其实搜索过程中还是会有重复分组的情况，例如 [10] [20,40] 和 [20,40] [10] 本质是一样的，不过是组别换了。

下面给出解题代码：

import java.util.*;

public class Main {
    static int ans = 9999;
    static int[] sticks = new int[10];
    static int[] d = new int[10];
    static int[] vis = new int[10];
    static int n, m;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        for (int i = 0; i < n; i++) {
            sticks[i] = scan.nextInt();
        }
        dfs(0);
        System.out.println(ans);
    }
    static void dfs(int u) {
    	// 遍历完了全部木棍
        if (u == n) {
            int s1 = d[0], s2 = d[0];
            for (int i = 0; i < m; i++) {
                s1 = Math.max(s1, d[i]);
                s2 = Math.min(s2, d[i]);
            }
            ans = Math.min(ans, s1 - s2);
            return;
        }
        for (int i = u; i < n; i++) {
        	// 最多分成 m 组
        	// 考虑一根木棍可以放到第1组，第2组...第m组
            for (int j = 0; j < m; j++) {
                if (vis[i] == 1) {
                    continue;
                }
                d[j] += sticks[i];
                vis[i] = 1;
                // 注意下一阶段是u + 1不是i + 1
                dfs(u + 1);
                d[j] -= sticks[i];
                vis[i] = 0;
            }
        }
    }
}

要注意，dfs下一阶段是dfs(u+1)，而不是dfs(i+1)，这里的u是指已经遍历了几个木棍。

下面的代码中，对u + 1还是i + 1分别做了测试。
1、当为 i + 1时


2、当为start + 1时

import java.util.*;

public class Main {
    static int[] vis = new int[10];
    static LinkedList<Integer> tmp = new LinkedList<>();
    static int n, m;
    public static void main(String[] args) {
        int n = 4;
        int m = 2;
        // 4 个数分 2 组
        int[] nums = new int[] {1,2,3,4};
        dfs(nums, 0);
    }
    static void dfs(int[] nums, int start) {
        if (start == 4) {
            System.out.println(tmp);
            System.out.println("*******");
            return;
        }
        for (int i = start; i < 4; i++) {
            if (vis[i] == 1) {
                return;
            }
            vis[i] = 1;
            tmp.add(nums[i]);
            dfs(nums, i + 1);
            vis[i] = 0;
            tmp.removeLast();
        }
    }
}

这道题提供了一种解决分组问题的思路，之前一直没有遇到这种问题，都是普通的dfs搜索，这道题收获很大。
上面的写法有些丑陋，下面给出更优雅的写法，我们只需要遍历每根木棍即可，让这根木棍可以放在m个组里。

import java.io.*;
import java.util.*;

public class Main {
	static int[] sticks;
	static int[] groups;
	static int n, m;
	static int ans = Integer.MAX_VALUE;
	public static void main(String[] args) throws IOException {
		Scanner scan = new Scanner(System.in);
		n = scan.nextInt();
		m = scan.nextInt();
		// m个组
		groups = new int[m];
		// n个木棍
		sticks = new int[n];
		for (int i = 0; i < n; i++) {
			sticks[i] = scan.nextInt();
		}
		// 需要知道每根木棍放到了哪个组里
		dfs(0);
		System.out.println(ans);
	}
	// 考虑第 k 根木棍
	static void dfs(int k) {
		if (k == n) {
			int max = groups[0], min = groups[0];
			for (int i = 1; i < m; i++) {
				max = Math.max(max, groups[i]);
				min = Math.min(min, groups[i]);
			}
			ans = Math.min(ans, max - min);
			return;
		}
		// 当前木棍可以放0 - m-1号组里
		for (int i = 0; i < m; i++) {
			groups[i] += sticks[k];
			dfs(k + 1);
			groups[i] -= sticks[k];
		}