huangge1199/leet-code
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: huangge1199:1f7318460c3f2046a7df18950eb64ed3adb312bf
Branches Tags
huangge1199:master
..
compare: huangge1199:f6930f00314c0873f4cd212d9e2d7eb7b893bbfa
Branches Tags
huangge1199:master

No commits in common. "1f7318460c3f2046a7df18950eb64ed3adb312bf" and "f6930f00314c0873f4cd212d9e2d7eb7b893bbfa" have entirely different histories.
1f7318460c ... f6930f0031

14 changed files with 0 additions and 1046 deletions
Show Stats Expand all files Collapse all files

59
src/main/java/blog/ImageGenerator.java
View File

@ -1,59 +0,0 @@
package blog;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
/**
* @author hyy
* @Classname ImageGenerator
* @Description TODO
* @Date 2023/9/11 9:59:25
*/
public class ImageGenerator {
public static void main(String[] args) {
String text = "你好，世界！"; // 要显示的文字
String backgroundImageFilePath = "src/main/java/blog/bg.png"; // 默认背景图片的文件路径
String outputFilePath = "src/main/java/blog/test.png"; // 生成的图片的输出路径
ImageGenerator.generateImage(text, backgroundImageFilePath, outputFilePath);
}
public static void generateImage(String text, String backgroundImageFilePath, String outputFilePath) {
try {
// 读取背景图片
BufferedImage backgroundImage = ImageIO.read(new File(backgroundImageFilePath));
// 创建一个Graphics2D对象，用于在背景图片上绘制文字
Graphics2D g2d = backgroundImage.createGraphics();
// 设置字体和颜色
Font font = new Font("宋体", Font.PLAIN, 36).deriveFont(Font.PLAIN);
g2d.setFont(font);
g2d.setColor(Color.BLACK); // 设置文字颜色
// 获取文字的尺寸
FontMetrics fm = g2d.getFontMetrics();
int textWidth = fm.stringWidth(text);
int textHeight = fm.getHeight();
// 计算文字的位置使其居中显示
int x = (backgroundImage.getWidth() - textWidth) / 2;
int y = (backgroundImage.getHeight() + textHeight) / 2;
// 在指定位置绘制文字
g2d.drawString(text, x, y);
// 释放资源
g2d.dispose();
// 保存生成的图片
ImageIO.write(backgroundImage, "png", new File(outputFilePath));
System.out.println("图片生成成功！");
} catch (Exception e) {
e.printStackTrace();
}
}
}

BIN
src/main/java/blog/bg.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 471 KiB

BIN
src/main/java/blog/test.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 503 KiB

97
src/main/java/contest/y2023/BW109.java
View File

@ -1,97 +0,0 @@
package contest.y2023;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class BW109 {
public static void main(String[] args) {
BW109 solution = new BW109();
// int[] nums = new int[]{2,3,6,1,9,2};
// int x = 5;
// System.out.println(solution.maxScore(nums,x));
System.out.println(solution.numberOfWays(4, 1));
}
public int numberOfWays(int n, int x) {
List<Integer> list = new ArrayList<>();
for (int i = 1; i <= n; i++) {
int sum = (int) Math.pow(i, x);
if (sum <= n) {
list.add(sum);
} else {
break;
}
}
int[] dp = new int[n + 1];
dp[0] = 1;
for (int num : list) {
for (int i = n; i >= num; i--) {
dp[i] = (dp[i] + dp[i - num]) % 1000000007;
}
}
return dp[n];
}
public long maxScore(int[] nums, int x) {
long max = nums[0];
long[] sum = new long[nums.length];
Arrays.fill(sum, Integer.MIN_VALUE);
sum[0] = nums[0];
int n1 = -1;
int n2 = -1;
if (nums[0] % 2 == 0) {
n2 = 0;
} else {
n1 = 0;
}
for (int i = 1; i < nums.length; i++) {
if (n1 >= 0) {
sum[i] = Math.max(sum[i], (nums[i] % 2 == 0 ? sum[n1] + nums[i] - x : sum[n1] + nums[i]));
}
if (n2 >= 0) {
sum[i] = Math.max(sum[i], (nums[i] % 2 == 0 ? sum[n2] + nums[i] : sum[n2] + nums[i] - x));
}
if (nums[i] % 2 == 0) {
n2 = i;
} else {
n1 = i;
}
max = Math.max(max, sum[i]);
}
return max;
}
public String sortVowels(String s) {
String str = "aeiouAEIOU";
List<String> list = new ArrayList<>();
for (int i = 0; i < s.length(); i++) {
if (str.contains(String.valueOf(s.charAt(i)))) {
list.add(String.valueOf(s.charAt(i)));
}
}
Collections.sort(list);
StringBuilder nstr = new StringBuilder();
int index = 0;
for (int i = 0; i < s.length(); i++) {
if (str.contains(String.valueOf(s.charAt(i)))) {
nstr.append(list.get(index));
index++;
} else {
nstr.append(String.valueOf(s.charAt(i)));
}
}
return nstr.toString();
}
public boolean isGood(int[] nums) {
Arrays.sort(nums);
for (int i = 0; i < nums.length - 1; i++) {
if (i + 1 != nums[i]) {
return false;
}
}
return nums[nums.length - 1] == nums.length - 1;
}
}

