youyou
/
my_leetcode
1
1
Fork 0
Code Issues Pull Requests Projects Releases Activity

更新

This commit is contained in:
游由 2022-08-03 16:07:47 +08:00
parent 966e70608d
commit b102c44cfd
7 changed files with 256 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
rust/src/implements/mod.rs
View File

@ -149,6 +149,7 @@ mod q0872;
mod q0876;
mod q0888;
mod q0897;
mod q0899;
mod q0912;
mod q0917;
mod q0918;
@ -170,6 +171,7 @@ mod q1137;
mod q1143;
mod q1190;
mod q1202;
mod q1203;
mod q1218;
mod q1269;
mod q1310;
@ -178,6 +180,7 @@ mod q1447;
mod q1473;
mod q1482;
mod q1486;
mod q1502;
mod q1720;
mod q1723;
mod q1734;

69
rust/src/implements/q0899.rs Normal file
View File

@ -0,0 +1,69 @@
use std::io::Read;
use crate::Solution;
impl Solution {
/// [899.有序队列](https://leetcode-cn.com/problems/orderly-queue/)
///
/// 2022-08-03 10:32:04
///
/// 给定一个字符串 `s` 和一个整数 `k` 。你可以从 `s` 的前 `k` 个字母中选择一个，并把它加到字符串的末尾。
///
/// 返回 _在应用上述步骤的任意数量的移动后，字典上最小的字符串_。
///
/// + **示例 1：**
/// - **输入：** s = "cba", k = 1
/// - **输出：** "acb"
/// - **解释：**
/// - 在第一步中，我们将第一个字符（“c”）移动到最后，获得字符串 “bac”。
/// - 在第二步中，我们将第一个字符（“b”）移动到最后，获得最终结果 “acb”。
/// + **示例 2：**
/// - **输入：** s = "baaca", k = 3
/// - **输出：** "aaabc"
/// - **解释：**
/// - 在第一步中，我们将第一个字符（“b”）移动到最后，获得字符串 “aacab”。
/// - 在第二步中，我们将第三个字符（“c”）移动到最后，获得最终结果 “aaabc”。
/// + **提示：**
/// * `1 <= k <= S.length <= 1000`
/// * `s` 只由小写字母组成。
/// + Related Topics
/// * 数学
/// * 字符串
/// * 排序
/// * 👍 100
/// * 👎 0
pub fn orderly_queue(s: String, k: i32) -> String {
match k {
1 => s.chars().chain(s.chars()).collect::<Vec<_>>().windows(s.len()).min().unwrap().iter().collect(),
_ => s.chars().collect::<std::collections::BinaryHeap<_>>().into_sorted_vec().iter().collect()
}
/*let mut result = s.into_bytes();
if k == 1 {
let mut bytes = result.clone();
for i in 1..result.len() {
let c = bytes.remove(0);
bytes.push(c);
if bytes.lt(&result) {
result = bytes.clone();
}
}
String::from_utf8(result).unwrap()
} else {
result.sort();
String::from_utf8(result).unwrap()
}*/
//unimplemented!()
}
}
#[cfg(test)]
mod test {
use crate::Solution;
#[test]
fn test_q0899() {
assert_eq!(Solution::orderly_queue("cba".to_owned(), 1), "acb".to_owned());
assert_eq!(Solution::orderly_queue("baaca".to_owned(), 3), "aaabc".to_owned());
assert_eq!(Solution::orderly_queue("nhtq".to_owned(),1), "htqn".to_owned());
assert_eq!(Solution::orderly_queue("gxzv".to_owned(), 4), "gvxz".to_owned());
}
}

3
rust/src/implements/q0912.rs
View File

@ -24,8 +24,7 @@ impl Solution {
///
/// 👍 318 👎 0
pub fn sort_array(mut nums: Vec<i32>) -> Vec<i32> {
nums.sort_unstable();
nums
std::collections::BinaryHeap::from(nums).into_sorted_vec()
}
}

131
rust/src/implements/q1203.rs Normal file
View File

