根据数据状况猜解法（续）、以及分治

面试中的分治的应用场景：

1，数据量整体做尝试可能性太多了，跑不完

2，数据分成多个块（常见是两块）之后，各自的可能性并不算多

3，合并多个块各自信息的整合过程不复杂

题目一

给定一个非负数组arr，和一个正数m。

返回arr的所有子序列中累加和%m之后的最大值。

public static int max1(int[] arr, int m) {
   HashSet<Integer> set = new HashSet<>();
   process(arr, 0, 0, set);
   int max = 0;
   for (Integer sum : set) {
      max = Math.max(max, sum % m);
   }
   return max;
}

public static void process(int[] arr, int index, int sum, HashSet<Integer> set) {
   if (index == arr.length) {
      set.add(sum);
   } else {
      process(arr, index + 1, sum, set);
      process(arr, index + 1, sum + arr[index], set);
   }
}

public static int max2(int[] arr, int m) {
   int sum = 0;
   int N = arr.length;
   for (int i = 0; i < N; i++) {
      sum += arr[i];
   }
   boolean[][] dp = new boolean[N][sum + 1];
   for (int i = 0; i < N; i++) {
      dp[i][0] = true;
   }
   dp[0][arr[0]] = true;
   for (int i = 1; i < N; i++) {
      for (int j = 1; j <= sum; j++) {
         dp[i][j] = dp[i - 1][j];
         if (j - arr[i] >= 0) {
            dp[i][j] |= dp[i - 1][j - arr[i]];
         }
      }
   }
   int ans = 0;
   for (int j = 0; j <= sum; j++) {
      if (dp[N - 1][j]) {
         ans = Math.max(ans, j % m);
      }
   }
   return ans;
}

public static int max3(int[] arr, int m) {
   int N = arr.length;
   // 0...m-1
   boolean[][] dp = new boolean[N][m];
   for (int i = 0; i < N; i++) {
      dp[i][0] = true;
   }
   dp[0][arr[0] % m] = true;
   for (int i = 1; i < N; i++) {
      for (int j = 1; j < m; j++) {
         // dp[i][j] T or F
         dp[i][j] = dp[i - 1][j];
         int cur = arr[i] % m;
         if (cur <= j) {
            dp[i][j] |= dp[i - 1][j - cur];
         } else {
            dp[i][j] |= dp[i - 1][m + j - cur];
         }
      }
   }
   int ans = 0;
   for (int i = 0; i < m; i++) {
      if (dp[N - 1][i]) {
         ans = i;
      }
   }
   return ans;
}

// 如果arr的累加和很大，m也很大
// 但是arr的长度相对不大
public static int max4(int[] arr, int m) {
   if (arr.length == 1) {
      return arr[0] % m;
   }
   int mid = (arr.length - 1) / 2;
   TreeSet<Integer> sortSet1 = new TreeSet<>();
   process4(arr, 0, 0, mid, m, sortSet1);
   TreeSet<Integer> sortSet2 = new TreeSet<>();
   process4(arr, mid + 1, 0, arr.length - 1, m, sortSet2);
   int ans = 0;
   for (Integer leftMod : sortSet1) {
      ans = Math.max(ans, leftMod + sortSet2.floor(m - 1 - leftMod));
   }
   return ans;
}

// 从index出发，最后有边界是end+1，arr[index...end]
public static void process4(int[] arr, int index, int sum, int end, int m, TreeSet<Integer> sortSet) {
   if (index == end + 1) {
      sortSet.add(sum % m);
   } else {
      process4(arr, index + 1, sum, end, m, sortSet);
      process4(arr, index + 1, sum + arr[index], end, m, sortSet);
   }
}

题目二

www.nowcoder.com/questionTer…

牛牛家里一共有n袋零食, 第i袋零食体积为v[i]，背包容量为w。

牛牛想知道在总体积不超过背包容量的情况下,

一共有多少种零食放法，体积为0也算一种放法

1 <= n <= 30, 1 <= w <= 2 * 10^9

v[i] (0 <= v[i] <= 10^9）

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int bag = sc.nextInt();
    int[] arr = new int[N];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = sc.nextInt();
    }
    long ways = ways(arr, bag);
    System.out.println(ways);
    sc.close();
}

public static long ways(int[] arr, int bag) {
    if (arr == null || arr.length == 0) {
        return 0;
    }
    if (arr.length == 1) {
        return arr[0] <= bag ? 2 : 1;
    }
    int mid = (arr.length - 1) >> 1;
    TreeMap<Long, Long> lmap = new TreeMap<>();
    long ways = process(arr, 0, 0, mid, bag, lmap);
    TreeMap<Long, Long> rmap = new TreeMap<>();
    ways += process(arr, mid + 1, 0, arr.length - 1, bag, rmap);
    TreeMap<Long, Long> rpre = new TreeMap<>();
    long pre = 0;
    for (Entry<Long, Long> entry : rmap.entrySet()) {
        pre += entry.getValue();
        rpre.put(entry.getKey(), pre);
    }
    for (Entry<Long, Long> entry : lmap.entrySet()) {
        long lweight = entry.getKey();
        long lways = entry.getValue();
        Long floor = rpre.floorKey(bag - lweight);
        if (floor != null) {
            long rways = rpre.get(floor);
            ways += lways * rways;
        }
    }
    return ways + 1;
}

// arr 30
// func(arr, 0, 14, 0, bag, map)

// func(arr, 15, 29, 0, bag, map)

// 从index出发，到end结束
// 之前的选择，已经形成的累加和sum
// 零食[index....end]自由选择，出来的所有累加和，不能超过bag，每一种累加和对应的方法数，填在map里
// 最后不能什么货都没选
// [3,3,3,3] bag = 6
// 0 1 2 3
// - - - - 0 -> （0 : 1）
// - - - $ 3 -> （0 : 1）(3, 1)
// - - $ - 3 -> （0 : 1）(3, 2)
public static long process(int[] arr, int index, long w, int end, int bag, TreeMap<Long, Long> map) {
    if (w > bag) {
        return 0;
    }
    if (index > end) {
        if (w != 0) {
            if (!map.containsKey(w)) {
                map.put(w, 1L);
            } else {
                map.put(w, map.get(w) + 1);
            }
            return 1;
        } else {
            return 0;
        }
    } else {
        long ways = process(arr, index + 1, w, end, bag, map);
        ways += process(arr, index + 1, w + arr[index], end, bag, map);
        return ways;
    }
}

卡特兰数

卡特兰数又称卡塔兰数，英文名Catalan number，是组合数学中一个常出现在各种计数问题中出现的数列。

其前几项为： 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, ...

k(0) = 1, k(1) = 1时，如果接下来的项满足：

k(n) = k(0) * k(n - 1) + k(1) * k(n - 2) + ... + k(n - 2) * k(1) + k(n - 1) * k(0)

或者

k(n) = c(2n, n) - c(2n, n-1)

或者

k(n) = c(2n, n) / (n + 1)

就说这个表达式，满足卡特兰数，常用的是范式1和2，3几乎不会使用到

题目三

假设给你N个0，和N个1，你必须用全部数字拼序列

返回有多少个序列满足：任何前缀串，1的数量都不少于0的数量

题目四

有N个二叉树节点，每个节点彼此之间无任何差别

返回由N个二叉树节点，组成的不同结构数量是多少？

卡特兰数的算法原型在做题时怎么发现？

1）如果像题目一一样，这个太明显了，你一定能发现

2）看看题目是不是类题目二问题，比如：

人员站队问题

出栈入栈问题

需要敏感度！