新增3题，累积48题

Author: mercuriussss

src/com/cjl/leetcode/Question_16.java

@@ -0,0 +1,52 @@
+package com.cjl.leetcode;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+    16. 最接近的三数之和
+    问题描述：
+        给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。
+        返回这三个数的和。
+        假定每组输入只存在恰好一个解。
+    示例 1：
+        输入：nums = [-1,2,1,-4], target = 1
+        输出：2
+        解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
+    示例 2：
+        输入：nums = [0,0,0], target = 1
+        输出：0
+    提示：
+        3 <= nums.length <= 1000
+        -1000 <= nums[i] <= 1000
+        -10^4 <= target <= 10^4
+
+ */
+public class Question_16 {
+
+    // 时间复杂度是O(N^2)，空间复杂度是O(1)
+    public int solution1(int[] nums, int target) {
+        int res = Integer.MAX_VALUE;
+        int len = nums.length;
+        Arrays.sort(nums);
+        for (int i = 0; i < len; i++) {
+            int left = i + 1;
+            int right = len - 1;
+            while(left < right) {
+                int sum = nums[i] + nums[left++] + nums[right--];
+                if (Math.abs(target - sum) < Math.abs(target - res)) {
+                    res = sum;
+                }
+                if (sum < target) {
+                    left++;
+                }else if (sum > target) {
+                    right--;
+                } else {
+                    return res;
+                }
+            }
+        }
+        return res;
+    }
+}

src/com/cjl/leetcode/Question_322.java

@@ -0,0 +1,49 @@
+package com.cjl.leetcode;
+
+
+import java.util.Arrays;
+
+/*
+    322. 零钱兑换
+    问题描述：
+        给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
+        计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
+        你可以认为每种硬币的数量是无限的。
+    示例 1：
+        输入：coins = [1, 2, 5], amount = 11
+        输出：3
+        解释：11 = 5 + 5 + 1
+    示例 2：
+        输入：coins = [2], amount = 3
+        输出：-1
+    示例 3：
+        输入：coins = [1], amount = 0
+        输出：0
+    提示：
+        1 <= coins.length <= 12
+        1 <= coins[i] <= 2^31 - 1
+        0 <= amount <= 10^4
+
+ */
+public class Question_322 {
+
+    // 动态数组
+    // 时间复杂度是O(N)，空间复杂度是O(N)
+    public int solution1(int[] coins, int amount) {
+        // 该数组下标代表金额，值则代表凑成该金额的最少硬币数量
+        int[] dp = new int[amount + 1];
+        dp[0] = 0;
+        Arrays.fill(dp, 1, amount + 1,Integer.MAX_VALUE);
+        for (int coin : coins) {
+            // 对于每个硬币面额 coin，从 coin 到 amount 的范围内，更新dp数组
+            for (int i = coin; i <= amount; i++) {
+                // 若dp[i-coin]不等于初始值，则表示可以使用该硬币
+                if (dp[i - coin] != Integer.MAX_VALUE) {
+                    // 这里的 dp[i-coin]+1 代表 i-coin 面额的硬币最少数量，再加上一个 coin 硬币面额的硬币
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
+    }
+}

src/com/cjl/leetcode/Question_468.java

@@ -0,0 +1,101 @@
+package com.cjl.leetcode;
+
+import java.util.*;
+
+/*
+    468. 验证IP地址
+    问题描述：
+        给定一个字符串 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” 、 “[email protected]” 为无效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 仅由英文字母，数字，字符 '.' 和 ':' 组成。
+ */
+public class Question_468 {
+
+    // 遍历对比解法
+    // 时间复杂度是O(N)，空间复杂度是O(1)
+    public String solution1(String queryIP){
+        if (queryIP.contains(".") && isIPv4(queryIP)) return "IPv4";
+        if (queryIP.contains(":") && isIPv6(queryIP)) return "IPv6";
+        return "Neither";
+    }
+
+    // 正则解法
+    public String solution2(String queryIP) {
+        String result = "Neither";
+        if (queryIP == null) {
+            return result;
+        }
+        String regex0 = "(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)";
+        String regexIPv4 = regex0 + "(\\." + regex0 + "){3}";
+        String regex1 = "([\\da-fA-F]{1,4})";
+        String regexIPv6 = regex1 + "(:" + regex1 + "){7}";
+
+        if (queryIP.matches(regexIPv4)) {
+            result = "IPv4";
+        } else if(queryIP.matches(regexIPv6)) {
+            result = "IPv6";
+        }
+        return result;
+    }
+
+    public boolean isIPv4(String s) {
+        String[] strs = s.split("\\.",-1);
+        if (strs.length != 4) {
+            return false;
+        }
+        for (int i = 0; i < 4; i++) {
+            if (strs[i].length() == 0 || (strs[i].length() > 1 && strs[i].charAt(0) == '0')) {
+                return false;
+            }
+            try {
+                int tmpNum = Integer.parseInt(strs[i]);
+                if (tmpNum > 255) {
+                    return false;
+                }
+            } catch (Exception e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isIPv6(String s) {
+        String[] strs = s.split(":",-1);
+        if (strs.length != 8) {
+            return false;
+        }
+        for (int i = 0; i < 8; i++) {
+            if (strs[i].length() == 0 || strs[i].length() > 4) {
+                return false;
+            }
+            for (int j = 0; j < strs[i].length(); j++) {
+                if (!(strs[i].charAt(j) >= '0' && strs[i].charAt(j) < '9') &&
+                        !(strs[i].charAt(j) >= 'a' && strs[i].charAt(j) <= 'f') &&
+                        !(strs[i].charAt(j) >= 'A' && strs[i].charAt(j) <= 'F')) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}