609. Find Duplicate File in System（python+cpp）

题目：

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.
A group of duplicate files consists of at least two files that have exactly the same content.
A single directory info string in the input list has the following format:
"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"
It means there are n files (f1.txt, f2.txt … fn.txt with content f1_content, f2_content … fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.
The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:
"directory_path/file_name.txt"
Example 1:

Input: ["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"] 
Output:   [["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]] 

Note:
　No order is required for the final output.
　You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
　The number of files given is in the range of [1,20000].
　You may assume no files or directories share the same name in the same directory.
　You may assume each given directory info represents a unique directory.
　Directory path and file info are separated by a single blank space.
Follow-up beyond contest:
　Imagine you are given a real file system, how will you search files? DFS or BFS?
　If the file content is verylarge (GB level), how will you modify your solution?
　If you can only read the file by 1kb each time, how will you modify your solution?
　What is the time complexity of your modified solution?
　What is the most time-consuming part and memory consuming part of it?
　How to optimize?
　 How to make sure the duplicated files you find are not false positive?

解释：
找到内容相同的文件的路径，并将路径打成一个组。
用字典做，用collections.defaultdict()，使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict,这里一定要用defaultdict，原因是dict可以用“=”赋值，但是键不存在的话不可以用append，但是defaultdict可以。_dict是一个（key,[])类型的字典,其实也可以用dict做，dupli_file[content] = dupli_file.get(content, []) + [di+"/"+filename]，要用到dict的get()和list相加的知识
defaultdict['不存在的key'](返回默认值)相当于 dict.get(不存在的key，默认值)
partition()方法用来根据指定的分隔符将字符串进行分割。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。和split的区别是，split所有的都分开，partition值按照第一个分隔符分开。
上面的文字是当时第一次解题的时候写的注释，现在看emmmmm，果然多刷题可以提高代码能力。
python代码：

from collections import defaultdict
class Solution(object):
    def findDuplicate(self, paths):
        """
        :type paths: List[str]
        :rtype: List[List[str]]
        """
        _dict=defaultdict(list)
        for path in paths:
            path=path.split()
            root=path[0]
            for _file in path[1:]:
                root2,content=_file.split('(')
                _dict[content[:-1]].append(root+'/'+root2)
        return [value for value in _dict.values() if len(value)>1]

c++代码：

#include <map>
#include <sstream>
using namespace std;
class Solution {
public:
    vector<vector<string>> findDuplicate(vector<string>& paths) {
        map<string,vector<string>> _map;
        for (auto path:paths)
        {
            istringstream _path(path);
            string word="";
            int i=0;
            string root="";
            while(getline(_path,word,' '))
            {
                if (root=="")
                    root=word;
                else
                {
                    string root2="",content="";
                    string tmp="";
                    istringstream _word(word);
                    while(getline(_word,tmp,'('))
                    {
                        if (root2=="")
                            root2=tmp;
                        else
                            content=tmp;
                    }
                    _map[content.substr(0,content.size()-1)].push_back(root+"/"+root2);
                }      
            }   
        }
        vector<vector<string>> result;
        for(auto item:_map)
        {
            if (item.second.size()>1)
                result.push_back(item.second);
        }
        return result;    
    }
};

总结：
寻找c++中一种比较简单的字符串分割方法ing…