114
src/main/java/contest/y2023/BW111.java
View File

@ -1,114 +0,0 @@
package contest.y2023;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class BW111 {
public static void main(String[] args) {
BW111 so = new BW111();
List<Integer> nums = Arrays.asList(2, 1, 3, 2, 1);
so.minimumOperations(nums);
}
public int numberOfBeautifulIntegers(int low, int high, int k) {
int cnt = 0;
List<Integer> list = Arrays.asList(10, 1001, 100011, 10000111);
if (low <= 10 && high >= 10) {
int num = 10;
int add = k % 2 == 0 ? k : 2 * k;
while (num % k != 0 && num <= high) {
num += 2;
}
if (num > high) {
return cnt;
}
cnt += (Math.min(99, high) - num) / add + 1;
}
if (low <= 1001 && high >= 1001) {
int num = 1001;
int add = k % 2 == 0 ? k : 2 * k;
while (num % k != 0 && num <= high) {
num += 2;
}
if (num > high) {
return cnt;
}
cnt += (Math.min(9999, high) - num) / add + 1;
}
if (low <= 100011 && high >= 100011) {
int num = 100011;
int add = k % 2 == 0 ? k : 2 * k;
while (num % k != 0 && num <= high) {
num += 2;
}
if (num > high) {
return cnt;
}
cnt += (Math.min(999999, high) - num) / add + 1;
}
if (low <= 10000111 && high >= 10000111) {
int num = 10000111;
int add = k % 2 == 0 ? k : 2 * k;
while (num % k != 0 && num <= high) {
num += 2;
}
if (num > high) {
return cnt;
}
cnt += (Math.min(99999999, high) - num) / add + 1;
}
return cnt;
}
public int minimumOperations(List<Integer> nums) {
int x = 0, y = 0, z = 0;
for (int num : nums) {
if (num == 1) {
y++;
z++;
} else if (num == 2) {
z++;
y = Math.min(x, y);
x++;
} else {
z = Math.min(x, Math.min(y, z));
x++;
y++;
}
}
return Math.min(x, Math.min(y, z));
}
public boolean canMakeSubsequence(String str1, String str2) {
if (str2.length() > str1.length()) {
return false;
}
int index = 0;
for (char ch : str1.toCharArray()) {
if (index == str2.length()) {
break;
}
if (ch == str2.charAt(index) || (ch == 'z' ? 'a' : ch + 1) == str2.charAt(index)) {
index++;
}
}
return index == str2.length();
}
public int countPairs(List<Integer> nums, int target) {
int cnt = 0;
Collections.sort(nums);
for (int i = 0; i < nums.size(); i++) {
for (int j = i + 1; j < nums.size(); j++) {
if (nums.get(i) + nums.get(j) < target) {
cnt++;
} else {
break;
}
}
}
return cnt;
}
}

96
src/main/java/contest/y2023/BW112.java
View File

