把舌头伸出来呼吸舒服一点,国产WW久久久久久久久久,最近2019免费中文第一页

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

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Leetcode - Triangle

Leetcode - Triangle

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Leetcode - Triangle

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频