JAVA程序设计：切分数组（LCP 14）

给定一个整数数组 nums ，小李想将 nums 切割成若干个非空子数组，使得每个子数组最左边的数和最右边的数的最大公约数大于 1 。为了减少他的工作量，请求出最少可以切成多少个子数组。

示例 1：

输入：nums = [2,3,3,2,3,3]

输出：2

解释：最优切割为 [2,3,3,2] 和 [3,3] 。第一个子数组头尾数字的最大公约数为 2 ，第二个子数组头尾数字的最大公约数为 3 。

示例 2：

输入：nums = [2,3,5,7]

输出：4

解释：只有一种可行的切割：[2], [3], [5], [7]

限制：

1 <= nums.length <= 10^5
2 <= nums[i] <= 10^6

方法一：定义dp[i]表示前i个数能够切分的最少数量的子数组【复杂度：O(n^2)，超时】

class Solution {

    private int[] dp;

    public int splitArray(int[] nums) {

        int n = nums.length;
        dp = new int[n];

        Arrays.fill(dp, -1);

        return f(nums, 0, n);

    }

    private int f(int[] arr, int index, int n) {

        if (index == n) return 0;

        if (dp[index] != -1)
            return dp[index];

        int res = n - index;

        for (int i = index + 1; i < n; i++)
            if (gcd(arr[index], arr[i]) > 1)
                res = Math.min(res, f(arr, i + 1, n) + 1);

        res = Math.min(res, f(arr, index + 1, n) + 1);

        return dp[index] = res;

    }

    private int gcd(int a, int b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
}

方法二：素数筛+动态规划【参考：官方题解】

class Solution {
    public int splitArray(int[] nums) {

        int n = nums.length, m = 2;
        int[] dp = new int[1000005];
        int[] prime = new int[1000005];
        int[] min_prime = new int[1000005];

        for (int i = 0; i < n; i++)
            m = Math.max(m, nums[i]);

        for (int i = 2; i <= m; i++) {
            if (min_prime[i] == 0) {
                prime[++prime[0]] = i;
                min_prime[i] = i;
            }
            for (int j = 1; j <= prime[0]; j++) {
                if (i > m / prime[j]) break;
                min_prime[i * prime[j]] = prime[j];
                if (i % prime[j] == 0) break;
            }
        }

        for (int i = 1; i <= prime[0]; i++)
            dp[prime[i]] = n;
        for (int x = nums[0]; x > 1; x /= min_prime[x])
            dp[min_prime[x]] = 0;

        int ans = 1;

        for (int i = 0; i < n; i++) {
            ans = i + 1;
            for (int x = nums[i]; x > 1; x /= min_prime[x])
                ans = Math.min(ans, dp[min_prime[x]] + 1);
            if (i == n - 1) break;
            for (int x = nums[i + 1]; x > 1; x /= min_prime[x])
                dp[min_prime[x]] = Math.min(ans, dp[min_prime[x]]);
        }

        return ans;

    }
}