@ -1,96 +0,0 @@
package contest.y2023;
import java.util.*;
public class BW112 {
public static void main(String[] args) {
BW112 so = new BW112();
// String s1 = "abe";
// String s2 = "bea";
// so.checkStrings(s1, s2);
List<Integer> nums = Arrays.asList(2, 6, 7, 3, 1, 7);
int m = 3;
int k = 4;
so.maxSum(nums, m, k);
}
public long maxSum(List<Integer> nums, int m, int k) {
long max = 0;
Set<Integer> set = new HashSet<>();
List<Integer> list = new ArrayList<>();
long sum = 0;
for (int i = 0; i < nums.size(); i++) {
sum += nums.get(i);
set.add(nums.get(i));
list.add(nums.get(i));
if (i < k - 1) {
continue;
} else if (i == k - 1) {
if (set.size() >= m) {
max = Math.max(max, sum);
}
} else {
list.remove(nums.get(i - k));
if (!list.contains(nums.get(i - k))) {
set.remove(nums.get(i - k));
}
sum -= nums.get(i - k);
if (set.size() >= m) {
max = Math.max(max, sum);
}
}
}
return max;
}
public boolean checkStrings(String s1, String s2) {
char[] ch1 = s1.toCharArray();
char[] ch2 = s2.toCharArray();
int size = s1.length();
char[] ch10 = new char[size / 2 + (size % 2)];
char[] ch20 = new char[size / 2 + (size % 2)];
char[] ch11 = new char[size / 2];
char[] ch21 = new char[size / 2];
for (int i = 0; i < size / 2 + (size % 2); i++) {
ch10[i] = ch1[i * 2];
ch20[i] = ch2[i * 2];
if (i < size / 2) {
ch11[i] = ch1[i * 2 + 1];
ch21[i] = ch2[i * 2 + 1];
}
}
Arrays.sort(ch10);
Arrays.sort(ch11);
Arrays.sort(ch20);
Arrays.sort(ch21);
for (int i = 0; i < size / 2 + (size % 2); i++) {
if (ch10[i] != ch20[i]) {
return false;
}
if (i < size / 2) {
if (ch11[i] != ch21[i]) {
return false;
}
}
}
return true;
}
public boolean canBeEqual(String s1, String s2) {
char[] ch1 = s1.toCharArray();
char[] ch2 = s2.toCharArray();
for (int i = 0; i < 4; i++) {
if (ch1[i] != ch2[i]) {
if (i > 1) {
return false;
} else {
if (ch1[i + 2] != ch2[i]) {
return false;
}
ch1[i + 2] = ch1[i];
}
}
}
return true;
}
}

123
src/main/java/contest/y2023/Week354.java
View File

@ -1,123 +0,0 @@
package contest.y2023;
import java.lang.reflect.Array;
import java.util.*;
public class Week354 {
public static void main(String[] args) {
String word = "cbaaaabc";
List<String> forbidden = Arrays.asList("aaa", "cb");
System.out.println(longestValidSubstring(word, forbidden));
}
static List<String> strs = new ArrayList<>();
public static int longestValidSubstring(String word, List<String> forbidden) {
Comparator<String> lengthComparator = Comparator.comparingInt(String::length);
forbidden.sort(lengthComparator);
for (int i = 0; i < forbidden.size(); i++) {
for (int j = i + 1; j < forbidden.size(); j++) {
if(forbidden.get(j).contains(forbidden.get(i))){
forbidden.remove(forbidden.get(j));
}
}
}
int max = getMax(word, forbidden);
strs.sort(lengthComparator);
while (strs.size() > 0 && strs.get(strs.size() - 1).length() > max) {
String str = strs.get(strs.size() - 1);
strs.remove(str);
max = Math.max(max, getMax(str, forbidden));
strs.sort(lengthComparator);
}
return max;
}
private static int getMax(String word, List<String> forbidden) {
for (String str : forbidden) {
if (word.contains(str)) {
int index = word.indexOf(str);
if (!strs.contains(word.substring(0, index))) {
strs.add(word.substring(0, index));
}
if (!strs.contains(word.substring(index + 1))) {
strs.add(word.substring(index + 1));
}
String substring = word.substring(0, index + str.length() - 1);
if (!strs.contains(substring)) {
strs.add(substring);
}
String substring1 = word.substring(index + str.length());
if (!strs.contains(substring1)) {
strs.add(substring1);
}
return 0;
}
}
return word.length();
}
public int minimumIndex(List<Integer> nums) {
int[] arr = new int[nums.size()];
for (int i = 0; i < nums.size(); i++) {
arr[i] = nums.get(i);
}
Arrays.sort(arr);
int cnt = 1;
int num = arr[0];
int max = 0;
for (int i = 1; i < nums.size(); i++) {
if (arr[i] == arr[i - 1]) {
cnt++;
} else {
if (max < cnt) {
max = cnt;
num = arr[i - 1];
}
cnt = 1;
}
}
if (max < cnt) {
max = cnt;
num = arr[nums.size() - 1];
}
if (cnt * 2 == nums.size() + 1) {
return -1;
}
cnt = 0;
for (int i = 0; i < nums.size(); i++) {
if (nums.get(i) == num) {
cnt++;
if (cnt * 2 > i + 1 && (max - cnt) * 2 > nums.size() - i - 1) {
return i;
}
}
}
return -1;
}
public int maximumBeauty(int[] nums, int k) {
Arrays.sort(nums);
int max = 0;
int index = 0;
for (int i = 1; i < nums.length; i++) {
while (nums[i] - nums[index] > k * 2) {
max = Math.max(max, i - index);
index++;
}
}
return Math.max(max, nums.length - index);
}
public int sumOfSquares(int[] nums) {
int sum = 0;
int size = nums.length;
for (int i = 0; i < size; i++) {
if (size % (i + 1) == 0) {
sum += nums[i] * nums[i];
}
}
return sum;
}
}

