Leetcode算法比赛----Longest Absolute File Path

问题描述

---

Suppose we abstract our file system by a string in the following manner:

The string "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext" represents:

dir
    subdir1
    subdir2
        file.ext

The directory dir contains an empty sub-directory subdir1 and a sub-directory subdir2 containing a file file.ext.

The string "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext" represents:

dir
    subdir1
        file1.ext
        subsubdir1
    subdir2
        subsubdir2
            file2.ext

The directory dir contains two sub-directories subdir1 and subdir2. subdir1 contains a file file1.ext and an empty second-level sub-directory subsubdir1. subdir2 contains a second-level sub-directory subsubdir2 containing a file file2.ext.

We are interested in finding the longest (number of characters) absolute path to a file within our file system. For example, in the second example above, the longest absolute path is "dir/subdir2/subsubdir2/file2.ext", and its length is 32 (not including the double quotes).

Given a string representing the file system in the above format, return the length of the longest absolute path to file in the abstracted file system. If there is no file in the system, return 0.

Note:
The name of a file contains at least a . and an extension.
The name of a directory or sub-directory will not contain a ..
Time complexity required: O(n) where n is the size of the input string.

Notice that a/aa/aaa/file1.txt is not the longest file path, if there is another path aaaaaaaaaaaaaaaaaaaaa/sth.png.

package code;

import java.util.ArrayList;

public class Solution {
    static int startPos=0;
    static int nextLevel=0;
    
    public  int lengthLongestPath(String input) {
        startPos=0;
        MyList list=new MyList(null, 0, 0, null);//新建一个空的MyList，表示根目录
        deal(list,input, 0);
        if(list.containsFile){
            return list.subLength-1; //因为在第一层的目录之前算上了'/' 符号，要去除掉
        }
        else{
            return 0;
        }
    }

    public static void deal(MyList parent,String input,int curLevel){
        while(startPos<input.length()){ //startPos是全局指针，用以标识当前正在处理原是字符串的哪一部分
                String curStr=input.substring(startPos);
                int len=curStr.indexOf('\n');
                if(len>0){
                    startPos+=len+1;
                    String fileName=curStr.substring(0, len);
                    MyList current=new MyList(parent,len,0,fileName);
                    parent.subs.add(current);
                    //current.myLength=fileName.length();
                    current.myLength=len;   //省去了fileName.length()函数调用
                    if(fileName.indexOf('.')>0){
                        parent.containsFile=true;
                        if(parent.subLength<len+1){
                            parent.subLength=len+1;//加 1 是为了在子目录之前算上'/'符号
                        }
                    }
                    nextLevel=findNextLevel(input);
                    startPos+=nextLevel;
                    if(nextLevel==curLevel+1){
                        //正好是下一级
                        deal(current,input,nextLevel);
                        if(current.containsFile){
                            parent.containsFile=true;
                            int newLength=current.myLength+current.subLength+1;//加 1 是为了在子目录之前算上'/'符号
                            if(parent.subLength<newLength){
                                parent.subLength=newLength;
                            }
                        }

                    }
                    if(nextLevel<curLevel){
                        /*说明接下来要处理的文件或目录名层级比本层级高，因此要退出当前层   级的处理,也正是因为下一个层级可能比
                        * 之前好几个层级都高，所以应当把nextLevel定义为全局变量，使得    退出一个层级的deal后，nextLevel得以完整，
                        * 在返回到栈中的上一个deal的环境中时，让会继续比较那个栈环境中  的currentLevel和nextLevel
                        */
                        break;
                    }
                    //如果nextLevel==curLevel,那么就继续循环
                }
                else{
                    //len<0说明当前处理的是最后一个 file or directory 的name
                    startPos+=curStr.length();
                    MyList current=new MyList(parent,len,-1,curStr);//故意将   subLength=-1
                    parent.subs.add(current);
                    if(curStr.indexOf('.')>0){
                        //是 file
                        parent.containsFile=true;
                        if(parent.subLength<curStr.length()+1){
                            parent.subLength=curStr.length()+1;
                        }
                    }
                
                    break;
                }
            
        }
    }

    public static int findNextLevel(String input){
        int level=0;
        while(input.charAt(startPos+level)=='\t'){//通过数制表符的个数判断层级
            level++;
        }
        return level;
    }

    static class MyList{;
        String myName;
        MyList parent;
        int myLength;
        int subLength;
        boolean containsFile=false;//默认情况下子目录下没有File
        ArrayList<MyList>subs=new ArrayList<>();
        public MyList(MyList parent,int myLength,int subLength,String myName){
            this.parent=parent;
            this.myLength=myLength;
            this.subLength=subLength;
            this.myName=myName;
        }
    }
}

转载于:https://www.cnblogs.com/dongling/p/5792841.html