LeetCode 面试题 17.11. 单词距离 / 1021. 删除最外层的括号 / 468. 验证IP地址

Posted 2022-05-31 Zephyr丶J

面试题 17.11. 单词距离

2022.5.27 每日一题

题目描述

有个内含单词的超大文本文件，给定任意两个不同的单词，找出在这个文件中这两个单词的最短距离(相隔单词数)。如果寻找过程在这个文件中会重复多次，而每次寻找的单词不同，你能对此优化吗?

示例：

输入：words = [“I”,“am”,“a”,“student”,“from”,“a”,“university”,“in”,“a”,“city”], word1 = “a”, word2 = “student”
输出：1

提示：

words.length <= 100000

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

思路

因为要多次重复寻找过程，所以先将所有单词存入map中，然后找两个数组中最短的距离，用双指针找

class Solution 
    public int findClosest(String[] words, String word1, String word2) 
        //先把所有单词都放在一个map中
        //然后针对两个单词的list，找最短距离

        Map<String, List<Integer>> map = new HashMap<>();
        int l = words.length;
        for(int i = 0; i < l; i++)
            List<Integer> list = map.getOrDefault(words[i], new ArrayList<>());
            list.add(i);
            map.put(words[i], list);
        
        List<Integer> list1 = map.get(word1);
        List<Integer> list2 = map.get(word2);
        /*
        for(int i : list1)
            System.out.print(i + " ");
        
        System.out.println();
        
        for(int i : list2)
            System.out.print(i + " ");
        
        */
        //因为两个数组都是排序好的，所以可以用双指针来找
        //比如在list2中，找和list1中最短的距离
        //那么遍历list1中所有数，先找到比每一个数大一位的数，期间每次更新min
        
        int idx = 0;
        int min = 100000;
        for(int t : list1)
            
            int id = idx;
            while(idx < list2.size() && list2.get(idx) - t < 0)
                min = Math.min(Math.abs(list2.get(idx) - t), min);
                idx++;
            
            if(idx < list2.size())
                min = Math.min(Math.abs(list2.get(idx) - t), min);
            else
                break;
        
        return min;
    

1021. 删除最外层的括号

2022.5.28 每日一题

题目描述

有效括号字符串为空 “”、“(” + A + “)” 或 A + B ，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。

例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 s 非空，且不存在将其拆分为 s = A + B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 s，考虑将其进行原语化分解，使得：s = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。

对 s 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 s 。

示例 1：

输入：s = “(()())(())”
输出：“()()()”
解释：
输入字符串为 “(()())(())”，原语化分解得到 “(()())” + “(())”，
删除每个部分中的最外层括号后得到 “()()” + “()” = “()()()”。

示例 2：

输入：s = “(()())(())(()(()))”
输出：“()()()()(())”
解释：
输入字符串为 “(()())(())(()(()))”，原语化分解得到 “(()())” + “(())” + “(()(()))”，
删除每个部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())”。

示例 3：

输入：s = “()()”
输出：“”
解释：
输入字符串为 “()()”，原语化分解得到 “()” + “()”，
删除每个部分中的最外层括号后得到 “” + “” = “”。

提示：

1 <= s.length <= 10^5
s[i] 为 ‘(’ 或 ‘)’
s 是一个有效括号字符串

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

思路

class Solution 
    public String removeOuterParentheses(String s) 
        //一个原语是什么意思呢，就是能使最外层括号配对的字符串
        //那么找原语就是找最外层的括号
        //直接用数字表示就行了，左括号+1，右括号-1
        //达到0的时候就找到了和最外层配对的括号，然后记录这个删除位置就行了
        StringBuffer sb = new StringBuffer();
        int cur = 0;
        boolean flag = false;
        for(int i = 0; i < s.length(); i++)
            char c = s.charAt(i);
            if(cur == 0)
                flag = true;
            if(c == '(')
                cur++;
            else
                cur--;
            
            if(flag || cur == 0)
                flag = false;
                continue;
            
            else
                sb.append(c);
        
        return sb.toString();
    

468. 验证IP地址

2022.5.29 每日一题

题目描述

给定一个字符串 queryIP。如果是有效的 IPv4 地址，返回 “IPv4” ；如果是有效的 IPv6 地址，返回 “IPv6” ；如果不是上述类型的 IP 地址，返回 “Neither” 。

有效的IPv4地址 是 “x1.x2.x3.x4” 形式的IP地址。 其中 0 <= xi <= 255 且 xi 不能包含 前导零。例如: “192.168.1.1” 、 “192.168.1.0” 为有效IPv4地址， “192.168.01.1” 为无效IPv4地址; “192.168.1.00” 、 “192.168@1.1” 为无效IPv4地址。

一个有效的IPv6地址 是一个格式为“x1:x2:x3:x4:x5:x6:x7:x8” 的IP地址，其中:

• 1 <= xi.length <= 4
• xi 是一个 十六进制字符串 ，可以包含数字、小写英文字母( ‘a’ 到 ‘f’ )和大写英文字母( ‘A’ 到 ‘F’ )。
• 在 xi 中允许前导零。

例如 “2001:0db8:85a3:0000:0000:8a2e:0370:7334” 和 “2001:db8:85a3:0:0:8A2E:0370:7334” 是有效的 IPv6 地址，而 “2001:0db8:85a3::8A2E:037j:7334” 和 “02001:0db8:85a3:0000:0000:8a2e:0370:7334” 是无效的 IPv6 地址。

示例 1：

输入：queryIP = “172.16.254.1”
输出：“IPv4”
解释：有效的 IPv4 地址，返回 “IPv4”

示例 2：

输入：queryIP = “2001:0db8:85a3:0:0:8A2E:0370:7334”
输出：“IPv6”
解释：有效的 IPv6 地址，返回 “IPv6”

示例 3：

输入：queryIP = “256.256.256.256”
输出：“Neither”
解释：既不是 IPv4 地址，又不是 IPv6 地址

提示：

queryIP 仅由英文字母，数字，字符 ‘.’ 和 ‘:’ 组成。

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

思路

一直被用例卡，改了好多次才过

class Solution 
    public String validIPAddress(String queryIP) 
        //模拟
        if(queryIP.length() == 0)
            return "Neither";
        //分割的时候，如果符号在最后一个字符不会多分割一份，所以这里提前判断一下
        if(queryIP.charAt(queryIP.length() - 1) == ':' || queryIP.charAt(queryIP.length() - 1) == '.')
            return "Neither";
        String[] ss = queryIP.split("\\\\.");

        if(ss.length == 4)
            return isFour(ss) ? "IPv4" : "Neither";
        
        ss = queryIP.split(":");
        System.out.println(ss.length);
        if(ss.length == 8)
            return isEight(ss) ? "IPv6" : "Neither"; 
        
        return "Neither";
    

    public boolean isFour(String[] ss)
        for(String s : ss)
            if(s.length() == 0 || s.length() > 3)
                return false;
            if(s.charAt(0) == '0' && s.length() > 1)
                return false;
            int num = 0;
            for(int i = 0; i < s.length(); i++)
                char c = s.charAt(i);
                if(!Character.isDigit(c))
                    return false;
                num = num * 10 + c - '0';
            
            if(num > 255)
                return false;
        
        return true;
    

    public boolean isEight(String[] ss)
        for(String s : ss)
            if(s.length() > 4 || s.length() == 0)
                return false;
            for(char c : s.toCharArray())
                if(Character.isUpperCase(c) && c > 'F')
                    return false;
                if(Character.isLowerCase(c) && c > 'f')
                    return false;
            
        
        return true;