66
src/main/java/contest/y2023/Week355.java
View File

@ -1,66 +0,0 @@
package contest.y2023;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Week355 {
public static void main(String[] args) {
Week355 so = new Week355();
// List<String> words = Arrays.asList("one.two.three","four.five","six");
// char separator = '.';
// System.out.println(so.splitWordsBySeparator(words,separator));
List<Integer> usageLimits = Arrays.asList(2, 2, 2);
System.out.println(so.maxIncreasingGroups(usageLimits));
}
public int maxIncreasingGroups(List<Integer> usageLimits) {
Collections.sort(usageLimits);
int size = usageLimits.size();
int left = 1;
int right = size;
while (left < right) {
int mid = (left + right + 1) / 2;
int cnt = 0;
for (int i = 1; i <= size; i++) {
cnt += Math.max(0, mid - i);
cnt -= Math.min(cnt, usageLimits.get(size - i - 1));
}
if (cnt == 0) {
left = mid;
} else {
right = mid - 1;
}
}
return left;
}
public long maxArrayValue(int[] nums) {
long max = nums[nums.length - 1];
long cur = nums[nums.length - 1];
for (int i = nums.length - 2; i >= 0; i--) {
if (nums[i] <= cur) {
cur += nums[i];
} else {
max = Math.max(max, cur);
cur = nums[i];
}
}
return Math.max(max, cur);
}
public List<String> splitWordsBySeparator(List<String> words, char separator) {
List<String> list = new ArrayList<>();
for (String word : words) {
String[] strs = word.split("\\" + separator);
for (String str : strs) {
if (str.length() > 0) {
list.add(str);
}
}
}
return list;
}
}

109
src/main/java/contest/y2023/Week356.java
View File

