delNodes(TreeNode root, int[] to_delete) {
+// 将要删除的节点放入set
+ for (int i : to_delete) {
+ deleteSet.add(i);
+ }
+// 判断根节点是否要删除,如果不删除,就加入答案
+ boolean delete = deleteSet.contains(root.val);
+ if (!delete){
+ ans.add(root);
+ }
+// 递归遍历
+ bfs(root,delete);
+ return ans;
+ }
+
+ private void bfs(TreeNode root, boolean delete) {
+ if (root==null) return;
+// 判断左右子节点是否要删除,如果要删除,就递归删除,如果不删除,判断是否加入答案。
+// 是否加入答案的依据是,如果父节点要删除,那么子节点就是新的根节点,加入答案,否则不加入答案
+ if (root.left!=null){
+ if (deleteSet.contains(root.left.val)){
+ bfs(root.left, true);
+ root.left=null;
+ }else {
+ if (delete) ans.add(root.left);
+ bfs(root.left, false);
+ }
+ }
+ if(root.right != null ){
+ if (deleteSet.contains(root.right.val)){
+ bfs(root.right, true);
+ root.right=null;
+ }else {
+ if (delete) ans.add(root.right);
+ bfs(root.right, false);
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ val to_delete = new int[]{3,5};
+ Construct construct = new Construct();
+ TreeNode treeNode = construct.deserialize("1,2,3,4,5,6,7");
+ List
ansNow = new DelNodes().delNodes(treeNode, to_delete);
+ for (TreeNode node : ansNow) {
+ String serialize = construct.serialize(node);
+ System.out.printf("serialize = " + serialize + "\n");
+ }
+ System.out.printf("end");
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/DiStringMatch.java b/comxjtu/src/main/java/com/leetcode/everyday/DiStringMatch.java
new file mode 100644
index 0000000..6d3cba1
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/DiStringMatch.java
@@ -0,0 +1,19 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月9日 17:09
+ * @description //TODO
+ */
+public class DiStringMatch {
+
+ public int[] diStringMatch(String s) {
+ int[] reslut = new int[s.length()+1];
+ int max = s.length(), min = 0;
+ for (int i = 0; i < s.length(); i++) + reslut[i] = s.charAt(i)=='I'?reslut[i]=min++:max--; + reslut[s.length()] = s.charAt(s.length()-1)=='I'? min : max; + return reslut; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FallingSquares.java b/comxjtu/src/main/java/com/leetcode/everyday/FallingSquares.java new file mode 100644 index 0000000..c355215 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/FallingSquares.java @@ -0,0 +1,48 @@ +package com.leetcode.everyday; + +import java.util.LinkedList; +import java.util.List; + +/** + * @author JS + * @version 1.0 + * @date 2022/5/26 19:55 + * @description //699. 掉落的方块 + */ +public class FallingSquares { +// 内存超过限制而且,以下这种方法对这个案例是错的: +//输入: +//[[2,1],[2,9],[1,8]] +//输出: +//[1,9,17] +//预期结果: +//[1,10,18] + int MAX_COUNT = 100000001; + public List
fallingSquares(int[][] positions) {
+ int[] lowArray = new int[MAX_COUNT];
+ int[] highArray = new int[MAX_COUNT];
+ List ans = new LinkedList();
+ int max=0;
+ for (int i = 0; i < positions.length; i++) { + int left = positions[i][0]; + int side = positions[i][1]; + int right = left + side; + int base = lowArray[left]; + for (int j = left; j < right+1; j++) { + base = Math.max(base, lowArray[j]); + } + for (int j = left+1; j < right; j++) { + highArray[j]=base+side; + lowArray[j]=base+side; + } + lowArray[left]=Math.min(base+side, highArray[left]); + highArray[left] = Math.max(base+side, highArray[left]); + lowArray[right]=Math.min(base+side, highArray[right]); + highArray[right]=Math.max(base+side, highArray[right]); + max=Math.max(max, base+side); + ans.add(max); + } + return ans; + } + +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FindBottomLeftValue.java b/comxjtu/src/main/java/com/leetcode/everyday/FindBottomLeftValue.java new file mode 100644 index 0000000..057347c --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/FindBottomLeftValue.java @@ -0,0 +1,51 @@ +package com.leetcode.everyday; + +import com.leetcode.util.Construct; +import com.leetcode.util.TreeNode; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @author JS + * @version 1.0 + * @date 2022/6/22 15:42 + * @description //513. 找树左下角的值 + */ +public class FindBottomLeftValue { + public int findBottomLeftValue(TreeNode root) { + int ans = root.val; + + Queue queue = new LinkedList
();
+ queue.offer(root);
+ while (!queue.isEmpty()){
+ int length = queue.size();
+ int left_count= 0;
+ for (int i = 0; i < length; i++) { + TreeNode treeNode = queue.poll(); + if(treeNode.left!=null) { + if (left_count==0){ + ans = treeNode.left.val; + left_count++; + } + queue.offer(treeNode.left); + } + if (treeNode.right!=null){ + if (left_count==0){ + ans = treeNode.right.val; + left_count++; + } + queue.offer(treeNode.right); + } + } + } + + return ans; + } + + public static void main(String[] args) { + TreeNode root = Construct.deserialize("1,2,3,4,#,5,6,#,#,7"); + int ans = new FindBottomLeftValue().findBottomLeftValue(root); + System.out.println(ans); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FindDiagonalOrder.java b/comxjtu/src/main/java/com/leetcode/everyday/FindDiagonalOrder.java new file mode 100644 index 0000000..c99b805 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/FindDiagonalOrder.java @@ -0,0 +1,51 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2022/6/14 15:04 + * @description //498. 对角线遍历 + */ +public class FindDiagonalOrder { + + /** + * + * @Param + * @Description 分三步:起点到左下至右上、右上至左下,确定什么时候变方向。 + * @Date 15:05 2022/6/14 + * @return + **/ + public int[] findDiagonalOrder(int[][] mat) { + int m = mat.length, n=mat[0].length; + int[] ans = new int[m*n]; + ans[0] = mat[0][0]; + int index= 0, i= 0, j=0; + + while (i=0 && j=0 ){
+ ans[index++] = mat[i++][j--];
+ }
+ if (i+1 == m-1 && j-1 == n-1)break;
+ if (i==m){
+ i=i-1;
+ j=j+2;
+ }else {
+ j=j+1;
+ }
+ }
+ return ans;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FindLUSlength.java b/comxjtu/src/main/java/com/leetcode/everyday/FindLUSlength.java
new file mode 100644
index 0000000..ddc622b
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/FindLUSlength.java
@@ -0,0 +1,12 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年6月27日 10:38
+ * @description //522. 最长特殊序列 II
+ */
+public class FindLUSlength {
+
+
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FindMaxK.java b/comxjtu/src/main/java/com/leetcode/everyday/FindMaxK.java
new file mode 100644
index 0000000..5593e02
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/FindMaxK.java
@@ -0,0 +1,28 @@
+package com.leetcode.everyday;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月13日 21:46
+ * @description //2441. 与对应负数同时存在的最大正整数
+ */
+public class FindMaxK {
+// 给你一个 不包含 任何零的整数数组 nums ,找出自身与对应的负数都在数组中存在的最大正整数 k 。返回正整数 k ,如果不存在这样的整数,返回 -1 。
+ public int findMaxK(int[] nums) {
+ int k = -1;
+ Set set = new HashSet();
+ for (int x : nums) {
+ set.add(x);
+ }
+ for (int x : nums) {
+ if (set.contains(-x)) {
+ k = Math.max(k, x);
+ }
+ }
+ return k;
+ }
+
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FindRightInterval.java b/comxjtu/src/main/java/com/leetcode/everyday/FindRightInterval.java
new file mode 100644
index 0000000..7eb33eb
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/FindRightInterval.java
@@ -0,0 +1,62 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static java.util.Arrays.binarySearch;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月20日 10:31
+ * @description //436. 寻找右区间
+ */
+public class FindRightInterval {
+
+ public int[] findRightInterval(int[][] intervals) {
+ if (intervals.length<2) return new int[]{-1}; + int[] ans = new int[intervals.length]; + int[] indexArray = new int[intervals.length]; + Arrays.fill(ans, -1); + Arrays.sort(indexArray); + Map indexMap = new TreeMap();
+ for (int i = 0; i < intervals.length; i++) { + indexMap.put(intervals[i][0], i); + indexArray[i] = intervals[i][0]; + } + Arrays.sort(indexArray); + for (int i = 0; i < intervals.length; i++) { + int index = rank(indexArray, intervals[i][1]); + if (indext) hi = mid - 1;
+ else if (a[mid]用队列,直接将出局的弹出即可;
+ * 另一种:约瑟夫环问题,关键在于找到递归表达式,递推公式: f(n)= (f(n - 1) + k - s) % n + 1 (s 代表起点编号)
+ * @Date 9:44 2022年5月4日
+ * @return
+ **/
+ public int findTheWinner(int n, int k) {
+ if (n<2) return n; + int count = n, start = 1, itrK = 1; + boolean[] flags = new boolean[n+1]; + while (count!=1){ + + if (flags[start]){ + //已被淘汰 + }else { + if (itrK==k){ + flags[start]=true; + count--; + itrK=1; + } + else itrK++; + } + if (start==n) start=1; + else start++; + } + for (int i = 1; i < n+1; i++) { + if (!flags[i]) return i; + } + return n; + } + + public int findTheWinner2(int n, int k) { + if (n == 1) { + return 1; + } + return (k + findTheWinner2(n - 1, k) - 1) % n + 1; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/FrogPosition.java b/comxjtu/src/main/java/com/leetcode/everyday/FrogPosition.java new file mode 100644 index 0000000..2b3ea15 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/FrogPosition.java @@ -0,0 +1,56 @@ +package com.leetcode.everyday; + +import lombok.experimental.var; + +import java.util.*; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/24 9:48 + * @description //1377. T 秒后青蛙的位置 + */ +public class FrogPosition { + + public double frogPosition(int n, int[][] edges, int t, int target) { + Map> graph = new HashMap();
+ for (int[] edge : edges) {
+ graph.computeIfAbsent(edge[0], key -> new ArrayList()).add(edge[1]);
+ graph.computeIfAbsent(edge[1], key -> new ArrayList()).add(edge[0]);
+ }
+ Queue queue = new LinkedList();
+ queue.offer(1);
+ double[] prob = new double[n + 1];
+ prob[1] = 1.0;
+ while (!queue.isEmpty() && t--> 0) {
+ for (int sz = queue.size(); sz> 0; --sz) {
+ int cur = queue.poll();
+ int nextCount = 0;
+ for (int next : graph.getOrDefault(cur, new ArrayList())) {
+ if (prob[next] == 0) {
+ ++nextCount;
+ }
+ }
+ for (int next : graph.getOrDefault(cur, new ArrayList())) {
+ if (prob[next] == 0) {
+ queue.offer(next);
+ prob[next] = prob[cur] / nextCount;
+ }
+ }
+ if (nextCount> 0) {
+ prob[cur] = 0;
+ }
+ }
+ }
+ return prob[target];
+ }
+
+ public static void main(String[] args) {
+ FrogPosition solver = new FrogPosition();
+ int n = 7;
+ int[][] edges = {{1,2},{1,3},{1,7},{2,4},{2,6},{3,5}};
+ int t = 2;
+ int target = 4;
+ System.out.println(solver.frogPosition(n,edges,t,target));
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/GetAllElements.java b/comxjtu/src/main/java/com/leetcode/everyday/GetAllElements.java
new file mode 100644
index 0000000..3358907
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/GetAllElements.java
@@ -0,0 +1,88 @@
+package com.leetcode.everyday;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月1日 10:13
+ * @description //lc1305 给你 root1 和 root2 这两棵二叉搜索树。请你返回一个列表,其中包含 两棵树 中的所有整数并按 升序 排序。.
+ */
+public class GetAllElements {
+
+ /**
+ *
+ * @Description 中序遍历+归并排序
+ * @Date 10:16 2022年5月1日
+ * @return
+ **/
+ public List getAllElements(TreeNode root1, TreeNode root2) {
+ List result = new LinkedList();
+ List result1 = midOrder(root1);
+ List result2 = midOrder(root2);
+ if (result1.size()==0){
+ return result2;
+ }else if (result2.size()==0){
+ return result1;
+ }
+ result = merge(result1, result2);
+ return result;
+ }
+
+ private List merge(List result1, List result2) {
+ List result = new LinkedList();
+ int i = 0, j=0;
+ while (i midOrder(TreeNode root) {
+ List result = new ArrayList();
+ inOrder(root, result);
+ return result;
+ }
+
+ private void inOrder(TreeNode root, List result) {
+ if (root == null) return;
+ inOrder(root.left, result);
+ result.add(root.val);
+ inOrder(root.right, result);
+ }
+
+
+ //Definition for a binary tree node.
+ public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+ TreeNode() {}
+ TreeNode(int val) { this.val = val; }
+ TreeNode(int val, TreeNode left, TreeNode right) {
+ this.val = val;
+ this.left = left;
+ this.right = right;
+ }
+ }
+}
+
+
+
+
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/InorderSuccessor.java b/comxjtu/src/main/java/com/leetcode/everyday/InorderSuccessor.java
new file mode 100644
index 0000000..7387d2f
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/InorderSuccessor.java
@@ -0,0 +1,33 @@
+package com.leetcode.everyday;
+
+import com.leetcode.util.TreeNode;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月16日 9:07
+ * @description //面试题 04.06. 后继者
+ */
+public class InorderSuccessor {
+
+ public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
+ if (root == null) return null;
+
+ return inorder(root, p);
+ }
+
+ private TreeNode inorder(TreeNode root, TreeNode p) {
+ if (root == null) return null;
+
+ TreeNode post = inorder(root.right, p);
+ if (root == p) return post;
+ else {
+ TreeNode pre = inorder(root.left, p);
+ post = inorder(root.right, p);
+ }
+
+ return post;
+ }
+}
+
+
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/KSmallestPairs.java b/comxjtu/src/main/java/com/leetcode/everyday/KSmallestPairs.java
new file mode 100644
index 0000000..cd69889
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/KSmallestPairs.java
@@ -0,0 +1,10 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月28日 11:02
+ * @description //373. 查找和最小的 K 对数字
+ */
+public class KSmallestPairs {
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/LargestTriangleArea.java b/comxjtu/src/main/java/com/leetcode/everyday/LargestTriangleArea.java
new file mode 100644
index 0000000..9d2ccf3
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/LargestTriangleArea.java
@@ -0,0 +1,29 @@
+package com.leetcode.everyday;
+
+import java.lang.ref.PhantomReference;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月15日 9:55
+ * @description //lc812
+ */
+public class LargestTriangleArea {
+
+ public double largestTriangleArea(int[][] points) {
+ int n = points.length;
+ double ret = 0.0;
+ for (int i = 0; i < n; i++) { + for (int j = i + 1; j < n; j++) { + for (int k = j + 1; k < n; k++) { + ret = Math.max(ret, triangleArea(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1])); + } + } + } + return ret; + } + + public double triangleArea(int x1, int y1, int x2, int y2, int x3, int y3) { + return 0.5 * Math.abs(x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/LargestValsFromLabels.java b/comxjtu/src/main/java/com/leetcode/everyday/LargestValsFromLabels.java new file mode 100644 index 0000000..3057826 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/LargestValsFromLabels.java @@ -0,0 +1,38 @@ +package com.leetcode.everyday; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedHashMap; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/23 10:13 + * @description //1090. 受标签影响的最大值 + */ +public class LargestValsFromLabels { + public int largestValsFromLabels(int[] values, int[] labels, int numWanted, int useLimit) { + Integer[] id = new Integer[values.length]; + for (int i = 0; i < values.length; i++) { + id[i] = i; + } + Arrays.sort(id, (a, b) -> values[b] - values[a]);
+
+ HashMap hashMap = new LinkedHashMap();
+ for (int label : labels) {
+ hashMap.put(label, 0);
+ }
+ int ans = 0, numCount = 0;
+ for (int j = 0; j < id.length && numCount> levelOrder (TreeNode root) {
+ // 二叉树层序遍历
+ ArrayList> res = new ArrayList();
+ if (root == null) {
+ return res;
+ }
+ ArrayList queue = new ArrayList
();
+ queue.add(root);
+ while (!queue.isEmpty()) {
+ ArrayList list = new ArrayList();
+ ArrayList temp = new ArrayList
();
+ for (TreeNode node : queue) {
+ list.add(node.val);
+ if (node.left != null) {
+ temp.add(node.left);
+ }
+ if (node.right != null) {
+ temp.add(node.right);
+ }
+
+ }
+ res.add(list);
+ queue = temp;
+ }
+ return res;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/LongestDecomposition.java b/comxjtu/src/main/java/com/leetcode/everyday/LongestDecomposition.java
new file mode 100644
index 0000000..e9a2e82
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/LongestDecomposition.java
@@ -0,0 +1,59 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月12日 9:25
+ * @description //1147. 段式回文
+ */
+public class LongestDecomposition {
+
+ public int longestDecomposition(String text) {
+ int ans = 0;
+ int left = 0, right = text.length()-1;
+ for (;left <= right;){ + for (int size = 1;; size++) { + if (size*2>right-left+1){
+ ans++;
+ left = right+1;
+ break;
+ }
+ if (text.substring(left, left+size).equals(text.substring(right-size+1,right+1))){
+ ans++;
+ left += size;
+ right -= size;
+ if (left-1 majorityElement(int[] nums) {
+ int element1 = 0;
+ int element2 = 0;
+ int vote1 = 0;
+ int vote2 = 0;
+
+ for (int num : nums) {
+ if (vote1> 0 && num == element1) { //如果该元素为第一个元素,则计数加1
+ vote1++;
+ } else if (vote2> 0 && num == element2) { //如果该元素为第二个元素,则计数加1
+ vote2++;
+ } else if (vote1 == 0) { // 选择第一个元素
+ element1 = num;
+ vote1++;
+ } else if (vote2 == 0) { // 选择第二个元素
+ element2 = num;
+ vote2++;
+ } else { //如果三个元素均不相同,则相互抵消1次
+ vote1--;
+ vote2--;
+ }
+ }
+
+ int cnt1 = 0;
+ int cnt2 = 0;
+ for (int num : nums) {
+ if (vote1> 0 && num == element1) {
+ cnt1++;
+ }
+ if (vote2> 0 && num == element2) {
+ cnt2++;
+ }
+ }
+ // 检测元素出现的次数是否满足要求
+ List ans = new ArrayList();
+ if (vote1> 0 && cnt1> nums.length / 3) {
+ ans.add(element1);
+ }
+ if (vote2> 0 && cnt2> nums.length / 3) {
+ ans.add(element2);
+ }
+
+ return ans;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/Makesquare.java b/comxjtu/src/main/java/com/leetcode/everyday/Makesquare.java
new file mode 100644
index 0000000..3bb44d5
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/Makesquare.java
@@ -0,0 +1,44 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年6月1日 10:26
+ * @description 473. 火柴拼正方形
+ */
+public class Makesquare {
+
+ class Solution {
+ public boolean makesquare(int[] matchsticks) {
+ int totalLen = Arrays.stream(matchsticks).sum();
+ if (totalLen % 4 != 0) {
+ return false;
+ }
+ Arrays.sort(matchsticks);
+ for (int i = 0, j = matchsticks.length - 1; i < j; i++, j--) { + int temp = matchsticks[i]; + matchsticks[i] = matchsticks[j]; + matchsticks[j] = temp; + } + + int[] edges = new int[4]; + return dfs(0, matchsticks, edges, totalLen / 4); + } + + public boolean dfs(int index, int[] matchsticks, int[] edges, int len) { + if (index == matchsticks.length) { + return true; + } + for (int i = 0; i < edges.length; i++) { + edges[i] += matchsticks[index]; + if (edges[i] <= len && dfs(index + 1, matchsticks, edges, len)) { + return true; + } + edges[i] -= matchsticks[index]; + } + return false; + } + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaskPII.java b/comxjtu/src/main/java/com/leetcode/everyday/MaskPII.java new file mode 100644 index 0000000..9821801 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MaskPII.java @@ -0,0 +1,79 @@ +package com.leetcode.everyday; + +import java.util.HashSet; +import java.util.Scanner; + +/** + * @author JS + * @version 1.0 + * @date 2023/4/1 16:25 + * @description //831 + */ +public class MaskPII { + + public String maskPII(String s) { +// 1.判断是邮箱还是电话;@ + StringBuilder ans = new StringBuilder(""); + if (s.contains("@")){ + // 2.邮箱:(1)转小写;(2)分割,@;(3)替换,拼接 + s = s.toLowerCase(); + String[] strs = s.split("@"); + int len = strs[0].length(); + ans.append(strs[0].charAt(0)).append("*****").append(strs[0].charAt(len-1)).append("@").append(strs[1]); + }else { + // 3.电话:(1)只留下数字;(2)判断长度;(4)按照对应模式拼接+最后四位 + char[] chars = s.toCharArray(); + HashSet characterHashSet = new HashSet();
+ characterHashSet.add(' ');
+ characterHashSet.add('(');
+ characterHashSet.add(')');
+ characterHashSet.add('-');
+ characterHashSet.add('+');
+ int count = 0;
+ StringBuilder sb = new StringBuilder();
+ for (char aChar : chars) {
+ if (!characterHashSet.contains(aChar) ){
+ count++;
+ sb.append(aChar);
+ }
+ }
+ switch (count){
+ case 10:
+ ans.append("***-***-");
+ break;
+ case 11:
+ ans.append("+*-***-***-");
+ break;
+ case 12:
+ ans.append("+**-***-***-");
+ break;
+ default:
+ ans.append("+***-***-***-");
+ }
+ ans.append(sb.toString().substring(count-4));
+
+ }
+
+ return String.valueOf(ans);
+ }
+
+ public static void main(String[] args) {
+ StringBuilder ans = new StringBuilder("");
+ String s = "LeetCode@LeetCode.com";
+ s = s.toLowerCase();
+ String[] strs = s.split("@");
+ int len = strs[0].length();
+ ans.append(strs[0].charAt(0)).append("*****").append(strs[0].charAt(len-1)).append("@").append(strs[1]);
+ System.out.println(ans);
+
+ MaskPII solver = new MaskPII();
+ Scanner sc = new Scanner(System.in);
+ while (true){
+ String line = sc.nextLine();
+ System.out.println(solver.maskPII(line));
+ }
+
+// String ss = s.substring(s.length()-4);
+// System.out.println(ss);
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxAncestorDiff.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxAncestorDiff.java
new file mode 100644
index 0000000..50983e3
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxAncestorDiff.java
@@ -0,0 +1,27 @@
+package com.leetcode.everyday;
+
+import com.leetcode.base.TreeNode;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月18日 9:24
+ * @description //1026. 节点与其祖先之间的最大差值
+ */
+public class MaxAncestorDiff {
+ public int maxAncestorDiff(TreeNode root) {
+ return dfs(root, root.val, root.val);
+ }
+
+ public int dfs(TreeNode root, int mi, int ma) {
+ if (root == null) {
+ return 0;
+ }
+ int diff = Math.max(Math.abs(root.val - mi), Math.abs(root.val - ma));
+ mi = Math.min(mi, root.val);
+ ma = Math.max(ma, root.val);
+ diff = Math.max(diff, dfs(root.left, mi, ma));
+ diff = Math.max(diff, dfs(root.right, mi, ma));
+ return diff;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxEqulaK.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxEqulaK.java
new file mode 100644
index 0000000..58e8ef3
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxEqulaK.java
@@ -0,0 +1,37 @@
+package com.leetcode.everyday;
+
+import com.leetcode.base.TreeNode;
+
+import java.util.ArrayList;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月24日 12:21
+ * @description //
+ */
+public class MaxEqulaK {
+
+// 使用哈希表+前缀和
+ public int maxlenEqualK (int[] arr, int k) {
+ // write code here
+ int n = arr.length;
+ int[] preSum = new int[n + 1];
+ for (int i = 1; i <= n; i++) { + preSum[i] = preSum[i-1] + arr[i-1]; + } + int res = 0; + ArrayList list = new ArrayList();
+ for (int i = 0; i <= n; i++) { + if (list.contains(preSum[i] - k)) { + res = Math.max(res, i - list.indexOf(preSum[i] - k)); + } + if (!list.contains(preSum[i])) { + list.add(preSum[i]); + } + } + return res; + } + + +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxSubArray.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxSubArray.java new file mode 100644 index 0000000..01c5845 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxSubArray.java @@ -0,0 +1,49 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2023/4/8 20:17 + * @description //53. 最大子数组和 + */ +public class MaxSubArray { + private int maxCrossingSum(int[] nums, int left, int mid, int right) { + // 一定会包含 nums[mid] 这个元素 + int sum = 0; + int leftSum = Integer.MIN_VALUE; + // 左半边包含 nums[mid] 元素,最多可以到什么地方 + // 走到最边界,看看最值是什么 + // 计算以 mid 结尾的最大的子数组的和 + for (int i = mid; i>= left; i--) {
+ sum += nums[i];
+ if (sum> leftSum) {
+ leftSum = sum;
+ }
+ }
+ sum = 0;
+ int rightSum = Integer.MIN_VALUE;
+ // 右半边不包含 nums[mid] 元素,最多可以到什么地方
+ // 计算以 mid+1 开始的最大的子数组的和
+ for (int i = mid + 1; i <= right; i++) { + sum += nums[i]; + if (sum> rightSum) {
+ rightSum = sum;
+ }
+ }
+ return leftSum + rightSum;
+ }
+
+ private int maxSubArraySum(int[] nums, int left, int right) {
+ if (left == right) {
+ return nums[left];
+ }
+ int mid = left + (right - left) / 2;
+ return max3(maxSubArraySum(nums, left, mid),
+ maxSubArraySum(nums, mid + 1, right),
+ maxCrossingSum(nums, left, mid, right));
+ }
+
+ private int max3(int num1, int num2, int num3) {
+ return Math.max(num1, Math.max(num2, num3));
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxSubarraySumCircular.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxSubarraySumCircular.java
new file mode 100644
index 0000000..6a45753
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxSubarraySumCircular.java
@@ -0,0 +1,22 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年7月20日 11:15
+ * @description //918. 环形子数组的最大和
+ */
+public class MaxSubarraySumCircular {
+
+ public int maxSubarraySumCircular(int[] A) {
+ int total = 0, maxSum = A[0], curMax = 0, minSum = A[0], curMin = 0;
+ for (int a : A) {
+ curMax = Math.max(curMax + a, a);
+ maxSum = Math.max(maxSum, curMax);
+ curMin = Math.min(curMin + a, a);
+ minSum = Math.min(minSum, curMin);
+ total += a;
+ }
+ return maxSum> 0 ? Math.max(maxSum, total - minSum) : maxSum;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxSumAfterPartitioning.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxSumAfterPartitioning.java
new file mode 100644
index 0000000..87c8f48
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxSumAfterPartitioning.java
@@ -0,0 +1,40 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月19日 15:46
+ * @description //1043. 分隔数组以得到最大和
+ */
+public class MaxSumAfterPartitioning {
+
+ public int maxSumAfterPartitioning(int[] arr, int k) {
+ int n = arr.length;
+ int[] d = new int[n + 1];
+ for (int i = 1; i <= n; i++) { + int maxValue = arr[i - 1]; + for (int j = i - 1; j>= 0 && j>= i - k; j--) {
+ d[i] = Math.max(d[i], d[j] + maxValue * (i - j));
+ if (j> 0) {
+ maxValue = Math.max(maxValue, arr[j - 1]);
+ }
+ }
+ }
+ return d[n];
+ }
+
+ public static void main(String[] args) {
+ int ans =0;
+ MaxSumAfterPartitioning solver = new MaxSumAfterPartitioning();
+ ans = solver.maxSumAfterPartitioning(new int[]{1,15,7,9,2,5,10}, 3);
+ System.out.println(ans);
+ ans = solver.maxSumAfterPartitioning(new int[]{1,4,1,5,7,3,6,1,9,9,3}, 4);
+ System.out.println(ans);
+ ans = solver.maxSumAfterPartitioning(new int[]{1}, 1);
+ System.out.println(ans);
+ ans = solver.maxSumAfterPartitioning(new int[]{1,2}, 3);
+ System.out.println(ans);
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxSumDivThree.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxSumDivThree.java
new file mode 100644
index 0000000..350a88e
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxSumDivThree.java
@@ -0,0 +1,23 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年6月19日 11:45
+ * @description //1262. 可被三整除的最大和
+ */
+public class MaxSumDivThree {
+
+ public int maxSumDivThree(int[] nums) {
+ int[] f = {0, Integer.MIN_VALUE, Integer.MIN_VALUE};
+ for (int num : nums) {
+ int[] g = new int[3];
+ System.arraycopy(f, 0, g, 0, 3);
+ for (int i = 0; i < 3; ++i) { + g[(i + num % 3) % 3] = Math.max(g[(i + num % 3) % 3], f[i] + num); + } + f = g; + } + return f[0]; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MaxValueAfterReverse.java b/comxjtu/src/main/java/com/leetcode/everyday/MaxValueAfterReverse.java new file mode 100644 index 0000000..6805720 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MaxValueAfterReverse.java @@ -0,0 +1,28 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/12 16:02 + * @description //1330. 翻转子数组得到最大的数组值 + */ +public class MaxValueAfterReverse { + public int maxValueAfterReverse(int[] nums) { + int value = 0, n = nums.length; + for (int i = 0; i < n - 1; i++) { + value += Math.abs(nums[i] - nums[i + 1]); + } + int mx1 = 0; + for (int i = 1; i < n - 1; i++) { + mx1 = Math.max(mx1, Math.abs(nums[0] - nums[i + 1]) - Math.abs(nums[i] - nums[i + 1])); + mx1 = Math.max(mx1, Math.abs(nums[n - 1] - nums[i - 1]) - Math.abs(nums[i] - nums[i - 1])); + } + int mx2 = Integer.MIN_VALUE, mn2 = Integer.MAX_VALUE; + for (int i = 0; i < n - 1; i++) { + int x = nums[i], y = nums[i + 1]; + mx2 = Math.max(mx2, Math.min(x, y)); + mn2 = Math.min(mn2, Math.max(x, y)); + } + return value + Math.max(mx1, 2 * (mx2 - mn2)); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MctFromLeafValues.java b/comxjtu/src/main/java/com/leetcode/everyday/MctFromLeafValues.java new file mode 100644 index 0000000..1c5506a --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MctFromLeafValues.java @@ -0,0 +1,36 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/31 10:40 + * @description //1130. 叶值的最小代价生成树 + * 这个问题竟然是区间dp,区间dp各个区间的有效性是如何保证的? + * 设dp[i][j]表示从i到j这段区间中所有非叶节点的最小可能总和。然后对于每个区间[i,j],我们可以枚举最后一步的操作, + * 即把区间[i,j]分成两个子区间[l,k]和[k+1,r],使得[l,k]和[k+1,r]分别是其中一个非叶节点的左子树和右子树。 + * 那么非叶节点的值就是max{arr[p]}, l <= p <= k和l <= p <= r-k。 + * 我们可以用一个变量maxNum记录[p,k]和[k+1,r]中的最大值,然后再把左右子树的dp值相乘,加上这个maxNum,就可以得到区间[i,j]中所有非叶节点的最小值。 + * 由于我们需要对所有的区间[i,j]进行计算,所以可以使用二维数组dp来保存每个区间的结果,最后返回dp[0][n-1]即可。 + */ +public class MctFromLeafValues { + + public int mctFromLeafValues(int[] arr) { + int n = arr.length; + int[][] dp = new int[n][n]; + for (int len = 2; len <= n; len++) { + for (int i = 0; i + len - 1 < n; i++) { + int j = i + len - 1; + dp[i][j] = Integer.MAX_VALUE; + for (int k = i; k < j; k++) { + int maxNumL = Arrays.stream(arr, i, k+1).max().orElse(0); + int maxNumR = Arrays.stream(arr, k+1, j+1).max().orElse(0); + int nonLeafVal = maxNumL * maxNumR; + dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k+1][j] + nonLeafVal); + } + } + } + return dp[0][n-1]; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MedianFinder.java b/comxjtu/src/main/java/com/leetcode/everyday/MedianFinder.java new file mode 100644 index 0000000..303f3c9 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MedianFinder.java @@ -0,0 +1,31 @@ +package com.leetcode.everyday; + +import java.util.PriorityQueue; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/19 21:16 + * @Description //剑指 Offer 41. 数据流中的中位数 + * 如何得到一个数据流中的中位数?如果从数据流中读出奇数个数值,那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值,那么中位数就是所有数值排序之后中间两个数的平均值。 + * + */ +public class MedianFinder { + /** initialize your data structure here. */ + PriorityQueue left;//大顶
+ PriorityQueue right;//小顶
+ public MedianFinder() {
+ left=new PriorityQueue((n1,n2)->n2-n1);
+ right=new PriorityQueue();
+ }
+ public void addNum(int num) {
+ left.add(num);
+ right.add(left.poll());
+ if(left.size()+1left.size())return right.peek();
+ return (double)(left.peek()+right.peek())/2;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MedianSlidingWindow.java b/comxjtu/src/main/java/com/leetcode/everyday/MedianSlidingWindow.java
new file mode 100644
index 0000000..c667047
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MedianSlidingWindow.java
@@ -0,0 +1,63 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月19日 21:30
+ * @description //力扣 480. 滑动窗口中位数
+ */
+public class MedianSlidingWindow {
+
+// 中位数是有序序列最中间的那个数。如果序列的长度是偶数,则没有最中间的数;此时中位数是最中间的两个数的平均数。
+ public double[] medianSlidingWindow(int[] nums, int k) {
+ PriorityQueue maxHeap = new PriorityQueue(Collections.reverseOrder()); // 大根堆
+ PriorityQueue minHeap = new PriorityQueue(); // 小根堆
+ double[] medians = new double[nums.length - k + 1];
+ for (int i = 0; i < nums.length; i++) { + // Step 1: 维护两个堆的大小,并将元素分别插入 + if (i>= k) {
+ // 判断堆顶元素是否失效
+ if (maxHeap.contains(nums[i - k])) {
+ maxHeap.remove(nums[i - k]);
+ } else {
+ minHeap.remove(nums[i - k]);
+ }
+ }
+ if (maxHeap.size() <= minHeap.size()) { + maxHeap.offer(nums[i]); + } else { + minHeap.offer(nums[i]); + } + // Step 2: 平衡两个堆 + if (!minHeap.isEmpty() && maxHeap.peek()> minHeap.peek()) {
+ int maxHeapTop = maxHeap.poll();
+ int minHeapTop = minHeap.poll();
+ maxHeap.offer(minHeapTop);
+ minHeap.offer(maxHeapTop);
+ }
+ // Step 3: 找中位数
+ if (i>= k - 1) { // 当窗口的大小大于等于k时,才可以找到中位数
+ double median;
+ if (k % 2 == 0) {
+ median = ((double) maxHeap.peek() + minHeap.peek()) / 2;
+ } else {
+ median = maxHeap.peek();
+ }
+ medians[i - k + 1] = median;
+ }
+ }
+ return medians;
+ }
+
+ public static void main(String[] args) {
+ MedianSlidingWindow s = new MedianSlidingWindow();
+ int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
+ int k = 3;
+ double[] result = s.medianSlidingWindow(nums, k);
+ System.out.println(Arrays.toString(result)); // [1.0, -1.0, -1.0, 3.0, 5.0, 6.0]
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MergeStones.java b/comxjtu/src/main/java/com/leetcode/everyday/MergeStones.java
new file mode 100644
index 0000000..5336005
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MergeStones.java
@@ -0,0 +1,63 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月4日 12:50
+ * @description //1000. 合并石头的最低成本
+ */
+public class MergeStones {
+ static final int INF = 0x3f3f3f3f;
+ int[][][] d;
+ int[] sum;
+ int k;
+
+ public int mergeStones(int[] stones, int k) {
+ int n = stones.length;
+ if ((n - 1) % (k - 1) != 0) {
+ return -1;
+ }
+ this.k = k;
+ d = new int[n][n][k + 1];
+ for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + Arrays.fill(d[i][j], -1); + } + } + sum = new int[n]; + + // 初始化 + for (int i = 0, s = 0; i < n; i++) { + d[i][i][1] = 0; + s += stones[i]; + sum[i] = s; + } + int res = get(0, n - 1, 1); + return res; + } + + public int get(int l, int r, int t) { + // 若 d[l][r][t] 不为 -1,表示已经在之前的递归被求解过,直接返回答案 + if (d[l][r][t] != -1) { + return d[l][r][t]; + } + // 当石头堆数小于 t 时,一定无解 + if (t> r - l + 1) {
+ return INF;
+ }
+ if (t == 1) {
+ int res = get(l, r, k);
+ if (res == INF) {
+ return d[l][r][t] = INF;
+ }
+ return d[l][r][t] = res + (sum[r] - (l == 0 ? 0 : sum[l - 1]));
+ }
+ int val = INF;
+ for (int p = l; p < r; p += (k - 1)) { + val = Math.min(val, get(l, p, 1) + get(p + 1, r, t - 1)); + } + return d[l][r][t] = val; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MinDeletionLength.java b/comxjtu/src/main/java/com/leetcode/everyday/MinDeletionLength.java new file mode 100644 index 0000000..0316a72 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/MinDeletionLength.java @@ -0,0 +1,24 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2022/5/12 9:41 + * @description //lc944 + */ +public class MinDeletionLength { + + public int minDeletionSize(String[] strs) { + if (strs.length==1 ) return 0; + int sum =0; + for (int i = 0; i < strs[0].length(); i++) { + for (int j = 1; j < strs.length; j++) { + if (strs[j].charAt(i) 0) // 如果有青蛙发出了 pre 的声音
+ cnt[pre]--; // 复用一只
+ else if (ch != 'c') // 否则青蛙必须从 'c' 开始蛙鸣
+ return -1; // 不符合要求
+ cnt[ch]++; // 发出了 ch 的声音
+ }
+ if (cnt['c']> 0 || cnt['r']> 0 || cnt['o']> 0 || cnt['a']> 0)
+ return -1; // 有发出其它声音的青蛙,不符合要求
+ return cnt['k']; // 最后青蛙们都发出了 'k' 的声音
+ }
+
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MinStickers.java b/comxjtu/src/main/java/com/leetcode/everyday/MinStickers.java
new file mode 100644
index 0000000..e8cade1
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MinStickers.java
@@ -0,0 +1,85 @@
+package com.leetcode.everyday;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月14日 20:15
+ * @description //691:这个解答实现错了,将重复选用的记为一次了;如果不记为一次,则使用map数组来做、
+ */
+public class MinStickers {
+ public int minStickers(String[] stickers, String target) {
+ Set[] stickerSetArray = new HashSet[stickers.length];
+ for (int i = 0; i < stickers.length; i++) { + stickerSetArray[i] = generateSet(stickers[i]); + } + Set targetSet = generateSet(target);
+ int ans = -1;
+ ans = backtrack(stickerSetArray, targetSet, 0, Integer.MAX_VALUE);
+ return ans==Integer.MAX_VALUE ? -1: ans;
+ }
+
+ private int backtrack(Set[] stickerSetArray, Set targetSet, int start, int min) {
+ if (0 == targetSet.size()){
+ return start;
+ }
+ if (start == stickerSetArray.length) return Integer.MAX_VALUE;
+
+ for (int i = start; i < stickerSetArray.length; i++) { + Set targetSetOri = new HashSet(targetSet);
+ int matchCount = intersection(stickerSetArray[i], targetSet);
+ if (matchCount!=0){
+ int count = backtrack(stickerSetArray, targetSet, i+1, min);
+ min = count characters, Set targetSet) {
+ int count = 0;
+ for (Character ch :
+ characters) {
+ if (targetSet.contains(ch)){
+ targetSet.remove(ch);
+ count++;
+ }
+ }
+ return count;
+ }
+
+ private Set generateSet(String sticker) {
+ Set stickerSet = new HashSet();
+ for (int i = 0; i < sticker.length(); i++) { + stickerSet.add(sticker.charAt(i)); + } + return stickerSet; + } + + public static void main(String[] args) { + MinStickers minStickers = new MinStickers(); + Set stickerSet = minStickers.generateSet("starta");
+ Set targetSetOri = new HashSet(stickerSet);
+ targetSetOri.remove('s');
+ for (Character sticker:
+ stickerSet) {
+ System.out.print(sticker);
+ }
+ System.out.println();
+ for (Character sticker:
+ targetSetOri) {
+ System.out.print(sticker);
+ }
+ System.out.println();
+ int matchCount = minStickers.intersection(stickerSet, targetSetOri);
+ System.out.println(matchCount);
+ for (Character sticker:
+ targetSetOri) {
+ System.out.print(sticker);
+ }
+ System.out.println(minStickers.minStickers(new String[]{"with","example","science"}, "thehat"));
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/MinStickers2.java b/comxjtu/src/main/java/com/leetcode/everyday/MinStickers2.java
new file mode 100644
index 0000000..8e0c06b
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/MinStickers2.java
@@ -0,0 +1,50 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月14日 20:15
+ * @description //691:这个解答实现错了,将重复选用的记为一次了;如果不记为一次,则使用map数组来做、
+ */
+public class MinStickers2 {
+ class Solution {
+ public int minStickers(String[] stickers, String target) {
+ int m = target.length();
+ int[] memo = new int[1 << m]; + Arrays.fill(memo, -1); + memo[0] = 0; + int res = dp(stickers, target, memo, (1 << m) - 1); + return res <= m ? res : -1; + } + + public int dp(String[] stickers, String target, int[] memo, int mask) { + int m = target.length(); + if (memo[mask] < 0) { + int res = m + 1; + for (String sticker : stickers) { + int left = mask; + int[] cnt = new int[26]; + for (int i = 0; i < sticker.length(); i++) { + cnt[sticker.charAt(i) - 'a']++; + } + for (int i = 0; i < target.length(); i++) { + char c = target.charAt(i); + if (((mask>> i) & 1) == 1 && cnt[c - 'a']> 0) {
+ cnt[c - 'a']--;
+ left ^= 1 << i; + } + } + if (left < mask) { + res = Math.min(res, dp(stickers, target, memo, left) + 1); + } + } + memo[mask] = res; + } + return memo[mask]; + } + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/ModifiedGraphEdges.java b/comxjtu/src/main/java/com/leetcode/everyday/ModifiedGraphEdges.java new file mode 100644 index 0000000..259689d --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/ModifiedGraphEdges.java @@ -0,0 +1,103 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2023/6/9 8:17 + * @description //2699. 修改图中的边权 + */ +public class ModifiedGraphEdges { + + public int[][] modifiedGraphEdges(int n, int[][] edges, int source, int destination, int target) { + int k = 0; + for (int[] e : edges) { + if (e[2] == -1) { + ++k; + } + } + + if (dijkstra(source, destination, construct(n, edges, 0, target))> target) {
+ return new int[0][];
+ }
+ if (dijkstra(source, destination, construct(n, edges, (long) k * (target - 1), target)) < target) { + return new int[0][]; + } + + long left = 0, right = (long) k * (target - 1), ans = 0; + while (left <= right) { + long mid = (left + right) / 2; + if (dijkstra(source, destination, construct(n, edges, mid, target))>= target) {
+ ans = mid;
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+
+ for (int[] e : edges) {
+ if (e[2] == -1) {
+ if (ans>= target - 1) {
+ e[2] = target;
+ ans -= target - 1;
+ } else {
+ e[2] = (int) (1 + ans);
+ ans = 0;
+ }
+ }
+ }
+
+ return edges;
+ }
+
+ public long dijkstra(int source, int destination, int[][] adjMatrix) {
+ // 朴素的 dijkstra 算法
+ // adjMatrix 是一个邻接矩阵
+ int n = adjMatrix.length;
+ long[] dist = new long[n];
+ Arrays.fill(dist, Integer.MAX_VALUE / 2);
+ boolean[] used = new boolean[n];
+ dist[source] = 0;
+
+ for (int round = 0; round < n - 1; ++round) { + int u = -1; + for (int i = 0; i < n; ++i) { + if (!used[i] && (u == -1 || dist[i] < dist[u])) { + u = i; + } + } + used[u] = true; + for (int v = 0; v < n; ++v) { + if (!used[v] && adjMatrix[u][v] != -1) { + dist[v] = Math.min(dist[v], dist[u] + adjMatrix[u][v]); + } + } + } + + return dist[destination]; + } + + public int[][] construct(int n, int[][] edges, long idx, int target) { + // 需要构造出第 idx 种不同的边权情况,返回一个邻接矩阵 + int[][] adjMatrix = new int[n][n]; + for (int i = 0; i < n; ++i) { + Arrays.fill(adjMatrix[i], -1); + } + for (int[] e : edges) { + int u = e[0], v = e[1], w = e[2]; + if (w != -1) { + adjMatrix[u][v] = adjMatrix[v][u] = w; + } else { + if (idx>= target - 1) {
+ adjMatrix[u][v] = adjMatrix[v][u] = target;
+ idx -= (target - 1);
+ } else {
+ adjMatrix[u][v] = adjMatrix[v][u] = (int) (1 + idx);
+ idx = 0;
+ }
+ }
+ }
+ return adjMatrix;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NextLargerNodes.java b/comxjtu/src/main/java/com/leetcode/everyday/NextLargerNodes.java
new file mode 100644
index 0000000..12f372c
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/NextLargerNodes.java
@@ -0,0 +1,53 @@
+package com.leetcode.everyday;
+
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月10日 11:36
+ * @description //1019. 链表中的下一个更大节点
+ */
+public class NextLargerNodes {
+
+ class Solution {
+ public int[] nextLargerNodes(ListNode head) {
+ List ans = new ArrayList();
+ Deque stack = new ArrayDeque();
+
+ ListNode cur = head;
+ int idx = -1;
+ while (cur != null) {
+ ++idx;
+ ans.add(0);
+ while (!stack.isEmpty() && stack.peek()[0] < cur.val) { + ans.set(stack.pop()[1], cur.val); + } + stack.push(new int[]{cur.val, idx}); + cur = cur.next; + } + + int size = ans.size(); + int[] arr = new int[size]; + for (int i = 0; i < size; ++i) { + arr[i] = ans.get(i); + } + return arr; + } + } + + class ListNode { + int val; + ListNode next; + + ListNode(int x) { + this.val = x; + } + + ListNode(int val, ListNode next) { this.val = val; this.next = next;} + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NumMoveStonesII.java b/comxjtu/src/main/java/com/leetcode/everyday/NumMoveStonesII.java new file mode 100644 index 0000000..fdcac07 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/NumMoveStonesII.java @@ -0,0 +1,53 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2023/4/7 10:45 + * @description //1040. 移动石子直到连续 II + */ +public class NumMoveStonesII { + + public int[] numMovesStonesII(int[] stones) { + int[] ans = new int[2]; + int len = stones.length; + int[] space = new int[len-1]; + int minCount = 0, maxCount = 0; + + Arrays.sort(stones); + while (stones[len-1]-stones[0]>len-1){
+// int[] maxValueandIndex = getMaxValueandIndex(space);
+// int[] minValueandIndex = getMinValueandIndex(space);
+ int min=stones[len-1], max=-1, maxIndex=-1, minIndex=-1;
+ for (int i = 1; i < stones.length; i++) { + space[i-1] = stones[i]-stones[i-1]; + if (space[i-1]>max){
+ max = space[i-1];
+ maxIndex = i-1;
+ } else if (space[i - 1] < min) { + min = space[i-1]; + minIndex = i-1; + } + } + + if (space[0]==1){ + update(stones, max, maxIndex); + minCount++; + }else if (space[len-2]==1){ + + }else { + + } + Arrays.sort(stones); + } + + + + return ans; + } + + private void update(int[] stones, int max, int maxIndex) { + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NumMovesStones.java b/comxjtu/src/main/java/com/leetcode/everyday/NumMovesStones.java new file mode 100644 index 0000000..6fe5274 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/NumMovesStones.java @@ -0,0 +1,59 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2023/4/30 16:23 + * @description //1033. 移动石子直到连续 + * 1040. 移动石子直到连续 II + */ +public class NumMovesStones { + + + /** + * + * @Param + * @Description //贪心算法 + * @Date 16:24 2023/4/30 + * @return + **/ + public int[] numMovesStones(int a, int b, int c) { + int x = Math.min(Math.min(a, b), c); + int z = Math.max(Math.max(a, b), c); + int y = a + b + c - x - z; + + int[] res = new int[2]; + res[0] = 2; + if (z - y == 1 && y - x == 1) { + res[0] = 0; + } else if (z - y <= 2 || y - x <= 2) { + res[0] = 1; + } + res[1] = z - x - 2; + return res; + } + + public int[] numMovesStonesII(int[] stones) { + int n = stones.length; + Arrays.sort(stones); + if (stones[n - 1] - stones[0] + 1 == n) { + return new int[]{0, 0}; + } + int ma = Math.max(stones[n - 2] - stones[0] + 1, stones[n - 1] - stones[1] + 1) - (n - 1); + int mi = n; + for (int i = 0, j = 0; i < n && j + 1 < n; ++i) { + while (j + 1 < n && stones[j + 1] - stones[i] + 1 <= n) { + ++j; + } + if (j - i + 1 == n - 1 && stones[j] - stones[i] + 1 == n - 1) { + mi = Math.min(mi, 2); + } else { + mi = Math.min(mi, n - (j - i + 1)); + } + } + return new int[]{mi, ma}; + } + +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NumPairsDivisibleBy60.java b/comxjtu/src/main/java/com/leetcode/everyday/NumPairsDivisibleBy60.java new file mode 100644 index 0000000..05ae40c --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/NumPairsDivisibleBy60.java @@ -0,0 +1,23 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/7 18:16 + * @description //1010. 总持续时间可被 60 整除的歌曲 + */ +public class NumPairsDivisibleBy60 { + + public int numPairsDivisibleBy60(int[] time) { + int[] cnt = new int[60]; + for (int t : time) { + cnt[t % 60]++; + } + long res = 0; + for (int i = 1; i < 30; i++) { + res += cnt[i] * cnt[60 - i]; + } + res += (long) cnt[0] * (cnt[0] - 1) / 2 + (long) cnt[30] * (cnt[30] - 1) / 2; + return (int) res; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NumSmallerByFrequency.java b/comxjtu/src/main/java/com/leetcode/everyday/NumSmallerByFrequency.java new file mode 100644 index 0000000..ac671f2 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/NumSmallerByFrequency.java @@ -0,0 +1,48 @@ +package com.leetcode.everyday; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +/** + * @author JS + * @version 1.0 + * @date 2023/6/10 9:06 + * @description //1170. 比较字符串最小字母出现频次 + */ +public class NumSmallerByFrequency { + + public int[] numSmallerByFrequency(String[] queries, String[] words) { + int[] ans = new int[queries.length]; + +// 先对words处理,将其保存在hashmap中 + Map map = new HashMap();
+ for (String word : words) {
+ int count = f(word);
+ map.put(count, map.getOrDefault(count, 0)+1);
+ }
+
+ int i = 0;
+ for (String query : queries) {
+ int count = f(query);
+ int ansNow = 0;
+ for (Map.Entry entry : map.entrySet()) {
+ if (entry.getKey()>count) ansNow+=entry.getValue();
+ }
+ ans[i]=ansNow;
+ i++;
+ }
+ return ans;
+ }
+
+ private int f(String word) {
+ int ans = 1;
+ char[] chars = word.toCharArray();
+ Arrays.sort(chars);
+ for (int i = 0; i < chars.length-1; i++) { + if (chars[i]==chars[i+1]) ans++; + else break; + } + return ans; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/NumSubarray.java b/comxjtu/src/main/java/com/leetcode/everyday/NumSubarray.java new file mode 100644 index 0000000..35ea2e0 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/NumSubarray.java @@ -0,0 +1,29 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2022/5/5 9:09 + * @description //LC713 给你一个整数数组 nums 和一个整数 k ,请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。 + */ +public class NumSubarray { + + public int numSubarrayProductLessThanK(int[] nums, int k) { + if (k<=0) return 0; + int count = 0; + for (int i = 0; i < nums.length; i++) { + if (nums[i] emailSet = new HashSet();
+ for (String email : emails) {
+ int i = email.indexOf('@');
+ String local = email.substring(0, i).split("\\+")[0]; // 去掉本地名第一个加号之后的部分
+ local = local.replace(".", ""); // 去掉本地名中所有的句点
+ emailSet.add(local + email.substring(i));
+ }
+ return emailSet.size();
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/OddString.java b/comxjtu/src/main/java/com/leetcode/everyday/OddString.java
new file mode 100644
index 0000000..f244b53
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/OddString.java
@@ -0,0 +1,61 @@
+package com.leetcode.everyday;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月25日 20:32
+ * @description //TODO
+ */
+public class OddString {
+
+ public String oddString(String[] words) {
+ HashMap hash = new LinkedHashMap();
+ int count = 0;
+ for (String word : words) {
+ count++;
+ StringBuilder diff = new StringBuilder();
+ for (int i = 0; i < word.length()-1; i++) { + diff.append("*"); + diff.append(word.charAt(i+1)-word.charAt(i)); + } + String s= diff.toString(); + if (!hash.containsKey(s)){ + if (count>3){
+ return word;
+ }else {
+ hash.put(s,1);
+ }
+ }else {
+ hash.put(s,hash.get(s)+1);
+ }
+ }
+
+
+ for(String key:hash.keySet()) {
+ int value = hash.get(key);
+ if (value==1){
+ for (int j = 0; j < 3; j++) { + StringBuilder diff = new StringBuilder(); + for (int i = 0; i < words[j].length()-1; i++) { + diff.append("*"); + diff.append(words[j].charAt(i+1)-words[j].charAt(i)); + } + String s= diff.toString(); + if (s.equals(key)){ + return words[j]; + } + } + } + } + return ""; + } + + public static void main(String[] args) { + OddString solver = new OddString(); + String[] words = {"abm","bcn","alm"}; + System.out.println(solver.oddString(words)); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/OneEditAway.java b/comxjtu/src/main/java/com/leetcode/everyday/OneEditAway.java new file mode 100644 index 0000000..e52a39c --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/OneEditAway.java @@ -0,0 +1,66 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2022/5/13 10:21 + * @description //面试题 01.05. 一次编辑 + */ +public class OneEditAway { + public boolean oneEditAway(String first, String second) { + if (first == null || second==null) return false; + if (Math.abs(first.length()-second.length())>1) return false;
+ int count = 0;
+ if (first.length() == second.length()){
+ for (int i = 0; i < first.length(); i++) { + if (first.charAt(i)!=second.charAt(i)) count++; + if (count==2) return false; + } + return true; + }else { + if (first.length()> pacificAtlantic(int[][] heights) {
+ List> resultList = new LinkedList();
+ if (heights == null){
+ return resultList;
+ }
+ int m = heights.length, n = heights[0].length;
+
+ //右上角和左下角
+ List listRight = new ArrayList(Arrays.asList(new int[]{0,n-1}));
+ resultList.add(listRight);
+ if (m == 1 && n == 1){
+ return resultList;
+ }
+ List listLeft = new ArrayList(Arrays.asList(new int[]{m-1,0}));
+ resultList.add(listLeft);
+
+ //处理每一行
+
+ return resultList;
+ }
+
+ public static void main(String[] args) {
+
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/PowerfulIntegers.java b/comxjtu/src/main/java/com/leetcode/everyday/PowerfulIntegers.java
new file mode 100644
index 0000000..b6e6159
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/PowerfulIntegers.java
@@ -0,0 +1,37 @@
+package com.leetcode.everyday;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月2日 21:35
+ * @description //970. 强整数
+ */
+class PowerfulIntegers {
+ public List powerfulIntegers(int x, int y, int bound) {
+ Set set = new HashSet();
+ int value1 = 1;
+ for (int i = 0; i < 21; i++) { + int value2 = 1; + for (int j = 0; j < 21; j++) { + int value = value1 + value2; + if (value <= bound) { + set.add(value); + } else { + break; + } + value2 *= y; + } + if (value1> bound) {
+ break;
+ }
+ value1 *= x;
+ }
+ return new ArrayList(set);
+ }
+}
+
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/PrevPermOpt1.java b/comxjtu/src/main/java/com/leetcode/everyday/PrevPermOpt1.java
new file mode 100644
index 0000000..6939baa
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/PrevPermOpt1.java
@@ -0,0 +1,39 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月3日 11:17
+ * @description //1053. 交换一次的先前排列
+ */
+public class PrevPermOpt1 {
+
+ public int[] prevPermOpt1(int[] A) {
+ int len = A.length;
+ int curMax = -1;
+ int index = -1;
+ boolean hasResult = false;
+ for (int i = len - 2; i>= 0; i--) {
+ if (A[i+1] < A[i]) { // 此处逆序,需要移动A[i] + for (int j = i + 1; j < len; j++) { // 寻找与 A[i] 交换的位置 + if (A[i]> A[j]) { // 必须满足 A[i]> A[j],否则不能满足交换后的字典序小于原始字典序
+ hasResult = true;
+ if (A[j]> curMax) {
+ curMax = A[j];
+ index = j;
+ }
+ }
+ }
+ if (hasResult) {
+ int tmp = A[i];
+ A[i] = A[index];
+ A[index] = tmp;
+ return A;
+ }
+ }
+ }
+ return A;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/QuadTree.java b/comxjtu/src/main/java/com/leetcode/everyday/QuadTree.java
new file mode 100644
index 0000000..74de0fa
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/QuadTree.java
@@ -0,0 +1,138 @@
+package com.leetcode.everyday;
+
+import com.sun.org.apache.bcel.internal.generic.I2F;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年4月29日 11:15
+ * @description lc427:
+ * 给你一个 n * n 矩阵 grid ,矩阵由若干 0 和 1 组成。请你用四叉树表示该矩阵 grid 。
+ * 你需要返回能表示矩阵的 四叉树 的根结点。
+ */
+public class QuadTree {
+
+ public Node construct(int[][] grid) {
+ Node root = new Node();
+ int length = grid.length ;
+ //TODO:length为0时怎么办
+
+ if (length<=1){ + root.isLeaf = true; + root.val = grid[0][0]==1 ? true : false; + return root; + } + + root = constructChild(grid,0,0,length); + + return root; + } + + private Node constructChild(int[][] grid, int startX, int startY, int length) { + Node parent = new Node(); + if (length==1){ + parent.isLeaf = true; + parent.val = grid[startX][startY]==1 ? true : false; + return parent; + } + length = length/2; + Node topLeft = constructChild(grid, startX, startY, length); + Node topRight = constructChild(grid, startX, startY+length, length); + Node bottomLeft = constructChild(grid, startX+length, startY, length); + Node bottomRight = constructChild(grid, startX+length, startY+length, length); + + int ans = 0; + ans += topLeft.val ? 1 :0; + ans += topRight.val ? 1 :0; + ans += bottomLeft.val ? 1 :0; + ans += bottomRight.val ? 1 :0; + + if ((topLeft.isLeaf && topRight.isLeaf && bottomLeft.isLeaf && bottomRight.isLeaf) && (ans==0 || ans==4)){ + parent.val = topLeft.val; + parent.isLeaf = true; + + }else { + parent.topLeft = topLeft; + parent.topRight = topRight; + parent.bottomLeft = bottomLeft; + parent.bottomRight = bottomRight; + parent.val = true; + } + return parent; + } + + /** + * @Description 节点定义 + * @Date 11:33 2022/4/29 + **/ + class Node { + public boolean val; + public boolean isLeaf; + public Node topLeft; + public Node topRight; + public Node bottomLeft; + public Node bottomRight; + + + public Node() { + this.val = false; + this.isLeaf = false; + this.topLeft = null; + this.topRight = null; + this.bottomLeft = null; + this.bottomRight = null; + } + + public Node(boolean val, boolean isLeaf) { + this.val = val; + this.isLeaf = isLeaf; + this.topLeft = null; + this.topRight = null; + this.bottomLeft = null; + this.bottomRight = null; + } + + public Node(boolean val, boolean isLeaf, Node topLeft, Node topRight, Node bottomLeft, Node bottomRight) { + this.val = val; + this.isLeaf = isLeaf; + this.topLeft = topLeft; + this.topRight = topRight; + this.bottomLeft = bottomLeft; + this.bottomRight = bottomRight; + } + } + + public void outResult(Node root){ + + levelOrder(root); + } + + private List levelOrder(Node root){
+ List resList = new LinkedList();
+ Queue queue = new LinkedList();
+ if (root == null){
+ return resList;
+ }
+ queue.add(root);
+ while (!queue.isEmpty()){
+ Node node = queue.poll();
+ int[] res = {0,1};
+ if (node.isLeaf) res[0]=1;
+ res[1]=node.val ? 1 : 0;
+ resList.add(res);
+ System.out.print(Arrays.toString(res)+",");
+ if (node.topLeft != null) queue.add(node.topLeft);
+ if (node.topRight != null) queue.add(node.topRight);
+ if (node.bottomLeft != null) queue.add(node.bottomLeft);
+ if (node.bottomRight != null) queue.add(node.bottomRight);
+ }
+ System.out.println();
+ return resList;
+ }
+
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/RandomPoint.java b/comxjtu/src/main/java/com/leetcode/everyday/RandomPoint.java
new file mode 100644
index 0000000..495ec72
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/RandomPoint.java
@@ -0,0 +1,47 @@
+package com.leetcode.everyday;
+
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年6月5日 10:27
+ * @description //478. 在圆内随机生成点
+ * 这里实现的方法看似可行,但是分布并不是,所以还是采用拒绝采样的思路来做。
+ * (拒绝采样的意思是说:我们在一个更大的范围内生成随机数,并拒绝掉那些不在题目给定范围内的随机数,
+ * 此时保留下来的随机数都是在范围内的。为了在一个半径为 RR 的圆中生成均匀随机点,我们可以使用一个边长为 2R2R 的正方形覆盖住圆,
+ * 并在正方形内生成均匀随机点,此时就只需要对于横坐标和纵坐标分别生成一个随机数即可。)
+ */
+public class RandomPoint {
+
+ private double radius;
+ private double x_center, y_center;
+
+ public RandomPoint(double radius, double x_center, double y_center) {
+ this.radius = radius;
+ this.x_center = x_center;
+ this.y_center = y_center;
+ }
+
+ public double[] randPoint() {
+ Random random = new Random();
+// double x_left = x_center-radius, x_right = x_center+radius;
+ double x_random = x_center+random.nextDouble() * radius;
+ double y_half = Math.sqrt(radius*radius- Math.pow(x_random-x_center,2));
+// double y_up = y_center+y_half, y_down=y_center-y_half;
+ double y_random = y_center + random.nextDouble() *y_half;;
+ return new double[]{x_random, y_random};
+ }
+
+ public static void main(String[] args) {
+ RandomPoint randomPoint = new RandomPoint(1.0,0.0,0.0);
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+ System.out.println(Arrays.toString(randomPoint.randPoint()));
+
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/RecentCounter.java b/comxjtu/src/main/java/com/leetcode/everyday/RecentCounter.java
new file mode 100644
index 0000000..41d5ef0
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/RecentCounter.java
@@ -0,0 +1,27 @@
+package com.leetcode.everyday;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月6日 9:57
+ * @description //lc933写一个 RecentCounter 类来计算特定时间范围内最近的请求。
+ */
+public class RecentCounter {
+
+ private Queue queue;
+
+ public RecentCounter() {
+ queue = new LinkedList();
+ }
+
+ public int ping(int t) {
+ while (queue.peek()!=null && queue.peek() seen = new HashMap();
+ int prefix = 0;
+ for (ListNode node = dummy; node != null; node = node.next) {
+ prefix += node.val;
+ seen.put(prefix, node);
+ }
+ prefix = 0;
+ for (ListNode node = dummy; node != null; node = node.next) {
+ prefix += node.val;
+ node.next = seen.get(prefix).next;
+ }
+ return dummy.next;
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/ReorderLogFiles.java b/comxjtu/src/main/java/com/leetcode/everyday/ReorderLogFiles.java
new file mode 100644
index 0000000..118dbbd
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/ReorderLogFiles.java
@@ -0,0 +1,81 @@
+package com.leetcode.everyday;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月3日 9:38
+ * @description //给你一个日志数组 logs。每条日志都是以空格分隔的字串,其第一个字为字母与数字混合的 标识符 。
+ * 有两种不同类型的日志:
+字母日志:除标识符之外,所有字均由小写字母组成
+数字日志:除标识符之外,所有字均由数字组成
+请按下述规则将日志重新排序:
+所有 字母日志 都排在 数字日志 之前。
+字母日志 在内容不同时,忽略标识符后,按内容字母顺序排序;在内容相同时,按标识符排序。
+数字日志 应该保留原来的相对顺序。
+返回日志的最终顺序。
+ */
+public class ReorderLogFiles {
+
+ public String[] reorderLogFiles(String[] logs) {
+ if (logs==null || logs.length<2) return logs; +// String[] letter = new String[]{}; +// String[] digit = new String[]{}; + List letters = new ArrayList();
+ List digits = new ArrayList();
+ Comparator comparator = new Comparator() {
+ @Override
+ public int compare(Object o1, Object o2) {
+ String val1 = (String)o1;
+ String val2 = (String)o2;
+ String[] arr1 = val1.split(" ");
+ String[] arr2 = val2.split(" ");
+ int i=1,j=1;
+ while (i{
+ int index1 = a.indexOf(" ");
+ int index2 = b.indexOf(" ");
+ String a1=a.substring(index1+1);
+ String b1=b.substring(index2+1);
+ return a1.equals(b1) ? a.compareTo(b) : a1.compareTo(b1);
+ });
+ letters.addAll(digits);
+ return letters.toArray(logs);
+ }
+
+ public static void main(String[] args) {
+ ReorderLogFiles reorderLogFiles = new ReorderLogFiles();
+ String[] input = new String[]{"let1 art zero can","let3 art zero","let2 own kit dig","dig1 8 1 5 1","dig2 3 6"};
+ System.out.println(Arrays.toString(reorderLogFiles.reorderLogFiles(input)));
+ }
+
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/ShortestPathBinaryMatrix.java b/comxjtu/src/main/java/com/leetcode/everyday/ShortestPathBinaryMatrix.java
new file mode 100644
index 0000000..007124a
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/ShortestPathBinaryMatrix.java
@@ -0,0 +1,54 @@
+package com.leetcode.everyday;
+
+import java.util.*;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年5月26日 8:51
+ * @description //1091. 二进制矩阵中的最短路径
+ */
+public class ShortestPathBinaryMatrix {
+
+ public int shortestPathBinaryMatrix(int[][] grid) {
+ int n = grid.length;
+ if (grid[0][0]==1 || grid[n-1][n-1]==1){
+ return -1;
+ }
+
+ int[][] dirs = new int[][]{{-1,-1}, {-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};
+
+ Queue queue = new LinkedList();
+ Set visited = new HashSet();
+ queue.offer(new int[]{0, 0});
+ visited.add(0);
+ int ans = 1;
+ while (!queue.isEmpty()) {
+ int size = queue.size();
+ while (size--> 0) {//BFS中一次处理当前队列的所有元素
+ int[] cur = queue.poll();
+ if (cur[0] == n - 1 && cur[1] == n - 1) {//到达终点
+ return ans;
+ }
+ for (int[] dir : dirs) {//遍历八个方向的邻居
+ int x = cur[0] + dir[0], y = cur[1] + dir[1];
+ int pos = x * n + y;
+ if (x < 0 || x>= n || y < 0 || y>= n || grid[x][y] == 1 || visited.contains(pos)) {
+ continue;
+ }
+ queue.offer(new int[]{x, y});
+ visited.add(pos);
+ }
+ }
+ ans++;
+ }
+ return -1;//无法到达终点
+ }
+
+ public static void main(String[] args) {
+ ShortestPathBinaryMatrix solver = new ShortestPathBinaryMatrix();
+// [[0,1,1,0,0,0],[0,1,0,1,1,0],[0,1,1,0,1,0],[0,0,0,1,1,0],[1,1,1,1,1,0],[1,1,1,1,1,0]]
+ int[][] grid = new int[][]{{0,1,1,0,0,0},{0,1,0,1,1,0},{0,1,1,0,1,0},{0,0,0,1,1,0},{1,1,1,1,1,0},{1,1,1,1,1,0}};
+ System.out.println(solver.shortestPathBinaryMatrix(grid));
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/SmallestEvenMultiple.java b/comxjtu/src/main/java/com/leetcode/everyday/SmallestEvenMultiple.java
new file mode 100644
index 0000000..9a4e244
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/SmallestEvenMultiple.java
@@ -0,0 +1,15 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2023年4月21日 9:26
+ * @description //2413. 最小偶倍数
+ */
+public class SmallestEvenMultiple {
+ public int smallestEvenMultiple(int n) {
+ if (n<=2) return 2; + if ((n&1)==0) return n; + return n*2; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/SmallestRangeI.java b/comxjtu/src/main/java/com/leetcode/everyday/SmallestRangeI.java new file mode 100644 index 0000000..60543f8 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/SmallestRangeI.java @@ -0,0 +1,37 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2022/4/30 10:22 + * @description //lc908: + * 给你一个整数数组 nums,和一个整数 k 。 +在一个操作中,您可以选择 0 <= i < nums.length 的任何索引 i 。将 nums[i] 改为 nums[i] + x ,其中 x 是一个范围为 [-k, k] 的整数。对于每个索引 i ,最多 只能 应用 一次 此操作。 +nums 的 分数 是 nums 中最大和最小元素的差值。 +在对 nums 中的每个索引最多应用一次上述操作后,返回 nums 的最低 分数 + */ +public class SmallestRangeI { + + /** + * + * @Param + * @Description //使用排序后就一目了然了,最大值和最小值的转换代价最大,所以只需要计算最大和最小即可; + * 其实也不需要排序,找出最大值最小值就行。 + * @Date 10:23 2022/4/30 + * @return + **/ + public int smallestRangeI(int[] nums, int k) { + if (nums == null || nums.length<2) return 0; +// Arrays.sort(nums); +// int ans = nums[nums.length-1]-nums[0] - 2*k; + int max = -1, min=Integer.MAX_VALUE; + for (int i = 0; i < nums.length; i++) { + if (max < nums[i]) max = nums[i]; + if (min> nums[i]) min = nums[i];
+ }
+ int ans = max - min - 2*k;
+ return ans<=0 ? 0 : ans; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/SortArrayByParity.java b/comxjtu/src/main/java/com/leetcode/everyday/SortArrayByParity.java new file mode 100644 index 0000000..fad7c04 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/SortArrayByParity.java @@ -0,0 +1,46 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2022/4/28 15:54 + * @description //LC905 + * 给你一个整数数组 nums,将 nums 中的的所有偶数元素移动到数组的前面,后跟所有奇数元素。 + * 返回满足此条件的 任一数组 作为答案。 + */ +public class SortArrayByParity { + + + + /** + * + * @Param + * @Description 方法一:双指针(类似于快速排序的partition) + * 双指针:前后指针,时间复杂度为O(N) + 1.前指针为偶数指针evenIndex,从0开始往后走,直到当前值为偶数或者交换后为偶数往后继续, + 2.后指针为奇数指针oddIndex + 3.终止条件evenIndex>=oddIndex,
+ * @Date 17:46 2022年4月28日
+ * @return
+ **/
+ public int[] sortArrayByParity(int[] nums) {
+ if (nums == null || nums.length == 1){
+ return nums;
+ }
+ int evenIndex = 0, oddIndex = nums.length-1;
+ while (evenIndex < nums.length && oddIndex> 0 && evenIndex < oddIndex){ + if (nums[evenIndex]%2 == 0){ + evenIndex++; + }else if (nums[oddIndex]%2 == 0){ + int tmp = nums[evenIndex]; + nums[evenIndex] = nums[oddIndex]; + nums[oddIndex] = tmp; + evenIndex++; + oddIndex--; + }else { + oddIndex--; + } + } + return nums; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/StoreWater.java b/comxjtu/src/main/java/com/leetcode/everyday/StoreWater.java new file mode 100644 index 0000000..6afbf4b --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/StoreWater.java @@ -0,0 +1,28 @@ +package com.leetcode.everyday; + +import java.util.Arrays; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/21 16:54 + * @description //LCP 33. 蓄水 + */ +public class StoreWater { + + public int storeWater(int[] bucket, int[] vat) { + int maxk = Arrays.stream(vat).max().getAsInt(); + if (maxk == 0) { + return 0; + } + int res = Integer.MAX_VALUE; + for (int k = 1; k <= maxk && k < res; ++k) { + int t = 0; + for (int i = 0; i < bucket.length; ++i) { + t += Math.max(0, (vat[i] + k - 1) / k - bucket[i]); + } + res = Math.min(res, t + k); + } + return res; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/SumRootToLeaf.java b/comxjtu/src/main/java/com/leetcode/everyday/SumRootToLeaf.java new file mode 100644 index 0000000..4044f95 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/SumRootToLeaf.java @@ -0,0 +1,37 @@ +package com.leetcode.everyday; + +import com.leetcode.util.TreeNode; + +import java.util.LinkedList; +import java.util.List; + +/** + * @author JS + * @version 1.0 + * @date 2022/5/30 8:14 + * @description //1022. 从根到叶的二进制数之和 + */ +public class SumRootToLeaf { + + + int sum=0; + List ansList = new LinkedList();
+ public int sumRootToLeaf(TreeNode root) {
+ if (root==null) return sum;
+ String ans = "";
+ recursion(root,ans);
+ return sum;
+ }
+
+ private void recursion(TreeNode root,String ans) {
+ if (root.left==null && root.right==null) {
+ ans+=root.val;
+ sum+=Integer.parseInt(ans, 2);
+ ansList.add(ans);
+ return;
+ }
+ ans+=root.val;
+ if (root.left!=null) recursion(root.left, ans);
+ if (root.right!=null)recursion(root.right, ans);
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/TagValidator.java b/comxjtu/src/main/java/com/leetcode/everyday/TagValidator.java
new file mode 100644
index 0000000..621602e
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/TagValidator.java
@@ -0,0 +1,130 @@
+package com.leetcode.everyday;
+
+import java.util.Scanner;
+import java.util.Stack;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月2日 11:02
+ * @description //lc591给定一个表示代码片段的字符串,你需要实现一个验证器来解析这段代码,并返回它是否合法。
+ * 题目比较长,具体可以查看
+ */
+public class TagValidator {
+
+ /**
+ *
+ * @Description //思路及关键点:
+ * 1. 解析:
+ * (1)判断属于哪种模式:
+ * 闭合标签模式 < 和内容模式(又具体包括代码注释cdata,任意字符) + * <
+ * 2. 闭合标签模式:TAG_CONTENT
+ * (1)标签名:正则
+ * (2)判断匹配:标签栈,解析到结束标签时,比较名字是否相同
+ * (3)嵌套标签:标签栈
+ * //(4) 没有对应的>
+ * 3. 代码注释cdata模式:
+ * (1)CDATA_CONTENT为任意字符,其中可以包括闭合标签,也就是其中的内容不解析,屏蔽,用flag。
+ * (2)需要判断CDATA_CONTENT结束时,第一个]]>
+ *
+ * @Date 11:03 2022年5月2日
+ * @return
+ **/
+ public boolean isValid2(String code) {
+ if (code==null || code.length()==0 || !code.startsWith("<")) return false; + int index = 0; + boolean tagFlag, codeFlag; + while(true){ + if (code.charAt(index)=='<'){ + tagFlag = code.matches("^<[a-z]{1,9}>.*");
+ codeFlag = code.matches("^ tags = new Stack();
+
+ int i = 0;
+ while (i < n) { + if (code.charAt(i) == '<') { + if (i == n - 1) { + return false; + } + if (code.charAt(i + 1) == '/') { + int j = code.indexOf('>', i);
+ if (j < 0) { + return false; + } + String tagname = code.substring(i + 2, j); + if (tags.isEmpty() || !tags.peek().equals(tagname)) { + return false; + } + tags.pop(); + i = j + 1; + if (tags.isEmpty() && i != n) { + return false; + } + } else if (code.charAt(i + 1) == '!') { + if (tags.isEmpty()) { + return false; + } + if (i + 9> n) {
+ return false;
+ }
+ String cdata = code.substring(i + 2, i + 9);
+ if (!"[CDATA[".equals(cdata)) {
+ return false;
+ }
+ int j = code.indexOf("]]>", i);
+ if (j < 0) { + return false; + } + i = j + 1; + } else { + int j = code.indexOf('>', i);
+ if (j < 0) { + return false; + } + String tagname = code.substring(i + 1, j); + if (tagname.length() < 1 || tagname.length()> 9) {
+ return false;
+ }
+ for (int k = 0; k < tagname.length(); ++k) { + if (!Character.isUpperCase(tagname.charAt(k))) { + return false; + } + } + tags.push(tagname); + i = j + 1; + } + } else { + if (tags.isEmpty()) { + return false; + } + ++i; + } + } + + return tags.isEmpty(); + } + + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + while (true){ + String code = scanner.nextLine(); + System.out.println(code+": "+code.matches("^<[a-z]{1,9}>.*"));
+ System.out.println(code+": "+code.matches("^ map = new HashMap();
+ for (int i = 0; i < matrix.length; i++) { + StringBuilder sb1 = new StringBuilder(); + StringBuilder sb2 = new StringBuilder(); + for (int j = 0; j < matrix[0].length; j++) { + // 正序拼接和倒序拼接 + sb1.append(matrix[i][j]); + sb2.append(1 - matrix[i][j]); + } + // 存储相同的01序列的数量 + String s1 = sb1.toString(); + String s2 = sb2.toString(); + map.put(s1, map.getOrDefault(s1, 0) + 1); + map.put(s2, map.getOrDefault(s2, 0) + 1); + } + int maxRows = 0; + for (int value : map.values()) { + // 更新最大行数 + maxRows = Math.max(maxRows, value); + } + return maxRows; + } + + void testWithFiveExamples(){ + int[][] matrix = {{0,1},{1,1}}; + int[][] matrix1 = {{0,1},{1,0}}; + int[][] matrix2 = {{0,0,0},{0,0,1},{1,1,0}}; + int[][] matrix3 = {{1,0,0,0,1,1,1,0,1,1,1},{1,0,0,0,1,0,0,0,1,0,0},{1,0,0,0,1,1,1,0,1,1,1},{1,0,0,0,1,0,0,0,1,0,0},{1,1,1,0,1,1,1,0,1,1,1}}; + int[][] matrix4 = {{0,0,0,0,1,1,1},{0,0,0,0,1,0,1},{1,1,1,0,1,1,1},{0,0,0,0,1,0,0},{0,0,1,0,1,0,0},{0,1,1,0,1,0,0},{0,0,0,0,1,1,1},{0,0,0,0,1,0,0},{0,0,0,0,1,0,0},{0,0,0,0,1,0,0}}; + System.out.println(maxEqualRowsAfterFlips(matrix)); + System.out.println(maxEqualRowsAfterFlips(matrix1)); + System.out.println(maxEqualRowsAfterFlips(matrix2)); + System.out.println(maxEqualRowsAfterFlips(matrix3)); + System.out.println(maxEqualRowsAfterFlips(matrix4)); + } + + public static void main(String[] args) { + Test test = new Test(); + test.testWithFiveExamples(); + } + + + +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/Test.js b/comxjtu/src/main/java/com/leetcode/everyday/Test.js new file mode 100644 index 0000000..fbaeab9 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/Test.js @@ -0,0 +1,6 @@ +function calculateDaysBetweenDates(begin, end) { + let beginDate = new Date(begin); + let endDate = new Date(end); + let days = (endDate - beginDate) / (1000 * 60 * 60 * 24); + return days; +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/TreeAncestor.java b/comxjtu/src/main/java/com/leetcode/everyday/TreeAncestor.java new file mode 100644 index 0000000..725b1de --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/TreeAncestor.java @@ -0,0 +1,32 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2023/6/12 10:23 + * @description //1483. 树节点的第 K 个祖先 + * 由于任意k 可以分解为若干不同的2 的幂(例如 13=8+4+1),所以只需要预处理出这些2^i祖先节点,就可以快速地到达任意第k 个祖先节点。 + */ +public class TreeAncestor { + + int[] parent; + int n; + public TreeAncestor(int n, int[] parent) { + this.n = n; + this.parent = parent; + } + + public int getKthAncestor(int node, int k) { + int count = 0; + while (count count = new HashMap();
+ for (int x : nums) {
+ count.merge(x, 1, Integer::sum);
+ }
+ int res = 0, n = nums.length, t = 0;
+ for (Map.Entry entry : count.entrySet()) {
+ res += t * entry.getValue() * (n - t - entry.getValue());
+ t += entry.getValue();
+ }
+ return res;
+ }
+
+ public static void main(String[] args) {
+ UnequalTriplets solver = new UnequalTriplets();
+ int ans = solver.unequalTriplets(new int[]{1,3,1,2,4});
+ System.out.println(ans);
+ }
+}
diff --git a/comxjtu/src/main/java/com/leetcode/everyday/ValidIPAddress.java b/comxjtu/src/main/java/com/leetcode/everyday/ValidIPAddress.java
new file mode 100644
index 0000000..6e6a304
--- /dev/null
+++ b/comxjtu/src/main/java/com/leetcode/everyday/ValidIPAddress.java
@@ -0,0 +1,43 @@
+package com.leetcode.everyday;
+
+/**
+ * @author JS
+ * @version 1.0
+ * @date 2022年5月29日 16:54
+ * @description 468. 验证IP地址
+ */
+public class ValidIPAddress {
+ public String validIPAddress(String queryIP) {
+ if (queryIP.contains(".")){
+ if (queryIP.startsWith(".") || queryIP.endsWith(".")) return "Neither";
+ String[] strings = queryIP.split("\\.");
+
+ if (strings.length!=4) return "Neither";
+ for (String string : strings) {
+ if(!string.matches("[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]"))
+ return "Neither";
+ }
+ return "IPv4";
+ }else if (queryIP.contains(":")){
+ if (queryIP.startsWith(":") || queryIP.endsWith(":")) return "Neither";
+ String[] strings = queryIP.split(":");
+ if (strings.length!=8) return "Neither";
+ for (String string : strings) {
+ if(string.length()>4||string.length()<1) return "Neither"; + if(!string.matches("[0-9a-fA-F]{1,4}")) + return "Neither"; + } + return "IPv6"; + } + return "Neither"; + } + + public static void main(String[] args) { + ValidIPAddress validIPAddress = new ValidIPAddress(); + String queryIP = "172.16.254.1"; + String[] strings = queryIP.split("\\."); + System.out.println(validIPAddress.validIPAddress(queryIP)); + queryIP ="2001:0db8:85a3:0:0:8A2E:0370:7334:"; + System.out.println(validIPAddress.validIPAddress(queryIP)); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/WordSubsets.java b/comxjtu/src/main/java/com/leetcode/everyday/WordSubsets.java new file mode 100644 index 0000000..c3a12be --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/WordSubsets.java @@ -0,0 +1,49 @@ +package com.leetcode.everyday; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +import static org.apache.commons.lang3.CharSetUtils.count; + +/** + * @author JS + * @version 1.0 + * @date 2023/5/21 17:45 + * @description //TODO + */ +public class WordSubsets { + + public List wordSubsets(String[] A, String[] B) {
+ int[] bmax = count("");
+ for (String b: B) {
+ int[] bCount = count(b);
+ for (int i = 0; i < 26; ++i) + bmax[i] = Math.max(bmax[i], bCount[i]); + } + + List ans = new LinkedList();
+ for (String a : A) {
+ int[] aCount = count(a);
+ boolean shouldAdd = true;
+ for (int i = 0; i < 26; ++i) { + if (aCount[i] < bmax[i]) { + shouldAdd = false; + break; + } + } + if (shouldAdd) { + ans.add(a); + } + } + + return ans; + } + + public int[] count(String S) { + int[] ans = new int[26]; + for (char c: S.toCharArray()) + ans[c - 'a']++; + return ans; + } +} diff --git a/comxjtu/src/main/java/com/leetcode/everyday/isRobotBounded.java b/comxjtu/src/main/java/com/leetcode/everyday/isRobotBounded.java new file mode 100644 index 0000000..e524288 --- /dev/null +++ b/comxjtu/src/main/java/com/leetcode/everyday/isRobotBounded.java @@ -0,0 +1,31 @@ +package com.leetcode.everyday; + +/** + * @author JS + * @version 1.0 + * @date 2023/4/11 10:55 + * @description //1041. 困于环中的机器人 + */ +public class isRobotBounded { + + public boolean isRobotBounded(String instructions) { + int[][] direc = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; + int direcIndex = 0; + int x = 0, y = 0; + int n = instructions.length(); + for (int idx = 0; idx < n; idx++) { + char instruction = instructions.charAt(idx); + if (instruction == 'G') { + x += direc[direcIndex][0]; + y += direc[direcIndex][1]; + } else if (instruction == 'L') { + direcIndex += 3; + direcIndex %= 4; + } else { + direcIndex++; + direcIndex %= 4; + } + } + return direcIndex != 0 || (x == 0 && y == 0); + } +} diff --git a/comxjtu/src/main/java/com/leetcode/middle/Backpacking.java b/comxjtu/src/main/java/com/leetcode/middle/Backtracking.java similarity index 65% rename from comxjtu/src/main/java/com/leetcode/middle/Backpacking.java rename to comxjtu/src/main/java/com/leetcode/middle/Backtracking.java index ec03eb5..77aa46b 100644 --- a/comxjtu/src/main/java/com/leetcode/middle/Backpacking.java +++ b/comxjtu/src/main/java/com/leetcode/middle/Backtracking.java @@ -1,5 +1,7 @@ package com.leetcode.middle; +import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ; + import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; @@ -10,7 +12,7 @@ * @Date: Created in 20:40 2018/6/13 * @Modified By: */ -public class Backpacking { +public class Backtracking { /** * 电话号码的字母组合 * @param digits @@ -37,6 +39,30 @@ public List letterCombinations(String digits) {
return result;
}
+ public List letterCombinations2(String digits) {
+ if (digits == null) return null;
+ List result = new LinkedList();
+ if (digits.length() ==0) return result;
+
+ String[] dict = new String[]{"abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
+ backtrack(result, digits, dict,0, new StringBuilder());
+ return result;
+ }
+
+ private void backtrack(List result, String digits, String[] dict, int itrDigits, StringBuilder stringBuilder) {
+ if (itrDigits==digits.length()){
+ result.add(stringBuilder.toString());
+ return;
+ }
+ String string = dict[digits.charAt(itrDigits)-'2'];
+ for (int i = 0; i < string.length(); i++) { + int size = stringBuilder.length(); + stringBuilder.append(string.charAt(i)); + backtrack(result, digits,dict,itrDigits+1, stringBuilder); + stringBuilder.delete(size,size+1); + } + } + /** * lc46 * 全排列: @@ -45,15 +71,15 @@ public List letterCombinations(String digits) {
* @return
*/
public List> permute(int[] nums) {
- List> list = new ArrayList();
+ List> list = new LinkedList();
// Arrays.sort(nums); // not necessary
- backtrack(list, new ArrayList(), nums);
+ backtrack(list, new LinkedList(), nums);
return list;
}
private void backtrack(List> list, List tempList, int [] nums){
if(tempList.size() == nums.length){
- list.add(new ArrayList(tempList));
+ list.add(new LinkedList(tempList));
} else{
for(int i = 0; i < nums.length; i++){ if(tempList.contains(nums[i])) continue; // element already exists, skip @@ -71,18 +97,20 @@ private void backtrack(List> list, List tempList, int []
* @return
*/
public List> permuteUnique(int[] nums) {
- List> list = new ArrayList();
+ List> list = new LinkedList();
Arrays.sort(nums);
- backtrack(list, new ArrayList(), nums, new boolean[nums.length]);
+ backtrack(list, new LinkedList