Lintcode: Minimum Adjustment Cost 解题报告

Minimum Adjustment Cost

Given an integer array, adjust each integers so that the difference of every adjcent integers are not greater than a given number target.

If the array before adjustment is A, the array after adjustment is B, you should minimize the sum of |A[i]-B[i]| 

注意

You can assume each number in the array is a positive integer and not greater than 100

样例

Given [1,4,2,3] and target=1, one of the solutions is [2,3,2,3], the adjustment cost is 2 and it's minimal. Return 2.

 

原题链接：http://lintcode.com/zh-cn/problem/minimum-adjustment-cost/#

 

SOL 1:

主页君现在最喜欢这种题目了。好兴奋啊！

好啦，我们先上第一个版本，递归版本：

当前可取的值是1-100，并且与上一个值是在target的差值以内。

这个版本肯定是超时啦。因为我们有大量的重复的计算，每一次从头至尾计算时，从某个index开始的某个取值的计算会反复进行。

/**
     * @param A: An integer array.
     * @param target: An integer.
     */
    public static int MinAdjustmentCost1(ArrayList<Integer> A, int target) {
        // write your code here
        if (A == null) {
            return 0;
        }
        
        return rec(A, new ArrayList<Integer>(A), target, 0);
    }
    
    /*
     * SOL 1:
     * 最普通的递归方法。
     * */
    public static int rec(ArrayList<Integer> A, ArrayList<Integer> B, int target, int index) {
        int len = A.size();
        if (index >= len) {
            // The index is out of range.
            return 0;
        }
        
        int dif = 0;
        
        int min = Integer.MAX_VALUE;
        
        // If this is the first element, it can be from 1 to 100;
        for (int i = 0; i <= 100; i++) {
            if (index != 0 && Math.abs(i - B.get(index - 1)) > target) {
                continue;
            }
            
            B.set(index, i);
            dif = Math.abs(i - A.get(index));
            dif += rec(A, B, target, index + 1);
            min = Math.min(min, dif);
            
            // 回溯
            B.set(index, A.get(index));
        }
        
        return min;
    }

 

SOL 2:

我们还是跟以前一样，加一个memory，减少重复计算。

轻松AC. M[i][j]的定义是：从index = i处开始往后所有的differ，并且A[i]的取值取为j + 1;

/*
     * 递归2：
     * Rec + memory.
     * */
    /**
     * @param A: An integer array.
     * @param target: An integer.
     */
    public static int MinAdjustmentCost2(ArrayList<Integer> A, int target) {
        // write your code here
        if (A == null || A.size() == 0) {
            return 0;
        }
        
        int[][] M = new int[A.size()][100];
        for (int i = 0; i < A.size(); i++) {
            for (int j = 0; j < 100; j++) {
                M[i][j] = Integer.MAX_VALUE;
            }
        }
        
        return rec2(A, new ArrayList<Integer>(A), target, 0, M);
    }
    
    public static int rec2(ArrayList<Integer> A, ArrayList<Integer> B, int target, int index, 
           int[][] M) {
        int len = A.size();
        if (index >= len) {
            // The index is out of range.
            return 0;
        }
        
        int dif = 0;
        int min = Integer.MAX_VALUE;
        
        // If this is the first element, it can be from 1 to 100;
        for (int i = 1; i <= 100; i++) {
            if (index != 0 && Math.abs(i - B.get(index - 1)) > target) {
                continue;
            }
            
            if (M[index][i - 1] != Integer.MAX_VALUE) {
                dif = M[index][i - 1];
                min = Math.min(min, dif);
                continue;
            }
            
            B.set(index, i);
            dif = Math.abs(i - A.get(index));
            dif += rec2(A, B, target, index + 1, M);
            
            min = Math.min(min, dif);
            
            // Record the result.
            M[index][i - 1] = dif;
            
            // 回溯
            B.set(index, A.get(index));
        }
        
        return min;
    }

 

SOL 3:修改了一下，递归增加一个参数 ： int x，表示在index 处A[i]取值为x，返回值的意义是，当此值取x时，从index往后，所有的diff之和。

这样的话，递归会看起来更加简洁一点儿。我们不需要记录上一个A[i]的取值。

 

/*
     * SOLUTION 3 递归2：
     * Rec + memory.
     * 改进的递归版本
     * */
    /**
     * @param A: An integer array.
     * @param target: An integer.
     */
    public static int MinAdjustmentCost3(ArrayList<Integer> A, int target) {
        // write your code here
        if (A == null || A.size() == 0) {
            return 0;
        }
        
        int[][] M = new int[A.size()][100];
        for (int i = 0; i < A.size(); i++) {
            for (int j = 0; j < 100; j++) {
                M[i][j] = Integer.MAX_VALUE;
            }
        }
        
        // 首个数字可以取1-100
        int min = Integer.MAX_VALUE;
        for (int i = 1; i <= 100; i++) {
            min = Math.min(min, rec3(A, target, 0, i, M));
        }
        
        return min;
    }
    
    /*
     * 将当前值设置为x能求得的最小解 
     * */
    public static int rec3(ArrayList<Integer> A, int target, int index, int x, 
           int[][] M) {
        int len = A.size();
        if (index >= len) {
            // The index is out of range.
            return 0;
        }
        
        if (M[index][x - 1] != Integer.MAX_VALUE) {
            return M[index][x - 1];
        }
        
        int bas = Math.abs(x - A.get(index));
        int min = Integer.MAX_VALUE;
        
        // 对下一个值尝试取1-100
        for (int i = 1; i <= 100; i++) {
            // 下一个值的取值不可以超过abs
            if (index != len - 1 && Math.abs(i - x) > target) {
                continue;
            }
            
            // 计算dif 
            int dif = bas + rec3(A, target, index + 1, i, M);
            min = Math.min(min, dif);
        }
        
        // Record the result.
        M[index][x - 1] = min;
        return min;
    }

 

SOL 4:

LALA,主页君终于来打BOSS了。有了前面的递归的铺垫，把它转化为一个二维DP也就是水到渠成了。

D[i][v]: 把index = i的值修改为v，所需要的最小花费

我们引用一下九章算法黄老师课上的课件:

其实很简单，就是当前index为v时，我们把上一个index从1-100全部过一次，取其中的最小值（判断一下前一个跟当前的是不是abs <= target）

/*
     * SOLUTION 4：
     * DP
     * */
    /**
     * @param A: An integer array.
     * @param target: An integer.
     */
    public static int MinAdjustmentCost(ArrayList<Integer> A, int target) {
        // write your code here
        if (A == null || A.size() == 0) {
            return 0;
        }
        
        // D[i][v]: 把index = i的值修改为v，所需要的最小花费
        int[][] D = new int[A.size()][101];
        
        int size = A.size();
        
        for (int i = 0; i < size; i++) {
            for (int j = 1; j <= 100; j++) {
                D[i][j] = Integer.MAX_VALUE;
                if (i == 0) {
                    // The first element.
                    D[i][j] = Math.abs(j - A.get(i));
                } else {
                    for (int k = 1; k <= 100; k++) {
                        // 不符合条件 
                        if (Math.abs(j - k) > target) {
                            continue;
                        }
                        
                        int dif = Math.abs(j - A.get(i)) + D[i - 1][k];
                        D[i][j] = Math.min(D[i][j], dif);
                    }
                }
            }
        }
        
        int ret = Integer.MAX_VALUE;
        for (int i = 1; i <= 100; i++) {
            ret = Math.min(ret, D[size - 1][i]);
        }
        
        return ret;
    }

 

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/algorithm/dp/MinAdjustmentCost_Class.java