Monge Array - leftmost minimum for each row
Read compiler warnings and fix them:

src/main.rs:7:11: 7:27 warning: unnecessary parentheses around `if` condition, #[warn(unused_parens)] on by default
src/main.rs:7         if(monge[i] &lt; min){
                        ^~~~~~~~~~~~~~~~

Spaces before braces

fn min(...) -&gt; usize{ // No
fn min(...) -&gt; usize { // Yes

Be consistent about brace indentation

// No
if {
    1
} else { 2 }

// Yes
if {
    1
} else {
    2
}

mut is stuck to the &amp;

&amp; mut Vec&lt;usize&gt; // No
&amp;mut Vec&lt;usize&gt; // Yes

else lives on the same line as the previous curly brace

// No
if true {
    1
}
else {
    2
}

// Yes
if true {
    1
} else {
    2
}

No need to leave blank space at the beginning of a block

// No
fn foo() {

    let a = 1;

// Yes
fn foo() {
    let a = 1;

Keep the macro braces attached to the macro name, and indent the body if it's going to be multiline. Leave a trailing comma, and use spaces after the comma

let x = vec![
    10, 17, 13, 28, 23, 
    17, 22, 16, 29, 23, 
    24, 28, 22, 34, 24, 
    11, 13,  6, 17,  7, 
    45, 44, 32, 37, 23, 
    36, 33, 19, 21,  6, 
    75, 66, 51, 53, 34,
];

Leave spaces after commas in function calls as well, but not before

// No
get(row ,leftmost[row - factor]),

// Yes
get(row, leftmost[row - factor]),

A single space around =

leftmost[row] =  min(...); // No
leftmost[row] = min(...); // Yes

Never take a &amp;Vec&lt;T&gt; as an argument, use a &amp;[T] instead. This allows more types to be provided
Your min function is poorly named. The name seems to suggest it will return the minimum value, when it actually returns the index of the minimum value. Rename it to something intention-revealing. Maybe index_of_minimum
Space after a ; in an array or vector

vec![0;row]; // No
vec![0; row]; // Yes

Instead of having multiple lines in a for x in y clause, create a variable to store that in.

// Poor name because I'm not sure what it really is
let x_rows = (0..)
    .map(|x| factor * (2 * x + 1))
    .take_while(|&amp;x| x &lt; (rows - 1));

for row in x_rows {

Eventually, min_by will be stabilized, and you can use it:

// May be off-by-one errors here
let (min_index, _) =
    monge.iter()
    .enumerate()
    .skip(from)
    .take(to - from)
    .min_by(|&amp;(_, v)| v)
    .unwrap();
min_index



I'm sure there's more that can be suggested, but my brain is tired for now ^_^.

fn index_of_minimum(monge: &amp;[i32], from: usize, to: usize) -&gt; usize {
    let mut min = monge[from];

    (from + 1..to).fold(from, |m,i| {
        if monge[i] &lt; min {
            min = monge[i];
            i
        } else {
            m
        }
    })
}

fn minimums(monge: &amp;[i32], leftmost: &amp;mut Vec&lt;usize&gt;, rows: usize, columns: usize, factor: usize) {
    if rows == 1 {
        leftmost[0] = index_of_minimum(monge, 0, columns) % columns;
    } else {
        let mid = rows - (rows / 2);
        minimums(monge, leftmost, mid, columns, 2 * factor);

        let get = |i, j| (i * columns) + j;

        let x_rows = (0..)
            .map(|x| factor * (2 * x + 1))
            .take_while(|&amp;x| x &lt; (rows - 1));

        for row in x_rows {
            leftmost[row] = index_of_minimum(monge,
                                get(row, leftmost[row - factor]),
                                get(row, leftmost[row + factor] + 1)) % columns;
        }

        if rows % 2 == 0 {
            let row = factor * (rows - 1);
            leftmost[row] = index_of_minimum(monge,
                                get(row, leftmost[row - factor]),
                                get(row, columns)) % columns;
        }
    }
}

fn main() {
    let row = 7;
    let x = vec![
        10, 17, 13, 28, 23,
        17, 22, 16, 29, 23,
        24, 28, 22, 34, 24,
        11, 13,  6, 17,  7,
        45, 44, 32, 37, 23,
        36, 33, 19, 21,  6,
        75, 66, 51, 53, 34,
    ];

    let mut leftmost = vec![0; row];

    minimums(&amp;x, &amp;mut leftmost, row, 5, 1);

    for x in leftmost {
        println!("{}", x);
    }
}