三、搜索推荐系统（Weekly Contest 164）

题目描述：
给你一个产品数组 products 和一个字符串 searchWord ，products 数组中每个产品都是一个字符串。

请你设计一个推荐系统，在依次输入单词 searchWord 的每一个字母后，推荐 products 数组中前缀与 searchWord 相同的最多三个产品。如果前缀相同的可推荐产品超过三个，请按字典序返回最小的三个。

请你以二维列表的形式，返回在输入 searchWord 每个字母后相应的推荐产品的列表。

示例 1：

输入：products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”], searchWord = “mouse”
输出：[
[“mobile”,“moneypot”,“monitor”],
[“mobile”,“moneypot”,“monitor”],
[“mouse”,“mousepad”],
[“mouse”,“mousepad”],
[“mouse”,“mousepad”]
]
解释：按字典序排序后的产品列表是 [“mobile”,“moneypot”,“monitor”,“mouse”,“mousepad”]
输入 m 和 mo，由于所有产品的前缀都相同，所以系统返回字典序最小的三个产品 [“mobile”,“moneypot”,“monitor”]
输入 mou， mous 和 mouse 后系统都返回 [“mouse”,“mousepad”]
示例 2：

输入：products = [“havana”], searchWord = “havana”
输出：[[“havana”],[“havana”],[“havana”],[“havana”],[“havana”],[“havana”]]
示例 3：

输入：products = [“bags”,“baggage”,“banner”,“box”,“cloths”], searchWord = “bags”
输出：[[“baggage”,“bags”,“banner”],[“baggage”,“bags”,“banner”],[“baggage”,“bags”],[“bags”]]
示例 4：

输入：products = [“havana”], searchWord = “tatiana”
输出：[[],[],[],[],[],[],[]]

提示：

1 <= products.length <= 1000
1 <= Σ products[i].length <= 2 * 10^4
products[i] 中所有的字符都是小写英文字母。
1 <= searchWord.length <= 1000
searchWord 中所有字符都是小写英文字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-suggestions-system
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题真的无语了，很明显使用的是前缀树，但是需要注意的是products中可以有重复的，因此你的节点需要有一个统计次数的属性，真是醉了

class Solution {
        public List<List<String>> suggestedProducts(String[] products, String searchWord) {
//        使用前缀树
            Node root = new Node();
            for (String product : products) {
                Node node = root;
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < product.length(); i++) {
                    char temchar = product.charAt(i);
                    if (node.node[temchar - 'a'] == null){
                        node.node[temchar - 'a'] = new Node();
                    }
                    node = node.node[temchar - 'a'];
                    sb.append(temchar);
                }
                node.isleaf = true;
                node.time ++;
                node.string = new String(sb);
            }
            // for (int i = 0; i <26; i++) {
            //     char tme = (char) ('a'+ i);
            //     System.out.print( tme + "\t");
            //     System.out.println( root.node[i] == null);
            // }
//        建立完成，开始搜索
            List<List<String>> list = new ArrayList<>();
            for (int i = 0; i < searchWord.length(); i++) {
                list.add(new ArrayList<>());
            }
            for (int i = 0; i < searchWord.length(); i++) {
                char temchar = searchWord.charAt(i);
                Node node = root;
//            找到前i个合适的
                for (int j = 0; j <= i; j++) {
                    if(node.node[searchWord.charAt(j) - 'a'] == null){
                        // System.out.println("\t" + i);
                        // node =
                        return list;
                    }
                    node=  node.node[searchWord.charAt(j) - 'a'] ;
                }
//             寻找下一个满足的字典序最小的
                List<String> temlist = list.get(i);
                Node temnode = node;
                add(temnode,temlist);
            }
            return list;

        }
        public void add(Node node,List<String> list){
            if(list.size() >= 3){
                return;
            }
            if(node == null){
                return;
            }
            if(node.isleaf){
                int time = node.time;
                for (int i = 0; i < time && list.size() < 3; i++) {
                    list.add(node.string);
                }
            }
            for (int i = 0; i < 26; i++) {
                if(node.node[i] != null){
                    add(node.node[i],list);
                }

            }
        }
        //每个节点包括该节点的值以及下一个节点,是否是叶子节点,如果是叶子节点包含了
        class Node {
            
            Node node[] = new Node[26];
            boolean isleaf;
            String string;
            int time;
        }
    }

看看别人没有使用前缀树实现的

class Solution {
    public List<List<String>> suggestedProducts(String[] products, String searchWord) {
        List<List<String>> list = new ArrayList<>();
        Arrays.sort(products);
        for(int i=0;i<searchWord.length();i++){
            String r = searchWord.substring(0,i+1);
            ArrayList<String> sc = new ArrayList<>();
            int count=0;
            for(int j=0;j<products.length;j++){
                if(products[j].indexOf(r)==0){
                    sc.add(products[j]);
                    count++;
                    if(count==3)break;
                }
            }
            list.add(sc);
        }
        return list;
    }
}