@ -1,109 +0,0 @@
package contest.y2023;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Week356 {
public static void main(String[] args) {
Week356 so = new Week356();
String a = "ab", b = "a", c = "c";
so.minimumString(a, b, c);
}
public String minimumString(String a, String b, String c) {
String str = getStr(getStr(a, b), c);
List<String> list = new ArrayList<>();
list.add(getStr(a, getStr(b, c)));
list.add(getStr(getStr(a, c), b));
list.add(getStr(a, getStr(c, b)));
list.add(getStr(getStr(b, a), c));
list.add(getStr(b, getStr(a, c)));
list.add(getStr(getStr(b, c), a));
list.add(getStr(b, getStr(c, a)));
list.add(getStr(getStr(c, a), b));
list.add(getStr(c, getStr(a, b)));
list.add(getStr(getStr(c, b), a));
list.add(getStr(c, getStr(b, a)));
for (String tmp : list) {
tmp = getStr(a, getStr(b, c));
if (str.length() < tmp.length() || (str.length() == tmp.length() && isBef(tmp, str))) {
str = tmp;
}
}
return str;
}
private boolean isBef(String str1, String str2) {
char[] ch1 = str1.toCharArray();
char[] ch2 = str2.toCharArray();
for (int i = 0; i < ch1.length; i++) {
if (ch1[i] < ch2[i]) {
return true;
} else if (ch1[i] > ch2[i]) {
return false;
}
}
return true;
}
private String getStr(String str1, String str2) {
if (str1.contains(str2)) {
return str1;
}
for (int i = str2.length(); i >= 1; i--) {
if (str1.endsWith(str2.substring(0, i))) {
return str1 + str2.substring(i);
}
}
return str1 + str2;
}
public int countCompleteSubarrays(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
for (int num : nums) {
map.put(num, map.getOrDefault(num, 0) + 1);
}
int size = map.size();
int res = 0;
for (int i = 0; i < nums.length; i++) {
int cnt = 1;
map = new HashMap<>();
map.put(nums[i], 1);
if (cnt == size) {
res++;
}
for (int j = i + 1; j < nums.length; j++) {
if (map.containsKey(nums[j])) {
map.put(nums[j], map.get(nums[j]) + 1);
} else {
map.put(nums[j], 1);
cnt++;
}
if (cnt == size) {
res += nums.length - j;
break;
}
if (cnt + nums.length - 1 - j < size) {
break;
}
}
if (nums.length - 1 - i < size) {
break;
}
}
return res;
}
public int numberOfEmployeesWhoMetTarget(int[] hours, int target) {
int cnt = 0;
for (int hour : hours) {
if (hour >= target) {
cnt++;
}
}
return cnt;
}
}

88
src/main/java/contest/y2023/Week358.java
View File

@ -1,88 +0,0 @@
package contest.y2023;
import com.code.leet.entiy.ListNode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Week358 {
public static void main(String[] args) {
Week358 so = new Week358();
// ListNode head = new ListNode(Arrays.asList(9,9,9));
// so.doubleIt(head);
}
public int minAbsoluteDifference(List<Integer> nums, int x) {
int min = Integer.MAX_VALUE;
for (int i = 0; i < nums.size(); i++) {
for (int j = i + x; j < nums.size(); j++) {
min = Math.min(min, Math.abs(nums.get(i) - nums.get(j)));
}
}
return min;
}
public ListNode doubleIt(ListNode head) {
List<Integer> list = new ArrayList<>();
ListNode curr = head;
while (curr != null) {
list.add(curr.val);
curr = curr.next;
}
boolean bl = false;
for (int i = list.size() - 1; i >= 0; i--) {
int num = list.get(i);
num *= 2;
if (bl) {
num += 1;
}
if (num >= 10) {
list.set(i, num -= 10);
bl = true;
} else {
list.set(i, num);
bl = false;
}
}
if (bl) {
list.add(0, 1);
}
head = new ListNode(list.get(0));
curr = head;
for (int i = 1; i < list.size(); i++) {
curr.next = new ListNode(list.get(i));
curr = curr.next;
}
return head;
}
public int maxSum(int[] nums) {
int maxSum = -1;
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
// 获取两个数数位上的最大数字
int maxDigitI = getMaxDigit(nums[i]);
int maxDigitJ = getMaxDigit(nums[j]);
// 如果最大数字相等，则更新最大和
if (maxDigitI == maxDigitJ) {
maxSum = Math.max(maxSum, nums[i] + nums[j]);
}
}
}
return maxSum;
}
public int getMaxDigit(int num) {
int maxDigit = 0;
while (num > 0) {
int digit = num % 10;
maxDigit = Math.max(maxDigit, digit);
num /= 10;
}
return maxDigit;
}
}

98
src/main/java/leetcode/editor/cn/AddingTwoNegabinaryNumbers.java
View File

