九度OJ 1251：序列分割 （DFS）

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：166

解决：34

题目描述：

一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值

  比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1;

  {3,6}{2,4,3} m=2

  {3,3}{2,4}{6} m=3 所以m的最大值为3。

输入：

存在多组数据，每组数据一定行为一个正整数n（n<=64），第二行为n个数字。当n为0时，测试结束。

输出：

输出最大值m。

样例输入：

9
5 2 1 5 2 1 5 2 1
4
1 2 3 4
0

样例输出：

4
2

思路：

剪枝1：由大到小顺序排列，每次选择重上次选择的后一个开始。

剪枝2：如果一个数字把一组填满了，不需要考虑用更小的木棍填补这一组了，进行对下一组的搜索。

剪枝3：设对一组的搜索开始时，当前尚未用的最大的数字是a，如果把a选入不行，那么目前的状态应舍弃，因为这个数字a是必然要处理的，而放到后面处理，只会可用数字更少，而亦必然不可以。

剪枝4：由于数字已排序，前面一个数字尝试后不行，则跳过下面同样的数字。

这个题目很经典。黑书上有讲过，但其只错误的强调了剪枝2的效用，而事实上剪枝3是最强且必须的，需要注意。

代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int cmp(const void *a, const void *b) {
    return (*(int *)a < *(int *)b) * 2 - 1;
}

int n, A[100], sum;
int mark[100], ans, full;

int dfs(int cnt, int max, int re, int s) {
    if (cnt == 0) return 1;

    if (re == 0) {
        return dfs(cnt-1, max, max, 0);
    }

    int i;
    for (i=s; i<n; i++) {
        if (mark[i] || re-A[i] < 0) continue;

        mark[i] = 1;
        if (dfs(cnt, max, re-A[i], i+1)) return 1;
        mark[i] = 0;

        if (re-A[i] == 0) break;

        if (max == re) break; //the largest number have try, and failed, cut

        // not sucess, skip the same number
        while (A[i+1] == A[i] && i+1<n) i++;

    }

    return 0;
}

int Try(int len) {
    if (sum % len != 0) return 0;

    memset(mark, 0, sizeof mark);
    return dfs(sum/len, len, len, 0);
}

void Solve() {
    qsort(A, n, sizeof(int), cmp);

    int m = A[0];
    while (!Try(m)) m++;

    printf("%d\n", sum/m);
}

int main()
{
    int i, j;

    while (scanf("%d", &n), n) {
        for (sum=i=0; i<n; i++)
            scanf("%d", &A[i]), sum+=A[i];
        Solve();
    }
    return 0;
}