@ -0,0 +1,131 @@
use crate::Solution;
impl Solution {
/// [1203.项目管理](https://leetcode-cn.com/problems/sort-items-by-groups-respecting-dependencies/)
///
/// 2022-02-21 18:15:56
///
/// 有 `n` 个项目，每个项目或者不属于任何小组，或者属于 `m` 个小组之一。`group[i]` 表示第 `i` 个项目所属的小组，如果第 `i` 个项目不属于任何小组，则 `group[i]` 等于 `-1`。项目和小组都是从零开始编号的。可能存在小组不负责任何项目，即没有任何项目属于这个小组。
///
/// 请你帮忙按要求安排这些项目的进度，并返回排序后的项目列表：
///
/// > 同一小组的项目，排序后在列表中彼此相邻。
/// > 项目之间存在一定的依赖关系，我们用一个列表 `beforeItems` 来表示，其中 `beforeItems[i]` 表示在进行第 `i` 个项目前（位于第 `i` 个项目左侧）应该完成的所有项目。
///
/// 如果存在多个解决方案，只需要返回其中任意一个即可。如果没有合适的解决方案，就请返回一个 **空列表** 。
///
/// + **示例 1：**
/// + ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/22/1359_ex1.png)
/// + **输入：** n = 8, m = 2, group = \[-1,-1,1,0,0,1,0,-1\], beforeItems = \[\[\],\[6\],\[5\],\[6\],\[3,6\],\[\],\[\],\[\]\]
/// + **输出：** \[6,3,4,1,5,2,0,7\]
/// + **示例 2：**
/// + **输入：** n = 8, m = 2, group = \[-1,-1,1,0,0,1,0,-1\], beforeItems = \[\[\],\[6\],\[5\],\[6\],\[3\],\[\],\[4\],\[\]\]
/// + **输出：** \[\]
/// + **解释：** 与示例 1 大致相同，但是在排序后的列表中，4 必须放在 6 的前面。
/// + **提示：**
/// * `1 <= m <= n <= 3 * 104`
/// * `group.length == beforeItems.length == n`
/// * `-1 <= group[i] <= m - 1`
/// * `0 <= beforeItems[i].length <= n - 1`
/// * `0 <= beforeItems[i][j] <= n - 1`
/// * `i != beforeItems[i][j]`
/// * `beforeItems[i]` 不含重复元素
/// + Related Topics
/// * 深度优先搜索
/// * 广度优先搜索
/// * 图
/// * 拓扑排序
/// * 👍 189
/// * 👎 0
pub fn sort_items(n: i32, m: i32, group: Vec<i32>, before_items: Vec<Vec<i32>>) -> Vec<i32> {
fn top_sort(deg: &mut Vec<usize>, graph: &mut Vec<Vec<usize>>, items: &mut Vec<usize>) -> Vec<usize> {
let mut q = std::collections::VecDeque::<usize>::new();
let n = items.len();
for item in items {
if deg[*item] == 0 {
q.push_back(*item);
}
}
let mut res = Vec::<usize>::new();
while !q.is_empty() {
let u = q.pop_front().unwrap();
res.push(u);
for &v in &graph[u] {
deg[v] -= 1;
if deg[v] == 0 {
q.push_back(v);
}
}
}
if res.len() == n {
res
} else {
Vec::new()
}
//unimplemented!();
}
let mut group_item = vec![Vec::<usize>::new(); (n + m) as usize];
let mut group_graph = vec![Vec::<usize>::new(); (n + m) as usize];
let mut item_graph = vec![Vec::<usize>::new(); n as usize];
let mut group_degree = vec![0usize; (n + m) as usize];
let mut item_degree = vec![0usize; n as usize];
let mut id = (0..((n + m) as usize)).collect::<Vec<usize>>();
let mut left_id = m as usize;
let mut group = group.into_iter().map(|x| x as usize).collect::<Vec<usize>>();
for i in 0..(n as usize) {
if group[i] == -1i32 as usize {
group[i] = left_id;
left_id += 1;
}
group_item[group[i]].push(i);
}
for i in 0..(n as usize) {
let curr_group_id = group[i];
for &item in &before_items[i] {
let before_group_id = group[item as usize];
if before_group_id == curr_group_id {
item_degree[i] += 1;
item_graph[item as usize].push(i);
} else {
group_degree[curr_group_id] += 1;
group_graph[before_group_id].push(curr_group_id);
}
}
}
let group_top_sort = top_sort(&mut group_degree, &mut group_graph, &mut id);
if group_top_sort.is_empty() {
return Vec::new();
}
let mut ans = Vec::<i32>::new();
for curr_group_id in group_top_sort {
//let size = group_item[curr_group_id].len();
if group_item[curr_group_id].len() == 0 {
continue;
}
let res = top_sort(&mut item_degree, &mut item_graph, &mut group_item[curr_group_id]);
if res.is_empty() {
return Vec::<i32>::new();
}
for item in res {
ans.push(item as i32);
}
}
ans
}
}
#[cfg(test)]
mod test {
use crate::Solution;
#[test]
fn test_q1203() {
// n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]
assert_eq!(Solution::sort_items(8, 2, vec![-1, -1, 1, 0, 0, 1, 0, -1], vec![vec![], vec![6], vec![5], vec![6], vec![3, 6], vec![], vec![], vec![]]), vec![6, 3, 4, 5, 2, 0, 7, 1]);
}
}