@ -1,98 +0,0 @@
//<p>给出基数为 <strong>-2</strong>&nbsp;的两个数&nbsp;<code>arr1</code> 和&nbsp;<code>arr2</code>，返回两数相加的结果。</p>
//
//<p>数字以&nbsp;<em>数组形式</em><strong>&nbsp;</strong>给出：数组由若干 0 和 1 组成，按最高有效位到最低有效位的顺序排列。例如，<code>arr&nbsp;= [1,1,0,1]</code>&nbsp;表示数字&nbsp;<code>(-2)^3&nbsp;+ (-2)^2 + (-2)^0 = -3</code>。<em>数组形式</em>&nbsp;中的数字 <code>arr</code> 也同样不含前导零：即&nbsp;<code>arr == [0]</code>&nbsp;或&nbsp;<code>arr[0] == 1</code>。</p>
//
//<p>返回相同表示形式的 <code>arr1</code> 和 <code>arr2</code> 相加的结果。两数的表示形式为：不含前导零、由若干 0 和 1 组成的数组。</p>
//
//<p>&nbsp;</p>
//
//<p><strong>示例 1：</strong></p>
//
//<pre>
//<strong>输入：</strong>arr1 = [1,1,1,1,1], arr2 = [1,0,1]
//<strong>输出：</strong>[1,0,0,0,0]
//<strong>解释：</strong>arr1 表示 11，arr2 表示 5，输出表示 16 。
//</pre>
//
//<p>
// <meta charset="UTF-8" /></p>
//
//<p><strong>示例 2：</strong></p>
//
//<pre>
//<strong>输入：</strong>arr1 = [0], arr2 = [0]
//<strong>输出：</strong>[0]
//</pre>
//
//<p><strong>示例 3：</strong></p>
//
//<pre>
//<strong>输入：</strong>arr1 = [0], arr2 = [1]
//<strong>输出：</strong>[1]
//</pre>
//
//<p>&nbsp;</p>
//
//<p><strong>提示：</strong></p>
//<meta charset="UTF-8" />
//
//<ul>
// <li><code>1 &lt;= arr1.length,&nbsp;arr2.length &lt;= 1000</code></li>
// <li><code>arr1[i]</code>&nbsp;和&nbsp;<code>arr2[i]</code>&nbsp;都是&nbsp;<code>0</code>&nbsp;或&nbsp;<code>1</code></li>
// <li><code>arr1</code>&nbsp;和&nbsp;<code>arr2</code>&nbsp;都没有前导0</li>
//</ul>
//
//<div><div>Related Topics</div><div><li>数组</li><li>数学</li></div></div><br><div><li>👍 80</li><li>👎 0</li></div>
package leetcode.editor.cn;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
// 1073:负二进制数相加
public class AddingTwoNegabinaryNumbers {
public static void main(String[] args) {
Solution solution = new AddingTwoNegabinaryNumbers().new Solution();
// TO TEST
}
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public int[] addNegabinary(int[] arr1, int[] arr2) {
int i = arr1.length - 1, j = arr2.length - 1;
int carry = 0;
List<Integer> ans = new ArrayList<>();
while (i >= 0 || j >= 0 || carry != 0) {
int x = carry;
if (i >= 0) {
x += arr1[i];
}
if (j >= 0) {
x += arr2[j];
}
if (x >= 2) {
ans.add(x - 2);
carry = -1;
} else if (x >= 0) {
ans.add(x);
carry = 0;
} else {
ans.add(1);
carry = 1;
}
--i;
--j;
}
while (ans.size() > 1 && ans.get(ans.size() - 1) == 0) {
ans.remove(ans.size() - 1);
}
int[] arr = ans.stream().mapToInt(Integer::intValue).toArray();
for (i = 0, j = ans.size() - 1; j >= 0; i++, j--) {
arr[i] = ans.get(j);
}
return arr;
}
}
//leetcode submit region end(Prohibit modification and deletion)
}

103
src/main/java/leetcode/editor/cn/LoudAndRich.java
View File

