Rust 如何修复使用HashMap的代码<；i32，优先队列<；i32，i32>&燃气轮机；对矩阵进行对角排序？ 这是C++编程解决这个问题的方法（） vector对角线排序（vector&mat）{ int m=材料尺寸（）； int n=mat[0]。大小（）； map-mq； for（int i=0；iVec{ 让mut d:HashMap=HashMap:：new（）； 让mut mat=mat.clone（）； 设m=mat.len（）； 设n=mat[0].len（）； 因为我在0..m{ 对于0..n中的j{ 设key=i为i32-j为i32； 设v=-mat[i][j]； d、 输入（键）或插入（优先级队列：：new（））.push（v，v）； } } 因为我在0..m{ 对于0..n中的j{ 设key=i为i32-j为i32； 设v=d.get_mut（&key）.unwrap（）； mat[i][j]=-v.pop（）.unwrap（）.0； } } 垫子 } fn main（）{ 设m=vec！[vec！[9,6,3]，vec！[8,5,2]，vec！[7,4,1]； 显示（“输入：”、&m）； 设s=对角_排序（m）； 显示（“输出：”、&s）； } fn展会（s:&str、mat:&Vec）{ println！（“{}”，s）； 设m=mat.len（）； 设n=mat[0].len（）； 因为我在0..m{ 对于0..n中的j{ 打印！（“{}”，mat[i][j]）； } println！（）； } }

在不偷看的情况下从优先级队列中弹出：

 let v = d.get_mut(&key).unwrap();
 mat[i][j] = v.pop().unwrap().0;

结果（输出）：

您可以使用以下选项进行反向订购：

use std::cmp::Reverse;
use std::collections::BinaryHeap;
use std::collections::HashMap;

pub fn diagonal_sort(mat: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut mat = mat.clone();
    let mut mh: HashMap<i32, BinaryHeap<_>> = HashMap::new();
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            mh.entry(key)
                .or_insert(BinaryHeap::new())
                .push(Reverse(mat[i][j]));
        }
    }
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            let q = mh.get_mut(&key).unwrap();
            match q.pop().unwrap() {
                Reverse(v) => mat[i][j] = v,
            }
        }
    }
    mat
}

fn main() {
    let m = vec![vec![9, 8, 7], vec![6, 5, 4], vec![3, 2, 1]];
    show("input:", &m);
    let s = diagonal_sort(m);
    show("output:", &s);
}
fn show(s: &str, mat: &Vec<Vec<i32>>) {
    println!("{}", s);
    let m = mat.len();
    let n = mat[0].len();
    for i in 0..m {
        for j in 0..n {
            print!("{} ", mat[i][j]);
        }
        println!();
    }
}

尝试以下方法（对于对角不同的元素）：

使用优先级队列：：优先级队列；
使用std:：collections:：HashMap；
fn对角_排序（mat:Vec）->Vec{
让mut d:HashMap=HashMap:：new（）；
让mut mat=mat.clone（）；
设m=mat.len（）；
设n=mat[0].len（）；
因为我在0..m{
对于0..n中的j{
设key=i为i32-j为i32；
设v=-mat[i][j]；
d、 输入（键）或插入（优先级队列：：new（））.push（v，v）；
}
}
因为我在0..m{
对于0..n中的j{
设key=i为i32-j为i32；
设v=d.get_mut（&key）.unwrap（）；
mat[i][j]=-v.pop（）.unwrap（）.0；
}
}
垫子
}
fn main（）{
设m=vec！[vec！[9,6,3]，vec！[8,5,2]，vec！[7,4,1]；
显示（“输入：”、&m）；
设s=对角_排序（m）；
显示（“输出：”、&s）；
}
fn展会（s:&str、mat:&Vec）{
println！（“{}”，s）；
设m=mat.len（）；
设n=mat[0].len（）；
因为我在0..m{
对于0..n中的j{
打印！（“{}”，mat[i][j]）；
}
println！（）；
}
}

我发现使用std:：collections:：BinaryHeap来解决这个问题实际上更好

use std::collections::BinaryHeap;
use std::collections::HashMap;

pub fn main() {
    let mat = vec![vec![3,3,1,1],vec![2,2,1,2],vec![1,1,1,2]];
    let res = diagonal_sort(mat);
    println!("{:?}", res);
}

pub fn diagonal_sort(mat: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut mat = mat.clone();
    let mut mh: HashMap<i32, BinaryHeap<i32>> = HashMap::new();
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            mh.entry(key)
                .or_insert(BinaryHeap::new())
                .push(-mat[i][j]);
        }
    }
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            let q = mh.get_mut(&key).unwrap();
            mat[i][j] = -(q.pop().unwrap());
        }
    }
    mat
}