46
rust/src/implements/q1502.rs Normal file
View File

@ -0,0 +1,46 @@
use crate::Solution;
impl Solution {
/// [1502.判断能否形成等差数列](https://leetcode-cn.com/problems/can-make-arithmetic-progression-from-sequence/)
///
/// 2022-08-03 14:54:25
///
/// 给你一个数字数组 `arr` 。
///
/// 如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 **等差数列** 。
///
/// 如果可以重新排列数组形成等差数列，请返回 `true` ；否则，返回 `false` 。
///
/// + **示例 1：**
/// - **输入：** arr = \[3,5,1\]
/// - **输出：** true
/// - **解释：** 对数组重新排序得到 \[1,3,5\] 或者 \[5,3,1\] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
/// + **示例 2：**
/// - **输入：** arr = \[1,2,4\]
/// - **输出：** false
/// - **解释：** 无法通过重新排序得到等差数列。
/// + **提示：**
/// * `2 <= arr.length <= 1000`
/// * `-10^6 <= arr[i] <= 10^6`
/// + Related Topics
/// * 数组
/// * 排序
/// * 👍 29
/// * 👎 0
pub fn can_make_arithmetic_progression(arr: Vec<i32>) -> bool {
match arr.len() {
0 | 1 | 2 => true,
_ => std::collections::BinaryHeap::from(arr).into_sorted_vec().windows(3).map(|w| w[1] - w[0] == w[2] - w[1]).skip_while(|i| *i).next().is_none()
}
}
}
#[cfg(test)]
mod test {
use crate::Solution;
#[test]
fn test_q1502() {
assert_eq!(Solution::can_make_arithmetic_progression(vec![1, 2, 4]), false);
}
}

8
rust/src/implements/q1984.rs
View File

@ -42,12 +42,16 @@ impl Solution {
/// * 👍 36
/// * 👎 0
pub fn minimum_difference(mut nums: Vec<i32>, k: i32) -> i32 {
let k = k as usize;
match k {
1 => 0,
_ => std::collections::BinaryHeap::from(nums).into_sorted_vec().windows(k as usize).map(|s| s[s.len() - 1] - s[0]).min().unwrap()
}
/*let k = k as usize;
if k == 1 {
return 0;
}
nums.sort_unstable();
(k - 1..nums.len()).map(|idx| nums[idx] - nums[idx + 1 - k]).min().unwrap()
(k - 1..nums.len()).map(|idx| nums[idx] - nums[idx + 1 - k]).min().unwrap()*/
}
}

20
rust/src/leet_code.rs
View File

@ -7,26 +7,6 @@ use std::rc::Rc;
use std::ops::Add;
impl Solution {
/// 1502.判断能否形成等差数列
///
/// [原题链接](https://leetcode-cn.com/problems/can-make-arithmetic-progression-from-sequence/)
pub fn can_make_arithmetic_progression(mut arr: Vec<i32>) -> bool {
if arr.len() < 3 {
return true;
}
arr.sort();
let d = arr[1] - arr[0];
for i in 1..arr.len() {
if arr[i] != arr[i - 1] + d {
return false;
}
}
true
}
/// 面试题 16.01.交换数字
///
/// [原题链接](https://leetcode-cn.com/problems/swap-numbers-lcci/)