@ -1,103 +0,0 @@
////有一组 n 个人作为实验对象，从 0 到 n - 1 编号，其中每个人都有不同数目的钱，以及不同程度的安静值（quietness）。为了方便起见，我们将编号
//为 x 的人简称为 "person x "。
//
// 给你一个数组 richer ，其中 richer[i] = [ai, bi] 表示 person ai 比 person bi 更有钱。另给你一个整数数组
// quiet ，其中 quiet[i] 是 person i 的安静值。richer 中所给出的数据 逻辑自洽（也就是说，在 person x 比
//person y 更有钱的同时，不会出现 person y 比 person x 更有钱的情况 ）。
//
// 现在，返回一个整数数组 answer 作为答案，其中 answer[x] = y 的前提是，在所有拥有的钱肯定不少于 person x 的人中，
//person y 是最安静的人（也就是安静值 quiet[y] 最小的人）。
//
//
//
// 示例 1：
//
//
//输入：richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,
//7,0]
//输出：[5,5,2,5,4,5,6,7]
//解释：
//answer[0] = 5，
//person 5 比 person 3 有更多的钱，person 3 比 person 1 有更多的钱，person 1 比 person 0 有更多的钱。
//
//唯一较为安静（有较低的安静值 quiet[x]）的人是 person 7，
//但是目前还不清楚他是否比 person 0 更有钱。
//answer[7] = 7，
//在所有拥有的钱肯定不少于 person 7 的人中（这可能包括 person 3，4，5，6 以及 7），
//最安静（有较低安静值 quiet[x]）的人是 person 7。
//其他的答案也可以用类似的推理来解释。
//
//
// 示例 2：
//
//
//输入：richer = [], quiet = [0]
//输出：[0]
//
//
//
//
// 提示：
//
//
// n == quiet.length
// 1 <= n <= 500
// 0 <= quiet[i] < n
// quiet 的所有值 互不相同
// 0 <= richer.length <= n * (n - 1) / 2
// 0 <= ai, bi < n
// ai != bi
// richer 中的所有数对 互不相同
// 对 richer 的观察在逻辑上是一致的
//
//
// Related Topics 深度优先搜索 图 拓扑排序 数组 👍 222 👎 0
package leetcode.editor.cn;
import java.util.*;
// 851:喧闹和富有
public class LoudAndRich {
public static void main(String[] args) {
Solution solution = new LoudAndRich().new Solution();
}
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public int[] loudAndRich(int[][] richer, int[] quiet) {
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < quiet.length; i++) {
map.put(i,new ArrayList<>());
}
int[] sizes = new int[quiet.length];
for (int[] rich : richer) {
map.computeIfAbsent(rich[0], key -> new ArrayList<>()).add(rich[1]);
sizes[rich[1]]++;
}
int[] res = new int[quiet.length];
Queue<Integer> queue = new ArrayDeque<>();
for (int i = 0; i < quiet.length; i++) {
res[i]=i;
if(sizes[i]==0){
queue.offer(i);
}
}
while (!queue.isEmpty()) {
int key = queue.poll();
for (int index : map.get(key)) {
if (quiet[res[key]] < quiet[res[index]]) {
res[index] = res[key]; // 更新 x 的邻居的答案
}
if (--sizes[index] == 0) {
queue.offer(index);
}
}
}
return res;
}
}
//leetcode submit region end(Prohibit modification and deletion)
}

45
src/main/java/leetcode/editor/cn/doc/content/AddingTwoNegabinaryNumbers.md
View File

@ -1,45 +0,0 @@
<p>给出基数为 <strong>-2</strong>&nbsp;的两个数&nbsp;<code>arr1</code> 和&nbsp;<code>arr2</code>，返回两数相加的结果。</p>
<p>数字以&nbsp;<em>数组形式</em><strong>&nbsp;</strong>给出：数组由若干 0 和 1 组成，按最高有效位到最低有效位的顺序排列。例如，<code>arr&nbsp;= [1,1,0,1]</code>&nbsp;表示数字&nbsp;<code>(-2)^3&nbsp;+ (-2)^2 + (-2)^0 = -3</code>。<em>数组形式</em>&nbsp;中的数字 <code>arr</code> 也同样不含前导零：即&nbsp;<code>arr == [0]</code>&nbsp;或&nbsp;<code>arr[0] == 1</code>。</p>
<p>返回相同表示形式的 <code>arr1</code> 和 <code>arr2</code> 相加的结果。两数的表示形式为：不含前导零、由若干 0 和 1 组成的数组。</p>
<p>&nbsp;</p>
<p><strong>示例 1：</strong></p>
<pre>
<strong>输入：</strong>arr1 = [1,1,1,1,1], arr2 = [1,0,1]
<strong>输出：</strong>[1,0,0,0,0]
<strong>解释：</strong>arr1 表示 11，arr2 表示 5，输出表示 16 。
</pre>
<p>
<meta charset="UTF-8" /></p>
<p><strong>示例 2：</strong></p>
<pre>
<strong>输入：</strong>arr1 = [0], arr2 = [0]
<strong>输出：</strong>[0]
</pre>
<p><strong>示例 3：</strong></p>
<pre>
<strong>输入：</strong>arr1 = [0], arr2 = [1]
<strong>输出：</strong>[1]
</pre>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<meta charset="UTF-8" />
<ul>
<li><code>1 &lt;= arr1.length,&nbsp;arr2.length &lt;= 1000</code></li>
<li><code>arr1[i]</code>&nbsp;和&nbsp;<code>arr2[i]</code>&nbsp;都是&nbsp;<code>0</code>&nbsp;或&nbsp;<code>1</code></li>
<li><code>arr1</code>&nbsp;和&nbsp;<code>arr2</code>&nbsp;都没有前导0</li>
</ul>
<div><div>Related Topics</div><div><li>数组</li><li>数学</li></div></div><br><div><li>👍 80</li><li>👎 0</li></div>