使用std:：collections:：BinaryHeap；
使用std:：collections:：HashMap；
pub fn main（）{
设mat=vec！[vec！[3,3,1,1]，vec！[2,2,1,2]，vec！[1,1,2]；
设res=对角_排序（mat）；
println！（“{：？}”，res）；
}
发布fn对角排序（mat:Vec）->Vec{
让mut mat=mat.clone（）；
让mut-mh:HashMap=HashMap:：new（）；
对于0..mat.len（）中的i{
对于0..mat[0].len（）中的j{
设key=i为i32-j为i32；
mh.入口（钥匙）
.或_insert（BinaryHeap:：new（））
.push（-mat[i][j]）；
}
}
对于0..mat.len（）中的i{
对于0..mat[0].len（）中的j{
设key=i为i32-j为i32；
设q=mh.get_mut（&key）.unwrap（）；
mat[i][j]=-（q.pop（）.unwrap（））；
}
}
垫子
}

谢谢。数字需要按升序排序。请修复这个问题，并为它创建一个不同的测试用例，我会接受这个答案。@grokus:您也可以使用来颠倒顺序，请参见编辑。

use std::cmp::Reverse;
use std::collections::BinaryHeap;
use std::collections::HashMap;

pub fn diagonal_sort(mat: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut mat = mat.clone();
    let mut mh: HashMap<i32, BinaryHeap<_>> = HashMap::new();
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            mh.entry(key)
                .or_insert(BinaryHeap::new())
                .push(Reverse(mat[i][j]));
        }
    }
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            let q = mh.get_mut(&key).unwrap();
            match q.pop().unwrap() {
                Reverse(v) => mat[i][j] = v,
            }
        }
    }
    mat
}

fn main() {
    let m = vec![vec![9, 8, 7], vec![6, 5, 4], vec![3, 2, 1]];
    show("input:", &m);
    let s = diagonal_sort(m);
    show("output:", &s);
}
fn show(s: &str, mat: &Vec<Vec<i32>>) {
    println!("{}", s);
    let m = mat.len();
    let n = mat[0].len();
    for i in 0..m {
        for j in 0..n {
            print!("{} ", mat[i][j]);
        }
        println!();
    }
}

input:
9 6 3
8 5 2
7 4 1
output:
1 2 3
4 5 6
7 8 9

use priority_queue::PriorityQueue;
use std::collections::HashMap;

fn diagonal_sort(mat: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut d: HashMap<i32, PriorityQueue<i32, i32>> = HashMap::new();
    let mut mat = mat.clone();
    let m = mat.len();
    let n = mat[0].len();
    for i in 0..m {
        for j in 0..n {
            let key = i as i32 - j as i32;
            let v = -mat[i][j];
            d.entry(key).or_insert(PriorityQueue::new()).push(v, v);
        }
    }

    for i in 0..m {
        for j in 0..n {
            let key = i as i32 - j as i32;
            let v = d.get_mut(&key).unwrap();
            mat[i][j] = -v.pop().unwrap().0;
        }
    }
    mat
}

fn main() {
    let m = vec![vec![9, 6, 3], vec![8, 5, 2], vec![7, 4, 1]];
    show("input:", &m);
    let s = diagonal_sort(m);
    show("output:", &s);
}
fn show(s: &str, mat: &Vec<Vec<i32>>) {
    println!("{}", s);
    let m = mat.len();
    let n = mat[0].len();
    for i in 0..m {
        for j in 0..n {
            print!("{} ", mat[i][j]);
        }
        println!();
    }
}

use std::collections::BinaryHeap;
use std::collections::HashMap;

pub fn main() {
    let mat = vec![vec![3,3,1,1],vec![2,2,1,2],vec![1,1,1,2]];
    let res = diagonal_sort(mat);
    println!("{:?}", res);
}

pub fn diagonal_sort(mat: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut mat = mat.clone();
    let mut mh: HashMap<i32, BinaryHeap<i32>> = HashMap::new();
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            mh.entry(key)
                .or_insert(BinaryHeap::new())
                .push(-mat[i][j]);
        }
    }
    for i in 0..mat.len() {
        for j in 0..mat[0].len() {
            let key = i as i32 - j as i32;
            let q = mh.get_mut(&key).unwrap();
            mat[i][j] = -(q.pop().unwrap());
        }
    }
    mat
}