Leetcode - Triangle

Paste_Image.png

My code:

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if (triangle == null || triangle.size() == 0)
            return 0;
        if (triangle.size() == 1)
            return triangle.get(0).get(0);
        
        int[] currDis = new int[triangle.size()];
        currDis[0] = triangle.get(0).get(0);
        for (int i = 1; i < triangle.size(); i++) {
            currDis[i] = currDis[i - 1] + triangle.get(i).get(i);
            for (int j = i - 1; j > 0; j--)
                currDis[j] = Math.min(currDis[j - 1], currDis[j]) + triangle.get(i).get(j);
            currDis[0] = currDis[0] + triangle.get(i).get(0);
        }
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < currDis.length; i++) {
            if (min > currDis[i])
                min = currDis[i];
        }
        return min;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        ArrayList<Integer> a0 = new ArrayList<Integer>();
        ArrayList<Integer> a1 = new ArrayList<Integer>();
        ArrayList<Integer> a2 = new ArrayList<Integer>();
        a0.add(-1);
        a1.add(2);
        a1.add(3);
        a2.add(1);
        a2.add(-1);
        a2.add(-3);
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        result.add(a0);
        result.add(a1);
        result.add(a2);
        System.out.println(test.minimumTotal(result));
    }
}

My test result:

Paste_Image.png

這次題目一開始想偏了,覺得應該用最短路徑算法來做。后來發現沒有這么復雜。
首先,到每一層的最短距離,通過簡單的算法,我們是無法確定的。
但是,我們可以確定的是,到每一個結點的最短距離。這個是很容易確定的。類似于上面那道題目,設置一個數組,不斷刷新就行。
然后出現一個問題。該如何遍歷上一層呢?
我一開始設置了兩個數組,pastDis[] and currDis[]
分別用來記錄上一層和這一層的數據,然后不斷刷新。
后來查看代碼發現不需要這么復雜,直接一個數組就可以完工。并且可以解決因為覆蓋原數據導致的錯誤問題。方法就是從右往左遍歷。然后可以避免使用了已被覆蓋的數據。
差不多就這樣啦。

**
總結: Array
**

Anyway, Good luck, Richardo!

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if (triangle == null || triangle.size() == 0)
            return 0;
        int[] ret = new int[triangle.size()]; // record data
        /** scan from right to left, store minimum value to every element from upper to down */
        ret[0] = triangle.get(0).get(0);
        for (int i = 1; i < triangle.size(); i++) {
            for (int j = triangle.get(i).size() - 1; j >= 0; j--) {
                if (j == triangle.get(i).size() - 1)
                    ret[j] = triangle.get(i).get(j) + ret[j - 1];
                else if (j == 0)
                    ret[j] = triangle.get(i).get(j) + ret[j];
                else
                    ret[j] = triangle.get(i).get(j) + Math.min(ret[j - 1], ret[j]);
            }
        }
        
        /** find the minimum element in the ret array which means the minimum sum */
        Arrays.sort(ret);
        return ret[0];
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        ArrayList<Integer> a0 = new ArrayList<Integer>();
        ArrayList<Integer> a1 = new ArrayList<Integer>();
        ArrayList<Integer> a2 = new ArrayList<Integer>();
        ArrayList<Integer> a3 = new ArrayList<Integer>();
        a0.add(2);
        a1.add(3);
        a1.add(4);
        a2.add(6);
        a2.add(5);
        a2.add(7);
        a3.add(4);
        a3.add(1);
        a3.add(8);
        a3.add(3);
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        result.add(a0);
        result.add(a1);
        result.add(a2);
        result.add(a3);
        System.out.println(test.minimumTotal(result));
    }
}
Screenshot from 2016-01-11 11:41:31.png

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if (triangle == null || triangle.size() == 0)
            return 0;
        int[] ret = new int[triangle.size()]; // record data
        /** scan from right to left, store minimum value to every element from upper to down */
        ret[0] = triangle.get(0).get(0);
        for (int i = 1; i < triangle.size(); i++) {
            int size = i + 1;
            ret[size - 1] = triangle.get(i).get(size - 1) + ret[size - 2]; // for right end
            for (int j = size - 2; j >= 1; j--) {
                ret[j] = triangle.get(i).get(j) + Math.min(ret[j - 1], ret[j]);
            }
            ret[0] = triangle.get(i).get(0) + ret[0]; // for left end
        }
        
        /** find the minimum element in the ret array which means the minimum sum */
        Arrays.sort(ret);
        return ret[0];
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        ArrayList<Integer> a0 = new ArrayList<Integer>();
        ArrayList<Integer> a1 = new ArrayList<Integer>();
        ArrayList<Integer> a2 = new ArrayList<Integer>();
        ArrayList<Integer> a3 = new ArrayList<Integer>();
        a0.add(2);
        a1.add(3);
        a1.add(4);
        a2.add(6);
        a2.add(5);
        a2.add(7);
        a3.add(4);
        a3.add(1);
        a3.add(8);
        a3.add(3);
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        result.add(a0);
        result.add(a1);
        result.add(a2);
        result.add(a3);
        System.out.println(test.minimumTotal(result));
    }
}
Screenshot from 2016-01-11 15:14:51.png

這道題木我沒有做出來,因為,我想復雜了。
我覺得,既然要找出最小值,就得找出他們的路徑,會很復雜,需要全部計算,而這個很難用代碼實現,而且可能違背了簡潔的思想。
但關鍵在于,題目只要求我們求出最小值,而不需要把路徑找出來。
那么就可以只計算到每個結點的最短距離,其實就是全部算一遍,然后在最后,找出那個數組的最小值。
同樣的是從右到左掃描。

第一段代碼,我用if else 實現,來處理corner case。時間為7ms
第二段代碼,我想辦法取消掉了if else,少了判斷,時間一下短了, 變成了4ms,效率提升了近100%.

最近太懶惰了,
蘇秦遭受了那么大的挫折,最后還是站了起來,即使毫無希望,依然堅持自己。
很令人感動。雖然可能只是大秦帝國這本小說戲劇描繪的。
我不能放棄!
還有十天。

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if (triangle == null || triangle.size() == 0) {
            return 0;
        }
        
        int[] level = new int[triangle.size()];
        level[0] = triangle.get(0).get(0);
        for (int i = 1; i < triangle.size(); i++) {
            List<Integer> list = triangle.get(i);
            for (int j = list.size() - 1; j >= 0; j--) {
                if (j == list.size() - 1) {
                    level[j] = list.get(list.size() - 1) + level[j - 1];
                }
                else if (j == 0) {
                    level[j] = list.get(0) + level[0];
                }
                else {
                    level[j] = Math.min(level[j - 1], level[j]) + list.get(j);
                }
            }
        }
        
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < level.length; i++) {
            min = Math.min(min, level[i]);
        }
        return min;
    }
}

這一遍做,終于做出來了。因為我一直記得這道題目,我以前的錯誤在于,想找出路徑。其實只用找到最小值,不用找到路徑。

Anyway, Good luck, Richardo! --- 08/05/2016

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容