使序列递增的最小交换次数

/*
 * Problem: We have two equal-length integer arrays nums1 and nums2 that are not empty. In one operation, we can swap nums1[i] and nums2[i].
 * Goal: Return the minimum number of operations needed to make both nums1 and nums2 strictly increasing.
 * Explanation: Two arrays arr are strictly increasing if arr[0] < arr[1] < arr[2] < ... < arr[arr.length - 1].
 * Constraints: It is guaranteed that it is possible to achieve the goal.
 */

import java.util.stream.IntStream;

public class Solution {
    public int minSwap(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int[] keep = new int[n];  // Minimum swaps to make arrays increasing if we don't swap at i
        int[] swap = new int[n];  // Minimum swaps to make arrays increasing if we swap at i
        keep[0] = 0;
        swap[0] = 1;

        IntStream.range(1, n).forEach(i -> {
            keep[i] = swap[i] = n;  // Initialize with a large number

            // Condition if current elements are already in increasing order without swapping
            if (nums1[i] > nums1[i - 1] && nums2[i] > nums2[i - 1]) {
                keep[i] = keep[i - 1];
                swap[i] = swap[i - 1] + 1;
            }

            // Condition if current elements will be in increasing order if swapped
            if (nums1[i] > nums2[i - 1] && nums2[i] > nums1[i - 1]) {
                keep[i] = Math.min(keep[i], swap[i - 1]);
                swap[i] = Math.min(swap[i], keep[i - 1] + 1);
            }
        });

        return Math.min(keep[n - 1], swap[n - 1]);
    }
}