竞赛记录
This commit is contained in:
huangge1199@hotmail.com
parent
e8fcfb9f6c
commit
7f7691e3bf
@ -22,29 +22,29 @@ public class Flatten {
|
||||
/**
|
||||
* 430. 扁平化多级双向链表
|
||||
*/
|
||||
public Node flatten(Node head) {
|
||||
if (head == null) return head;
|
||||
// pseudo head to ensure the `prev` pointer is never none
|
||||
Node pseudoHead = new Node(0, null, head, null);
|
||||
|
||||
flattenDFS(pseudoHead, head);
|
||||
|
||||
// detach the pseudo head from the real head
|
||||
pseudoHead.next.prev = null;
|
||||
return pseudoHead.next;
|
||||
}
|
||||
/* return the tail of the flatten list */
|
||||
public Node flattenDFS(Node prev, Node curr) {
|
||||
if (curr == null) return prev;
|
||||
curr.prev = prev;
|
||||
prev.next = curr;
|
||||
|
||||
// the curr.next would be tempered in the recursive function
|
||||
Node tempNext = curr.next;
|
||||
|
||||
Node tail = flattenDFS(curr, curr.child);
|
||||
curr.child = null;
|
||||
|
||||
return flattenDFS(tail, tempNext);
|
||||
}
|
||||
// public Node flatten(Node head) {
|
||||
// if (head == null) return head;
|
||||
// // pseudo head to ensure the `prev` pointer is never none
|
||||
// Node pseudoHead = new Node(0, null, head, null);
|
||||
//
|
||||
// flattenDFS(pseudoHead, head);
|
||||
//
|
||||
// // detach the pseudo head from the real head
|
||||
// pseudoHead.next.prev = null;
|
||||
// return pseudoHead.next;
|
||||
// }
|
||||
// /* return the tail of the flatten list */
|
||||
// public Node flattenDFS(Node prev, Node curr) {
|
||||
// if (curr == null) return prev;
|
||||
// curr.prev = prev;
|
||||
// prev.next = curr;
|
||||
//
|
||||
// // the curr.next would be tempered in the recursive function
|
||||
// Node tempNext = curr.next;
|
||||
//
|
||||
// Node tail = flattenDFS(curr, curr.child);
|
||||
// curr.child = null;
|
||||
//
|
||||
// return flattenDFS(tail, tempNext);
|
||||
// }
|
||||
}
|
||||
|
||||
@ -1,5 +1,8 @@
|
||||
package com.code.leet.entiy;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class Node {
|
||||
public int val;
|
||||
public Node next;
|
||||
@ -10,4 +13,35 @@ public class Node {
|
||||
this.next = null;
|
||||
this.random = null;
|
||||
}
|
||||
|
||||
public Node(int val, Node random) {
|
||||
this.val = val;
|
||||
this.next = null;
|
||||
this.random = random;
|
||||
}
|
||||
|
||||
public Node setHead(List<Integer> list, List<Integer> index) {
|
||||
Node head = new Node(list.get(0));
|
||||
int i = 1;
|
||||
int size = list.size();
|
||||
Node temp = head;
|
||||
List<Node> nodeList = new ArrayList<>();
|
||||
nodeList.add(head);
|
||||
while (i < size) {
|
||||
temp.next = new Node(list.get(i));
|
||||
nodeList.add(temp.next);
|
||||
i++;
|
||||
temp = temp.next;
|
||||
}
|
||||
i = 0;
|
||||
temp = head;
|
||||
while (i < size) {
|
||||
if (index.get(i) != null) {
|
||||
temp.random = nodeList.get(index.get(i));
|
||||
}
|
||||
i++;
|
||||
temp = temp.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
}
|
||||
|
||||
@ -22,25 +22,25 @@ public class Flatten {
|
||||
/**
|
||||
* 430. 扁平化多级双向链表
|
||||
*/
|
||||
public Node flatten(Node head) {
|
||||
Node temp = head;
|
||||
while (temp != null) {
|
||||
if (temp.child != null) {
|
||||
Node next = temp.next;
|
||||
Node mid = flatten(temp.child);
|
||||
temp.child = null;
|
||||
temp.next = mid;
|
||||
mid.prev = temp;
|
||||
while (temp.next != null) {
|
||||
temp = temp.next;
|
||||
}
|
||||
temp.next = next;
|
||||
if (next != null) {
|
||||
next.prev = temp;
|
||||
}
|
||||
}
|
||||
temp = temp.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
// public Node flatten(Node head) {
|
||||
// Node temp = head;
|
||||
// while (temp != null) {
|
||||
// if (temp.child != null) {
|
||||
// Node next = temp.next;
|
||||
// Node mid = flatten(temp.child);
|
||||
// temp.child = null;
|
||||
// temp.next = mid;
|
||||
// mid.prev = temp;
|
||||
// while (temp.next != null) {
|
||||
// temp = temp.next;
|
||||
// }
|
||||
// temp.next = next;
|
||||
// if (next != null) {
|
||||
// next.prev = temp;
|
||||
// }
|
||||
// }
|
||||
// temp = temp.next;
|
||||
// }
|
||||
// return head;
|
||||
// }
|
||||
}
|
||||
|
||||
100
LeetCode/src/main/java/com/code/leet/week/LcpSolution.java
Normal file
100
LeetCode/src/main/java/com/code/leet/week/LcpSolution.java
Normal file
@ -0,0 +1,100 @@
|
||||
package com.code.leet.week;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* @Author: 轩辕龙儿
|
||||
* @Date: 2021/4/5 15:02
|
||||
* @Description:
|
||||
*/
|
||||
public class LcpSolution {
|
||||
public static void main(String[] args) {
|
||||
LcpSolution solution = new LcpSolution();
|
||||
System.out.println(solution.orchestraLayout(4, 1, 2));
|
||||
|
||||
// int[] nums = {2, 2, 1, 9};
|
||||
// int target = 10;
|
||||
// System.out.println(solution.purchasePlans(nums, target));
|
||||
}
|
||||
|
||||
public int magicTower(int[] nums) {
|
||||
long sum = 1;
|
||||
Stack<Integer> stack1 = new Stack<>();
|
||||
Stack<Integer> stack2 = new Stack<>();
|
||||
List<Integer> list = new ArrayList<>();
|
||||
int size = nums.length;
|
||||
int count = 0;
|
||||
for (int i = 0; i < size; i++) {
|
||||
sum += nums[i];
|
||||
if (nums[i] < 0) {
|
||||
while (!stack1.isEmpty() && stack1.peek() < nums[i]) {
|
||||
stack2.push(stack1.pop());
|
||||
}
|
||||
stack1.push(nums[i]);
|
||||
while (!stack2.isEmpty()) {
|
||||
stack1.push(stack2.pop());
|
||||
}
|
||||
}
|
||||
if (sum <= 0) {
|
||||
sum -= stack1.peek();
|
||||
list.add(stack1.pop());
|
||||
count++;
|
||||
}
|
||||
}
|
||||
size = list.size();
|
||||
for (int i = 0; i < size; i++) {
|
||||
sum += list.get(i);
|
||||
if (sum <= 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
public int orchestraLayout(int num, int xPos, int yPos) {
|
||||
int round = Math.min(Math.min(xPos, num - xPos - 1), Math.min(yPos, num - yPos - 1));
|
||||
int result = 4 * num * round - 4 * round * round;
|
||||
if (xPos == round) {
|
||||
result += yPos - round + 1;
|
||||
} else if (yPos == num - 1 - round) {
|
||||
result += (num - 1 - round * 2) + xPos - round + 1;
|
||||
} else if (xPos == num - 1 - round) {
|
||||
result += (num - 1 - round * 2) * 2 + num - round - yPos;
|
||||
} else {
|
||||
result += (num - 1 - round * 2) * 3 + num - round - xPos;
|
||||
}
|
||||
return result % 9;
|
||||
}
|
||||
|
||||
public int purchasePlans(int[] nums, int target) {
|
||||
long count = 0;
|
||||
List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
|
||||
Collections.sort(numList);
|
||||
Map<Integer, Long> map = new HashMap<>();
|
||||
int temp = -1;
|
||||
for (int num : numList) {
|
||||
if (num >= target) {
|
||||
break;
|
||||
}
|
||||
if (temp == -1) {
|
||||
for (int i = 1; i < num; i++) {
|
||||
map.put(i, Long.parseLong("0"));
|
||||
}
|
||||
map.put(num, Long.parseLong("1"));
|
||||
} else {
|
||||
if (map.containsKey(target - num)) {
|
||||
count += map.get(target - num);
|
||||
} else {
|
||||
count += map.get(temp);
|
||||
}
|
||||
for (int i = temp + 1; i < num; i++) {
|
||||
map.put(i, map.get(temp));
|
||||
}
|
||||
map.put(num, map.get(temp) + 1);
|
||||
}
|
||||
temp = num;
|
||||
}
|
||||
return (int) (count % (Math.pow(10, 9) + 7));
|
||||
}
|
||||
}
|
||||
101
LeetCode/src/main/java/com/code/leet/week/Solution235.java
Normal file
101
LeetCode/src/main/java/com/code/leet/week/Solution235.java
Normal file
@ -0,0 +1,101 @@
|
||||
package com.code.leet.week;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* @Author: 轩辕龙儿
|
||||
* @Date: 2021/4/4 10:33
|
||||
* @Description:
|
||||
*/
|
||||
public class Solution235 {
|
||||
public String truncateSentence(String s, int k) {
|
||||
String[] strings = s.split(" ");
|
||||
if (strings.length == 0) {
|
||||
return s;
|
||||
}
|
||||
StringBuilder sBuilder = new StringBuilder();
|
||||
for (int i = 0; i < k; i++) {
|
||||
sBuilder.append(strings[i]).append(" ");
|
||||
}
|
||||
s = sBuilder.toString();
|
||||
s = s.substring(0, s.length() - 1);
|
||||
return s;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
Solution235 solution235 = new Solution235();
|
||||
|
||||
int[][] logs = {{0, 5}, {1, 2}, {0, 2}, {0, 5}, {1, 3}};
|
||||
int k = 5;
|
||||
solution235.findingUsersActiveMinutes(logs, k);
|
||||
}
|
||||
|
||||
public int[] findingUsersActiveMinutes(int[][] logs, int k) {
|
||||
Map<Integer, List<Integer>> map = new HashMap<>();
|
||||
int min = Integer.MAX_VALUE;
|
||||
for (int i = 0; i < logs.length; i++) {
|
||||
List<Integer> temp;
|
||||
min = Math.min(min, logs[i][0]);
|
||||
if (map.containsKey(logs[i][0])) {
|
||||
temp = map.get(logs[i][0]);
|
||||
if (!temp.contains(logs[i][1])) {
|
||||
temp.add(logs[i][1]);
|
||||
}
|
||||
map.put(logs[i][0], temp);
|
||||
} else {
|
||||
temp = new ArrayList<>();
|
||||
temp.add(logs[i][1]);
|
||||
map.put(logs[i][0], temp);
|
||||
}
|
||||
}
|
||||
int[] result = new int[k];
|
||||
for (int i = 0; i < k; i++) {
|
||||
result[i] = 0;
|
||||
}
|
||||
for (int key : map.keySet()) {
|
||||
int index = map.get(key).size();
|
||||
result[index - 1] = result[index - 1] + 1;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public int minAbsoluteSumDiff(int[] nums1, int[] nums2) {
|
||||
long result = 0;
|
||||
Stack<int[]> stack = new Stack<>();
|
||||
Stack<int[]> tempStack = new Stack<>();
|
||||
int size = nums1.length;
|
||||
for (int i = 0; i < size; i++) {
|
||||
int temp = Math.abs(nums1[i] - nums2[i]);
|
||||
result += temp;
|
||||
if (!tempStack.isEmpty()) {
|
||||
while (temp > tempStack.peek()[1]) {
|
||||
stack.push(tempStack.pop());
|
||||
}
|
||||
}
|
||||
while (temp < stack.peek()[1]) {
|
||||
tempStack.push(stack.pop());
|
||||
}
|
||||
stack.push(new int[]{i, temp});
|
||||
}
|
||||
while (!tempStack.isEmpty()) {
|
||||
stack.push(tempStack.pop());
|
||||
}
|
||||
Set<Integer> set = Arrays.stream(nums1).boxed().collect(Collectors.toSet());
|
||||
int max = -1;
|
||||
while (!stack.isEmpty()) {
|
||||
int[] arr = stack.pop();
|
||||
int i;
|
||||
for (i = 0; i < arr[1]; i++) {
|
||||
if (set.contains(nums2[arr[0]] - i) || set.contains(nums2[arr[0]] + i)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(nums2[arr[0]] - i>stack.peek()[1]){
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return (int) ((result - max) % (Math.pow(10, 9) + 7));
|
||||
}
|
||||
}
|
||||
96
LeetCode/src/main/java/com/code/leet/week/Solution49.java
Normal file
96
LeetCode/src/main/java/com/code/leet/week/Solution49.java
Normal file
@ -0,0 +1,96 @@
|
||||
package com.code.leet.week;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* @Author: 轩辕龙儿
|
||||
* @Date: 2021/4/3 22:33
|
||||
* @Description:
|
||||
*/
|
||||
public class Solution49 {
|
||||
public static void main(String[] args) {
|
||||
Solution49 solution49 = new Solution49();
|
||||
// System.out.println(solution.squareIsWhite("a1"));
|
||||
}
|
||||
|
||||
public boolean squareIsWhite(String coordinates) {
|
||||
char[] chars = coordinates.toCharArray();
|
||||
if ((chars[0] - chars[1]) % 2 == 0) {
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean areSentencesSimilar(String sentence1, String sentence2) {
|
||||
sentence1 += " ";
|
||||
sentence2 += " ";
|
||||
String[] strs1 = sentence1.split(" ");
|
||||
String[] strs2 = sentence2.split(" ");
|
||||
int size1 = strs1.length;
|
||||
int size2 = strs2.length;
|
||||
if (size1 == size2) {
|
||||
return sentence1.equals(sentence2);
|
||||
} else if (size1 > size2) {
|
||||
return isTrue(strs1, strs2);
|
||||
} else {
|
||||
return isTrue(strs2, strs1);
|
||||
}
|
||||
}
|
||||
private boolean isTrue(String[] strs1, String[] strs2) {
|
||||
int size1 = strs1.length;
|
||||
int size2 = strs2.length;
|
||||
int index = 0;
|
||||
while (index < size2 && strs2[index].equals(strs1[index])) {
|
||||
index++;
|
||||
}
|
||||
if (index == size2) {
|
||||
return true;
|
||||
}
|
||||
for (int i = 1; i <= size2 - index; i++) {
|
||||
if (!strs2[size2 - i].equals(strs1[size1 - i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public int countNicePairs(int[] nums) {
|
||||
Map<Integer, Long> map = new HashMap<>();
|
||||
for (int num : nums) {
|
||||
int key = num - revert(num);
|
||||
if (map.containsKey(key)) {
|
||||
map.put(key, map.get(key) + 1);
|
||||
} else {
|
||||
map.put(key, Long.parseLong("1"));
|
||||
}
|
||||
}
|
||||
long count = 0;
|
||||
for (int key : map.keySet()) {
|
||||
long value = map.get(key);
|
||||
if (value > 1) {
|
||||
count += value * (value - 1) / 2;
|
||||
}
|
||||
}
|
||||
return (int)(count % (Math.pow(10, 9) + 7));
|
||||
}
|
||||
private int revert(int num) {
|
||||
String str = "" + num;
|
||||
str = new StringBuilder(str).reverse().toString();
|
||||
return Integer.parseInt(str);
|
||||
}
|
||||
|
||||
public int maxHappyGroups(int batchSize, int[] groups) {
|
||||
Map<Integer, List<Integer>> map = new HashMap<>();
|
||||
int size = groups.length;
|
||||
int count = 0;
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (groups[i] % batchSize == 0) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
package com.code.leet.weekold;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Created with IntelliJ IDEA.
|
||||
* User: 轩辕龙儿
|
||||
* Date: 2021/3/20
|
||||
* Time: 22:42
|
||||
* Description: No Description
|
||||
*/
|
||||
public class AuthenticationManager {
|
||||
Map<String, Integer> map = new HashMap<>();
|
||||
int timeToLive;
|
||||
|
||||
public AuthenticationManager(int timeToLive) {
|
||||
this.timeToLive = timeToLive;
|
||||
}
|
||||
|
||||
public void generate(String tokenId, int currentTime) {
|
||||
map.put(tokenId, currentTime + timeToLive);
|
||||
}
|
||||
|
||||
public void renew(String tokenId, int currentTime) {
|
||||
if (map.containsKey(tokenId) && currentTime < map.get(tokenId)) {
|
||||
map.put(tokenId, currentTime + timeToLive);
|
||||
}
|
||||
}
|
||||
|
||||
public int countUnexpiredTokens(int currentTime) {
|
||||
int num = 0;
|
||||
for (String key:map.keySet()) {
|
||||
if(map.get(key)>currentTime){
|
||||
num++;
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
}
|
||||
155
LeetCode/src/main/java/com/code/leet/weekold/Solution.java
Normal file
155
LeetCode/src/main/java/com/code/leet/weekold/Solution.java
Normal file
@ -0,0 +1,155 @@
|
||||
package com.code.leet.weekold;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Created with IntelliJ IDEA.
|
||||
* User: 轩辕龙儿
|
||||
* Date: 2021/3/20
|
||||
* Time: 22:31
|
||||
* Description: No Description
|
||||
*/
|
||||
public class Solution {
|
||||
public int secondHighest(String s) {
|
||||
int max = -1;
|
||||
int second = -2;
|
||||
int size = s.length();
|
||||
for (int i = 0; i < size; i++) {
|
||||
String temp;
|
||||
temp = i + 1 < size ? s.substring(i, i + 1) : s.substring(i);
|
||||
if (temp.matches("[0-9]+")) {
|
||||
int cur = Integer.parseInt(temp);
|
||||
if (cur > max) {
|
||||
second = max;
|
||||
max = cur;
|
||||
} else if (cur > second && cur != max) {
|
||||
second = cur;
|
||||
}
|
||||
}
|
||||
}
|
||||
return second > 0 ? second : -1;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
// getMaximumConsecutive(new int[]{1,1,1,4});
|
||||
int[][] orders = new int[][]{{23,8,0},{28,29,1},{11,30,1},{30,25,0},{26,9,0},{3,21,0},{28,19,1},{19,30,0},{20,9,1},{17,6,0}};
|
||||
Solution solution = new Solution();
|
||||
solution.getNumberOfBacklogOrders(orders);
|
||||
}
|
||||
|
||||
// public static int getMaximumConsecutive(int[] coins) {
|
||||
// int size = coins.length;
|
||||
// for (int i = 0; i < size; i++) {
|
||||
// for (int j = i + 1; j < size; j++) {
|
||||
// if (coins[j] < coins[i]) {
|
||||
// int temp = coins[j];
|
||||
// coins[j] = coins[i];
|
||||
// coins[i] = temp;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// int num = 1;
|
||||
// while (isTrue(coins, num)) {
|
||||
// num++;
|
||||
// }
|
||||
// return num - 1;
|
||||
// }
|
||||
//
|
||||
// private static boolean isTrue(int[] arr, int num) {
|
||||
// if (num == 0) {
|
||||
// return true;
|
||||
// }
|
||||
// int size = arr.length;
|
||||
// int index = -1;
|
||||
// for (int i = 0; i < size; i++) {
|
||||
// if (arr[i] > num) {
|
||||
// index = i;
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
// if (index == -1) {
|
||||
// return false;
|
||||
// }
|
||||
// for (int i = 0; i < index; i++) {
|
||||
// int[] newArr = new int[index - i - 1];
|
||||
// for (int j = i + 1; j < index; j++) {
|
||||
// newArr[j] = arr[j];
|
||||
// }
|
||||
// if (isTrue(newArr, num - arr[i])) {
|
||||
// return true;
|
||||
// }
|
||||
// }
|
||||
// return false;
|
||||
// }
|
||||
|
||||
public int maxAscendingSum(int[] nums) {
|
||||
int max = 0;
|
||||
int size = nums.length;
|
||||
int sum = nums[0];
|
||||
for (int i = 1; i < size; i++) {
|
||||
if (nums[i] > nums[i - 1]) {
|
||||
sum += nums[i];
|
||||
} else {
|
||||
max = Math.max(sum, max);
|
||||
sum = nums[i];
|
||||
}
|
||||
}
|
||||
max = Math.max(sum, max);
|
||||
return max;
|
||||
}
|
||||
|
||||
public int getNumberOfBacklogOrders(int[][] orders) {
|
||||
List<int[]> orderList = new ArrayList<>();
|
||||
int length = orders.length;
|
||||
long num = 0;
|
||||
for (int i = 0; i < length; i++) {
|
||||
int size = orderList.size();
|
||||
for (int j = 0; j < size; j++) {
|
||||
if (orders[i][2] - orderList.get(j)[2] != 0) {
|
||||
boolean buy = orders[i][2] == 0 && orderList.get(j)[0] <= orders[i][0];
|
||||
boolean sell = orders[i][2] == 1 && orderList.get(j)[0] >= orders[i][0];
|
||||
if (buy || sell) {
|
||||
if (orderList.get(j)[1] < orders[i][1]) {
|
||||
orders[i][1] -= orderList.get(j)[1];
|
||||
num -= orderList.get(j)[1];
|
||||
orderList.remove(orderList.get(j));
|
||||
size = orderList.size();
|
||||
j--;
|
||||
} else if (orderList.get(j)[1] > orders[i][1]) {
|
||||
num -= orders[i][1];
|
||||
orderList.get(j)[1] -= orders[i][1];
|
||||
orders[i][1] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
size = orderList.size();
|
||||
if (orders[i][1] > 0) {
|
||||
boolean isTrue = true;
|
||||
for (int j = 0; j < size; j++) {
|
||||
if (orders[i][2] == orderList.get(j)[2]) {
|
||||
if (orders[i][2] == 0 && orders[i][0] > orderList.get(j)[0]) {
|
||||
num += orders[i][1];
|
||||
orderList.add(j, orders[i]);
|
||||
isTrue = false;
|
||||
break;
|
||||
}
|
||||
if (orders[i][2] == 1 && orders[i][0] < orderList.get(j)[0]) {
|
||||
num += orders[i][1];
|
||||
orderList.add(j, orders[i]);
|
||||
isTrue = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isTrue) {
|
||||
num += orders[i][1];
|
||||
orderList.add(orders[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return (int)(num % (Math.pow(10, 9) + 7));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user