48
src/main/java/leetcode/editor/cn/doc/content/LoudAndRich.md
View File

@ -1,48 +0,0 @@
<p>有一组 <code>n</code> 个人作为实验对象，从 <code>0</code> 到 <code>n - 1</code> 编号，其中每个人都有不同数目的钱，以及不同程度的安静值（quietness）。为了方便起见，我们将编号为&nbsp;<code>x</code>&nbsp;的人简称为 "person&nbsp;<code>x</code>&nbsp;"。</p>
<p>给你一个数组 <code>richer</code> ，其中 <code>richer[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 表示 person&nbsp;<code>a<sub>i</sub></code>&nbsp;比 person&nbsp;<code>b<sub>i</sub></code>&nbsp;更有钱。另给你一个整数数组 <code>quiet</code> ，其中&nbsp;<code>quiet[i]</code> 是 person <code>i</code> 的安静值。<code>richer</code> 中所给出的数据 <strong>逻辑自洽</strong>（也就是说，在 person <code>x</code> 比 person <code>y</code> 更有钱的同时，不会出现 person <code>y</code> 比 person <code>x</code> 更有钱的情况 ）。</p>
<p>现在，返回一个整数数组 <code>answer</code> 作为答案，其中&nbsp;<code>answer[x] = y</code>&nbsp;的前提是，在所有拥有的钱肯定不少于&nbsp;person&nbsp;<code>x</code>&nbsp;的人中，person&nbsp;<code>y</code>&nbsp;是最安静的人（也就是安静值&nbsp;<code>quiet[y]</code>&nbsp;最小的人）。</p>
<p>&nbsp;</p>
<p><strong>示例 1：</strong></p>
<pre>
<strong>输入：</strong>richer = [[1,0],[2,1],[3,1],[3,7],[4,3],[5,3],[6,3]], quiet = [3,2,5,4,6,1,7,0]
<strong>输出：</strong>[5,5,2,5,4,5,6,7]
<strong>解释： </strong>
answer[0] = 5，
person 5 比 person 3 有更多的钱，person 3 比 person 1 有更多的钱，person 1 比 person 0 有更多的钱。
唯一较为安静（有较低的安静值 quiet[x]）的人是 person 7，
但是目前还不清楚他是否比 person 0 更有钱。
answer[7] = 7，
在所有拥有的钱肯定不少于 person 7 的人中（这可能包括 person 3，4，5，6 以及 7），
最安静（有较低安静值 quiet[x]）的人是 person 7。
其他的答案也可以用类似的推理来解释。
</pre>
<p><strong>示例 2：</strong></p>
<pre>
<strong>输入：</strong>richer = [], quiet = [0]
<strong>输出：</strong>[0]
</pre>
&nbsp;
<p><strong>提示：</strong></p>
<ul>
<li><code>n == quiet.length</code></li>
<li><code>1 &lt;= n &lt;= 500</code></li>
<li><code>0 &lt;= quiet[i] &lt; n</code></li>
<li><code>quiet</code> 的所有值 <strong>互不相同</strong></li>
<li><code>0 &lt;= richer.length &lt;= n * (n - 1) / 2</code></li>
<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
<li><code>a<sub>i </sub>!= b<sub>i</sub></code></li>
<li><code>richer</code> 中的所有数对 <strong>互不相同</strong></li>
<li>对<strong> </strong><code>richer</code> 的观察在逻辑上是一致的</li>
</ul>
<div><div>Related Topics</div><div><li>深度优先搜索</li><li>图</li><li>拓扑排序</li><li>数组</li></div></div><br><div><li>👍 222</li><li>👎 0</li></div>