原根

#include <unordered_set>

class Solution {
public:
    /**
     * 原根
     * @param n int整型 
     * @param s string字符串vector 
     * @return int整型
     */
    int solve(int n, vector<string>& s) {
        vector<vector<int>> T(1, vector<int>(26, 0));
        unordered_set<int> S;
        for(auto &w: s){
            int i=0, j=0;
            while(j<w.length() && T[i][w[j]-'a'])
                i = T[i][w[j++]-'a'];
            unordered_set<int>::iterator it = S.find(i);
            if(it != S.end())
                S.erase(it);
            while(j < w.length()){
                T[i][w[j++]-'a'] = T.size();
                i = T.size();
                T.push_back(vector<int>(26, 0));
                if(j == w.length())
                    S.insert(i);
            }
        }
        return S.size();
    }
};

import java.util.*;
import java.util.Comparator;
import java.util.stream.Stream;
import java.util.stream.Collectors;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param n int整型 
     * @param s string字符串一维数组 
     * @return int整型
     */
    
    public int solve (int n, String[] s) {
        HashMap<String, Integer> map = new HashMap<>();
        for(String str : s) {
            if(map.containsKey(str)) {
                map.remove(str);
                map.put(str, -1);
            }else {
                map.put(str, 1);
            }
        }
        int index = 0;
        for(HashMap.Entry entry: map.entrySet()) {
            if((Integer)entry.getValue() == 1) {
                entry.setValue(index++);
            }
        }
        String[] arr = new String[index];
        for(HashMap.Entry entry : map.entrySet()) {
            if((Integer)entry.getValue() > -1)
                arr[(Integer)entry.getValue()] = (String)entry.getKey();
        }

        /* 编译提示不通过，但运行正常*/
        List<String> list = Arrays.asList(arr);
        Object[] array = list.stream().sorted(Comparator.comparing(String::length)
                    .thenComparing(Comparator.naturalOrder())).toArray();
        int count = 0;
        TrieNode root = new TrieNode();
        for(Object obj : array) {
            if(root.insert((String)obj)) {
                count++;
            }
        }
        return count;
    }
}
class TrieNode {
    private final int CHAR_COUNT = 26;
    private TrieNode[] child;
    private boolean end;
    TrieNode() {
        this.child = new TrieNode[CHAR_COUNT];
        this.end = false;
    }
    public int getIndexFromChar(char c) {
        return (c - 'a');
    }
    public boolean insert(String str) {
        TrieNode cur = this;
        for(int i = 0; i < str.length(); i++) {
            int index = this.getIndexFromChar(str.charAt(i));
            if(cur.child[index] != null && cur.child[index].end == true)
                return false;
            if(cur.child[index] == null) {
                cur.child[index] = new TrieNode();
                cur = cur.child[index];
            }
        }
        cur.end = true;
        return true;
    }
}

#include <numeric>

class Solution {
public:
    int solve(int n, vector<string>& s) {
        vector<vector<int>> trie(1, vector<int>(26));
        vector<int> a(1);
        for (auto si: s) {
            int i = 0, j = 0;
            while (j < si.length() && trie[i][si[j] - 'a']) i = trie[i][si[j++] - 'a'];
            a[i] = 0;
            while (j < si.length()) {
                i = trie[i][si[j++] - 'a'] = trie.size();
                trie.push_back(vector<int>(26));
                a.push_back(j == si.length());
            }
        }
        return accumulate(a.begin(), a.end(), 0);
    }
};