fd

Author: dingjikerbo

solution/src/main/java/com/inuker/solution/LongestAbsoluteFilePath.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayDeque;
 import java.util.Deque;
+import java.util.Stack;
 
 /**
  * Created by dingjikerbo on 16/11/26.
@@ -11,50 +12,21 @@ public class LongestAbsoluteFilePath {
 
     // 耗时4ms
     public int lengthLongestPath(String input) {
-        Deque<Integer> stack = new ArrayDeque<>();
-        int maxLen = 0;
-
-        String[] inputs = input.split("\n");
-        for (String s : inputs) {
-            int lev = s.lastIndexOf("\t") + 1; // 算出\t的个数，\t的个数代表当前目录的深度
-
-            // 要出栈直到当前目录的parent
-            while (stack.size() > lev) {
+        Stack<Integer> stack = new Stack<Integer>();
+        int max = 0;
+        for (String line : input.split("\n")) {
+            int depth = line.lastIndexOf("\t") + 1;
+            while (stack.size() > depth) {
                 stack.pop();
             }
-
-            // parent的总长度
             int parentLen = stack.isEmpty() ? 0 : stack.peek();
-
-            // 这里要从s中去掉所有的\t，且合并parent的长度，最后再加上一个'/'
-            int len = parentLen + s.length() - lev + 1;
-
-            // 给当前长度也push
-            stack.push(len);
-
-            // 最后要返回的是文件的路径长度，而不是目录的长度
-            if (s.contains(".")) {
-                // 这里要减1因为上面后面加了个'/'，而对于文件是没必要的
-                maxLen = Math.max(maxLen, len - 1);
-            }
-        }
-
-        return maxLen;
-    }
-
-    // 下面这种写法简洁一些，其实栈是可以去掉的
-    public int lengthLongestPath2(String input) {
-        String[] paths = input.split("\n");
-        int[] stack = new int[paths.length + 1];
-        int maxLen = 0;
-        for (String s : paths) {
-            int lev = s.lastIndexOf("\t") + 1;
-            stack[lev + 1] = stack[lev] + s.length() - lev + 1;
-
-            if (s.contains(".")) {
-                maxLen = Math.max(maxLen, stack[lev + 1] - 1);
+            int len = parentLen + line.length() - depth;
+            if (line.contains(".")) {
+                max = Math.max(len, max);
+            } else {
+                stack.push(len + 1);
             }
         }
-        return maxLen;
+        return max;
     }
 }

solution/src/main/java/com/inuker/solution/SentenceScreenFitting.java

@@ -11,7 +11,7 @@ public class SentenceScreenFitting {
 
     /**
      * https://discuss.leetcode.com/topic/62455/21ms-18-lines-java-solution/2
-     * 这道题思路是将这个句子按空格拼接起来，然后铺开，这里核心是start，表示每行的开头对应的铺开序列的索引，
+     * 这道题思路是将这个句子按空格拼接起来，然后铺开，这里核心是start，表示对应的循环铺开序列的索引，
      * 注意每行的开头一定要对应某个单词的第一个字符，所以如果不是的话需要调整start
      * 假如单词拼接为"abc de f "，注意结尾加了空格，铺开后为"abc de f abc de f abc de f abc de f ..."
      * start起始为0，下一行需要start+col，如果对到了空格则需要start++，因为每行起始不能是空格，

test/src/main/java/com/inuker/test/main.java

@@ -24,40 +24,22 @@ public class main {
     public static void main(String[] args) {
     }
 
-    public int maxKilledEnemies(char[][] grid) {
+    public int lengthLongestPath(String input) {
+        Stack<Integer> stack = new Stack<Integer>();
         int max = 0;
-        for (int i = 0; i < grid.length; i++) {
-            for (int j = 0; j < grid[0].length; j++) {
-                if (grid[i][j] == '0') {
-                    max = Math.max(max, killedEnemies(grid, i, j));
-                }
+        for (String line : input.split("\n")) {
+            int depth = line.lastIndexOf("\t") + 1;
+            while (stack.size() > depth) {
+                stack.pop();
             }
-        }
-        return max;
-    }
-
-    private int killedEnemies(char[][] grid, int i, int j) {
-        int count = 0;
-        for (int k = j - 1; k >= 0 && grid[i][k] != 'W'; k--) {
-            if (grid[i][k] == 'E') {
-                count++;
-            }
-        }
-        for (int k = j + 1; k < grid[0].length && grid[i][k] != 'W'; k++) {
-            if (grid[i][k] == 'E') {
-                count++;
+            int parentLen = stack.isEmpty() ? 0 : stack.peek();
+            int len = parentLen + line.length() - depth;
+            if (line.contains(".")) {
+                max = Math.max(len, max);
+            } else {
+                stack.push(len + 1);
             }
         }
-        for (int k = i - 1; k >= 0 && grid[k][j] != 'W'; k--) {
-            if (grid[k][j] == 'E') {
-                count++;
-            }
-        }
-        for (int k = i + 1; k < grid.length && grid[k][j] != 'W'; k++) {
-            if (grid[k][j] == 'E') {
-                count++;
-            }
-        }
-        return count;
+        return max;
     }
 }