Searching for an idiomatic Rust implementation of Minimum Edit Distance (LeetCode #72)
The first thing I noticed about both versions of your code is the plenitude of single-letter names, something you can improve upon.  Incidentally, Rust uses snake_case for variables, so the compiler would have warned you about D.
Now, let's talk about the struggles I presume you have by reading the Rust code.
First of all, you probably felt forced to convert between i32 and usize all the time.  The decision to return i32 instead of usize is a typical indicator of the less-than-ideal quality of LeetCode interfaces (as usual).  In fact, it goes worse - impl Solution is not a good idea in Rust, and there is no reason to take the ownership of strings here.  My advice here would be to perform all calculations using usize and only convert to i32 at the very end.
I assume HashMap&lt;(i32, i32), i32&gt; results from the lack of multi-dimensional vector support in Rust.  Indeed, my first choice would be to use ndarray in this scenario, which is not available in the standard library.  You can make a small wrapper for this:
struct Vec2&lt;T&gt; {
    elements: Vec&lt;T&gt;,
    n_rows: usize,
    n_columns: usize,
}

and derive Index&lt;(usize, usize)&gt; and IndexMut&lt;(usize, usize)&gt;.  Or you could sacrifice some performance and use Vec&lt;Vec&lt;usize&gt;&gt;.
Instead of
let w1: Vec&lt;char&gt; = word1.chars().collect();
let w2: Vec&lt;char&gt; = word2.chars().collect();

I would simply use .as_bytes(), assuming that LeetCode doesn't consider multi-byte characters.

Here's how I reassembled everything according to the Java version: (not tested)
pub fn min_distance(word_a: String, word_b: String) -&gt; i32 {
    let word_a = word_a.as_bytes();
    let word_b = word_b.as_bytes();

    let len_a = word_a.len();
    let len_b = word_b.len();

    let mut matrix = vec![vec![0; len_b + 1]; len_a + 1];

    for i in 0..=len_a {
        matrix[i][0] = i;
    }
    for j in 0..=len_b {
        matrix[0][j] = j;
    }

    for i in 1..=len_a {
        for j in 1..=len_b {
            matrix[i][j] = if word_a[i - 1] == word_b[j - 1] {
                matrix[i - 1][j - 1]
            } else {
                1 + matrix[i - 1][j - 1]
                    .min(matrix[i - 1][j])
                    .min(matrix[i][j - 1])
            };
        }
    }

    matrix[len_a][len_b] as i32
}

The restriction of LeetCode (poor interface, no external crates) caused me to be lazy, so I used nested Vecs.  In a real-world scenario, ndarray::Array2 would be a far better choice.
Besides, this is still far from optimal for Rust, where we tend to avoid manual indexing and - 1.  Taking into account the algorithmic nature of this application, I won't go deeper into this.