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