use std::cmp::min;
use std::fs;
use std::io::{stdin, Read};
struct UnionFind {
    parents: Vec<usize>,
}
impl UnionFind {
    pub fn new(n: usize) -> Self {
        let par = (0..n).collect();
        UnionFind { parents: par }
    }
    pub fn root(&mut self, x: usize) -> usize {
        if self.parents[x] == x {
            return x;
        }
        let par = self.parents[x];
        self.parents[x] = self.root(par);
        self.parents[x]
    }
    pub fn union(&mut self, x: usize, y: usize) {
        let rx = self.root(x);
        let ry = self.root(y);
        if rx == ry {
            return;
        }
        self.parents[rx] = ry;
    }
    pub fn is_same(&mut self, x: usize, y: usize) -> bool {
        let rx = self.root(x);
        let ry = self.root(y);
        rx == ry
    }
}

macro_rules! parse {
    ($it: ident) => {
        $it.next().unwrap().parse().unwrap()
    };
    ($it: ident,2) => {
        (parse!($it), parse!($it))
    };
    ($it: ident,3) => {
        (parse!($it), parse!($it), parse!($it))
    };
    ($it: ident,4) => {
        (parse!($it), parse!($it), parse!($it), parse!($it))
    };
    ($it: ident, $n: expr) => {
        (&mut $it).take($n).map(|e| e.parse().unwrap()).collect();
    };
}

fn solve(s: &str) -> usize {
    let mut it = s.split_whitespace();
    let (h, w): (usize, usize) = parse!(it, 2);
    let g: Vec<Vec<_>> = (0..h)
        .map(|_| it.next().unwrap().chars().map(|c| c == '#').collect())
        .collect();
    let mut lens = vec![vec![std::usize::MAX / 10; w]; h];
    lens[0][0] = if g[0][0] { 1 } else { 0 };
    for i in 0..h {
        for j in 0..w {
            let mut prevs = vec![];
            if i > 0 {
                prevs.push((i - 1, j));
            }
            if j > 0 {
                prevs.push((i, j - 1))
            }
            for (pi, pj) in prevs {
                lens[i][j] = min(
                    lens[i][j],
                    lens[pi][pj] + if !g[pi][pj] && g[i][j] { 1 } else { 0 },
                );
            }
        }
    }
    // for i in 0..h {
    //     for j in 0..w {
    //         print!("{}", lens[i][j]);
    //     }
    //     println!()
    // }
    lens[h - 1][w - 1]
}

fn test() {
    let mut f = fs::File::open("foo.txt").unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();
    solve(&s);
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    println!("{}", solve(&s));
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_input() {
        let cases = &[
            (
                "
            9 3
            ...
            .#.
            #..
            .#.
            ###
            .##
            .#.
            .##
            ...
            ",
                2,
            ),
            (
                "
            3 5
            .#...
            .#.#.
            ...#.
            ",
                1,
            ),
            (
                "
            5 4
            ....
            ###.
            ....
            .###
            ....
            ",
                1,
            ),
            (
                "
2 14 
.#.#.#.#.#.#.#
##############
",
                1,
            ),
            (
                "
            2 2
            ..
            .#
            ",
                1,
            ),
            (
                "
            4 5
            ..###
            #...#
            ###.#
            #####
            ",
                1,
            ),
            (
                "
            4 5
            ..###
            #.#.#
            ###.#
            #####
            ",
                1,
            ),
            (
                "
            4 5
            ..###
            #.#.#
            #...#
            #.###
            ",
                1,
            ),
            (
                "
            1 14
            .#.#.#.#.#.#.#
            ",
                7,
            ),
            (
                "
            2 14
            .#.#.#.#.#.#.#
            ####.#########
            ",
                2,
            ),
        ];
        for &(s, i) in cases {
            let a = solve(s);
            if a != i {
                println!("actual {}, expected {}", a, i);
                println!("{}", s);
                panic!()
            }
        }
    }
}


Measured memory_bytes: 4352