QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#362034#8507. Clever Cell Choicesucup-team635#AC ✓1ms2700kbRust8.7kb2024-03-23 13:56:452024-03-23 13:56:45

Judging History

你现在查看的是最新测评结果

  • [2024-03-23 13:56:45]
  • 评测
  • 测评结果:AC
  • 用时:1ms
  • 内存:2700kb
  • [2024-03-23 13:56:45]
  • 提交

answer

use std::collections::*;
use std::io::Write;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    input! {
        h: usize,
        w: usize,
        s: [bytes; h],
    }
    let mut g = maxflow::Graph::new(h * w + 2);
    let mut edge = vec![];
    let src = h * w;
    let dst = src + 1;
    for (i, c) in s.iter().enumerate() {
        for (j, c) in c.iter().enumerate() {
            if *c == b'#' {
                continue;
            }
            if (i + j) % 2 == 0 {
                g.add_edge(src, i * w + j, 1u32);
                for &(dx, dy) in [(1, 0), (0, 1), (!0, 0), (0, !0)].iter() {
                    let (x, y) = (i + dx, j + dy);
                    if x < h && y < w && s[x][y] == b'.' {
                        edge.push(g.add_edge(i * w + j, x * w + y, 1));
                    }
                }
            } else {
                g.add_edge(i * w + j, dst, 1);
            }
        }
    }
    g.flow(src, dst);
    let mut matched = vec![None; h * w];
    let mut free = vec![vec![]; h * w];
    for e in edge.iter() {
        let (s, t, u, _) = g.get_edge(e);
        if u == 1 {
            matched[s] = Some(t);
            matched[t] = Some(s);
        } else {
            free[s].push(t);
            free[t].push(s);
        }
    }
    let mut win = vec![false; h * w];
    for i in 0..(h * w) {
        if win[i] {
            continue;
        }
        if s[i / w][i % w] == b'#' {
            continue;
        }
        if matched[i].is_some() {
            continue;
        }
        win[i] = true;
        let mut dfs = vec![i];
        while let Some(v) = dfs.pop() {
            for &u in free[v].iter() {
                let t = matched[u].unwrap();
                if !win[t] {
                    win[t] = true;
                    dfs.push(t);
                }
            }
        }
    }
    println!("{}", win.iter().filter(|w| **w).count());
}

// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[macro_export]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

#[macro_export]
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

#[macro_export]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
// ---------- end input macro ----------
// ---------- begin max flow (Dinic) ----------
mod maxflow {
    pub trait MaxFlowCapacity:
        Copy + Ord + std::ops::Add<Output = Self> + std::ops::Sub<Output = Self>
    {
        fn zero() -> Self;
        fn inf() -> Self;
    }

    macro_rules! impl_primitive_integer_capacity {
        ($x:ty, $y:expr) => {
            impl MaxFlowCapacity for $x {
                fn zero() -> Self {
                    0
                }
                fn inf() -> Self {
                    $y
                }
            }
        };
    }

    impl_primitive_integer_capacity!(u32, std::u32::MAX);
    impl_primitive_integer_capacity!(u64, std::u64::MAX);
    impl_primitive_integer_capacity!(i32, std::i32::MAX);
    impl_primitive_integer_capacity!(i64, std::i64::MAX);

    #[derive(Clone)]
    struct Edge<Cap> {
        to_: u32,
        inv_: u32,
        cap_: Cap,
    }

    impl<Cap> Edge<Cap> {
        fn new(to: usize, inv: usize, cap: Cap) -> Self {
            Edge {
                to_: to as u32,
                inv_: inv as u32,
                cap_: cap,
            }
        }
        fn to(&self) -> usize {
            self.to_ as usize
        }
        fn inv(&self) -> usize {
            self.inv_ as usize
        }
    }

    impl<Cap: MaxFlowCapacity> Edge<Cap> {
        fn add(&mut self, cap: Cap) {
            self.cap_ = self.cap_ + cap;
        }
        fn sub(&mut self, cap: Cap) {
            self.cap_ = self.cap_ - cap;
        }
        fn cap(&self) -> Cap {
            self.cap_
        }
    }

    pub struct Graph<Cap> {
        graph: Vec<Vec<Edge<Cap>>>,
    }

    #[allow(dead_code)]
    pub struct EdgeIndex {
        src: usize,
        dst: usize,
        x: usize,
        y: usize,
    }

    impl<Cap: MaxFlowCapacity> Graph<Cap> {
        pub fn new(size: usize) -> Self {
            Self {
                graph: vec![vec![]; size],
            }
        }
        pub fn add_edge(&mut self, src: usize, dst: usize, cap: Cap) -> EdgeIndex {
            assert!(src.max(dst) < self.graph.len());
            assert!(cap >= Cap::zero());
            assert!(src != dst);
            let x = self.graph[src].len();
            let y = self.graph[dst].len();
            self.graph[src].push(Edge::new(dst, y, cap));
            self.graph[dst].push(Edge::new(src, x, Cap::zero()));
            EdgeIndex { src, dst, x, y }
        }
        // src, dst, used, intial_capacity
        #[allow(dead_code)]
        pub fn get_edge(&self, e: &EdgeIndex) -> (usize, usize, Cap, Cap) {
            let max = self.graph[e.src][e.x].cap() + self.graph[e.dst][e.y].cap();
            let used = self.graph[e.dst][e.y].cap();
            (e.src, e.dst, used, max)
        }
        pub fn flow(&mut self, src: usize, dst: usize) -> Cap {
            let size = self.graph.len();
            assert!(src.max(dst) < size);
            assert!(src != dst);
            let mut queue = std::collections::VecDeque::new();
            let mut level = vec![0; size];
            let mut it = vec![0; size];
            let mut ans = Cap::zero();
            loop {
                (|| {
                    level.clear();
                    level.resize(size, 0);
                    level[src] = 1;
                    queue.clear();
                    queue.push_back(src);
                    while let Some(v) = queue.pop_front() {
                        let d = level[v] + 1;
                        for e in self.graph[v].iter() {
                            let u = e.to();
                            if e.cap() > Cap::zero() && level[u] == 0 {
                                level[u] = d;
                                if u == dst {
                                    return;
                                }
                                queue.push_back(u);
                            }
                        }
                    }
                })();
                if level[dst] == 0 {
                    break;
                }
                it.clear();
                it.resize(size, 0);
                loop {
                    let f = self.dfs(dst, src, Cap::inf(), &mut it, &level);
                    if f == Cap::zero() {
                        break;
                    }
                    ans = ans + f;
                }
            }
            ans
        }
        fn dfs(&mut self, v: usize, src: usize, cap: Cap, it: &mut [usize], level: &[u32]) -> Cap {
            if v == src {
                return cap;
            }
            while let Some((u, inv)) = self.graph[v].get(it[v]).map(|p| (p.to(), p.inv())) {
                if level[u] + 1 == level[v] && self.graph[u][inv].cap() > Cap::zero() {
                    let cap = cap.min(self.graph[u][inv].cap());
                    let c = self.dfs(u, src, cap, it, level);
                    if c > Cap::zero() {
                        self.graph[v][it[v]].add(c);
                        self.graph[u][inv].sub(c);
                        return c;
                    }
                }
                it[v] += 1;
            }
            Cap::zero()
        }
    }
}
// ---------- end max flow (Dinic) ----------

詳細信息

Test #1:

score: 100
Accepted
time: 0ms
memory: 2152kb

input:

3 3
#.#
...
#.#

output:

4

result:

ok 1 number(s): "4"

Test #2:

score: 0
Accepted
time: 0ms
memory: 2008kb

input:

3 3
..#
...
...

output:

0

result:

ok 1 number(s): "0"

Test #3:

score: 0
Accepted
time: 0ms
memory: 1984kb

input:

1 4
...#

output:

2

result:

ok 1 number(s): "2"

Test #4:

score: 0
Accepted
time: 0ms
memory: 2080kb

input:

1 5
####.

output:

1

result:

ok 1 number(s): "1"

Test #5:

score: 0
Accepted
time: 0ms
memory: 2080kb

input:

1 6
#..###

output:

0

result:

ok 1 number(s): "0"

Test #6:

score: 0
Accepted
time: 0ms
memory: 2020kb

input:

2 5
....#
###.#

output:

3

result:

ok 1 number(s): "3"

Test #7:

score: 0
Accepted
time: 0ms
memory: 2004kb

input:

2 6
...##.
.#.###

output:

4

result:

ok 1 number(s): "4"

Test #8:

score: 0
Accepted
time: 0ms
memory: 2096kb

input:

5 5
##...
##.#.
##.##
##.#.
.##..

output:

7

result:

ok 1 number(s): "7"

Test #9:

score: 0
Accepted
time: 0ms
memory: 2092kb

input:

6 6
...##.
#..#..
......
..#...
#...##
.#....

output:

1

result:

ok 1 number(s): "1"

Test #10:

score: 0
Accepted
time: 0ms
memory: 2096kb

input:

10 10
####.#...#
.#.###....
#....#..#.
.....#.#..
##.#..#.#.
..#..##...
.##.#####.
#######.##
.#.#.##..#
.#.###.##.

output:

26

result:

ok 1 number(s): "26"

Test #11:

score: 0
Accepted
time: 0ms
memory: 2104kb

input:

10 10
..#..#.###
.#######.#
.#.####.#.
......####
#..#..#.#.
...#.###.#
#.#...#.#.
.#...#....
...#.#.#.#
...###....

output:

21

result:

ok 1 number(s): "21"

Test #12:

score: 0
Accepted
time: 0ms
memory: 2228kb

input:

15 15
#......#.#.###.
#.##...####..#.
##.....##.##.#.
#.###.#..#...##
....###.##.#.#.
.#..#.###.##.#.
######.#.####.#
.#....#..####..
.....#.###.##..
#..##.###.#####
#.##.#####..###
.#######..##.#.
##....#.##...#.
....#####.##.##
...#.#........#

output:

51

result:

ok 1 number(s): "51"

Test #13:

score: 0
Accepted
time: 0ms
memory: 2032kb

input:

15 15
###.#......#...
#.....#.#.###.#
#..#.#.###..#..
.#####.##.#..#.
...#.##.#..#.#.
#.#.###.....###
......#..##....
..##..#.#.#...#
..#..#..#......
....####...#..#
.####..#.#.##.#
###.#..#.#.#...
.#.##.##....##.
.#.#####.#..#.#
#.#.#.##.#.....

output:

61

result:

ok 1 number(s): "61"

Test #14:

score: 0
Accepted
time: 0ms
memory: 2088kb

input:

20 20
####....##.#####.##.
...####.##..#.####..
#.#.....#....##..###
###..###.#.#..#..###
##.##..#.##.####....
#...###.##.###.##...
.###...#####.##....#
#...###...##........
##.#.#.#.###.......#
#...##.##.#..##.##..
..##.##.######....##
#.#....#.##.##.##..#
##.....#..#.########
##....##.###...#....
...

output:

95

result:

ok 1 number(s): "95"

Test #15:

score: 0
Accepted
time: 0ms
memory: 2144kb

input:

20 20
.##.#.#.#..##..##.#.
..#.##.##.....##..##
.#....##...####..#..
##..###..#.#..##....
....#.##.##.###...##
.#.#.##.#..###....#.
######.#..#....#.#..
.##.###..##..##.###.
#.....#.#..#.##.#.#.
###.#####.##..#.##.#
...###.####.##...#.#
.#.....#.#.#.#..###.
#.#...#####..##.####
..####.##..##.#.#.##
...

output:

109

result:

ok 1 number(s): "109"

Test #16:

score: 0
Accepted
time: 0ms
memory: 2280kb

input:

30 30
###...###....#..#.#.#######...
.##..#.###.#.####.#...#..#.#..
.##..#######..##...#....##...#
..###..#..###...#.##.....#..##
#.#.#.#.#...###.######..#....#
###..##..###.#.###.#.####..#..
.....#...####..####..##.#.##.#
..#...######.##....#..###..###
..#####......#.#...##...#..##.
##..#.#.#.##......

output:

196

result:

ok 1 number(s): "196"

Test #17:

score: 0
Accepted
time: 0ms
memory: 2180kb

input:

30 30
######....###.#..#..###.#.##.#
.#..#...#.##..#.##...#...#####
##.#.##..##.#..###.#.#...####.
.####.###..##..#..#.#####..#.#
....##.##...#...##.####..####.
..###.##.##...##.##.###.####.#
#####......#.#...#..........#.
..#.....###..##.##..##.#.#####
..##...#.##.#.#.#..#.#.#.##...
...#.#.##..###....

output:

196

result:

ok 1 number(s): "196"

Test #18:

score: 0
Accepted
time: 0ms
memory: 2240kb

input:

40 40
......##...#.##..###.##.#.....#.#.#..#.#
#..###...####.####..###.#.#.#..#.##..##.
############.#.#...##..#...#........#.##
##.###.##########...###...####.##..#####
.###.#.##.##....##...#.##.#..#..##.#..#.
##...####.##.###.#.#.##...##..####.#####
#####..##.###.##.#.#.....####..##...##..
.#..###...

output:

290

result:

ok 1 number(s): "290"

Test #19:

score: 0
Accepted
time: 0ms
memory: 2236kb

input:

40 40
.####.####.....##.......#....########..#
.#.#....#####..#.##.###..#..#.#...##.#.#
.##.####..#.#...#.######..#.....##.#.##.
.##..##...#...#.#.#..#.###.....#..##.##.
..###.#.#....#######...#.##.##...##...#.
.##..#......##.##########.##.###..#..#.#
###.##.#.##...#.#####...###..##.#.#..###
#.###.....

output:

307

result:

ok 1 number(s): "307"

Test #20:

score: 0
Accepted
time: 1ms
memory: 2436kb

input:

50 50
#..#..###.###.####..#..#.##.#.##...#.#...########.
..#.##.##..##..##.##.##.##...#.#.####.#.##...##..#
....##.#.#..#.#.#.###...##.###.#...#.##..#..#..###
#.###.#.##.#......##...#..#..#..##..#####.##.#....
.##.####..##.#..#...##...#..#...##..##.##..#.##...
.###.#..#..####....##...#......##..#.##...

output:

488

result:

ok 1 number(s): "488"

Test #21:

score: 0
Accepted
time: 1ms
memory: 2356kb

input:

50 50
...##..#.#.##...#..##........##..###..##..#......#
.......#.#..#####.##.##.##.###.#.##.#.#..##......#
...##.##.########.##...#...#...#####...###.####.#.
#....###..###.###......##.#####..##.#...#.#...###.
#.##.##...#.#....##..##.##..##.#..####..#####.##..
.##.##.#.##...#.##.#.#....##..#..#.##.#...

output:

494

result:

ok 1 number(s): "494"

Test #22:

score: 0
Accepted
time: 0ms
memory: 2020kb

input:

1 10
.#........

output:

1

result:

ok 1 number(s): "1"

Test #23:

score: 0
Accepted
time: 0ms
memory: 2076kb

input:

1 11
#..........

output:

0

result:

ok 1 number(s): "0"

Test #24:

score: 0
Accepted
time: 0ms
memory: 2092kb

input:

1 21
#.......#............

output:

4

result:

ok 1 number(s): "4"

Test #25:

score: 0
Accepted
time: 0ms
memory: 2264kb

input:

2 12
..#.........
......#.....

output:

0

result:

ok 1 number(s): "0"

Test #26:

score: 0
Accepted
time: 0ms
memory: 2168kb

input:

2 22
....#.................
..........#......#..#.

output:

0

result:

ok 1 number(s): "0"

Test #27:

score: 0
Accepted
time: 0ms
memory: 2056kb

input:

33 3
#..
...
...
...
.#.
...
...
...
...
.#.
...
...
...
...
..#
...
...
...
...
...
...
..#
..#
...
...
...
...
...
...
...
.#.
...
.#.

output:

3

result:

ok 1 number(s): "3"

Test #28:

score: 0
Accepted
time: 0ms
memory: 2016kb

input:

42 1
.
.
.
.
.
.
#
.
.
.
.
.
.
.
.
#
.
.
.
.
.
#
.
.
.
.
#
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

output:

11

result:

ok 1 number(s): "11"

Test #29:

score: 0
Accepted
time: 0ms
memory: 2216kb

input:

13 37
##........#..........................
....................#................
..........#.............#............
..............#.....#.....#..........
....#....#.....................##....
....#........#.........#.............
........#.......#....................
....#............##............

output:

221

result:

ok 1 number(s): "221"

Test #30:

score: 0
Accepted
time: 0ms
memory: 2140kb

input:

31 13
.....#......#
........#....
....#.#......
....#........
.............
.#.........#.
......#......
............#
..#.#......#.
.............
.......#.....
.....#.......
..#..........
.##.#........
.#..#........
..........##.
.............
...........##
............#
.............
.......#.#...
...

output:

184

result:

ok 1 number(s): "184"

Test #31:

score: 0
Accepted
time: 0ms
memory: 2556kb

input:

44 44
...................#...........#............
.#............#.#..#.#......................
...#....#.........##....#...##..............
.......#....................................
.....##...#...##..........#.................
..##.#...........#.........##........#......
.....#.....................

output:

833

result:

ok 1 number(s): "833"

Test #32:

score: 0
Accepted
time: 1ms
memory: 2552kb

input:

49 46
......##.................#....................
...#.................#.....#..#..........#.#..
#.....#...............#......##....#.....#....
..........#............##...................##
...#......#.#..............###..#..........#..
..................................#...........
...........#...

output:

956

result:

ok 1 number(s): "956"

Test #33:

score: 0
Accepted
time: 1ms
memory: 2540kb

input:

50 50
..#..#................#.#.......#.................
#...........................#..#..................
...#..............#....#...............#..........
.........#..........#........................#....
...#....#..........#..#.#................##..#....
...#.........#.#.#..................#.....

output:

1020

result:

ok 1 number(s): "1020"

Test #34:

score: 0
Accepted
time: 0ms
memory: 2160kb

input:

1 7
.......

output:

4

result:

ok 1 number(s): "4"

Test #35:

score: 0
Accepted
time: 0ms
memory: 2044kb

input:

1 10
..........

output:

0

result:

ok 1 number(s): "0"

Test #36:

score: 0
Accepted
time: 1ms
memory: 2456kb

input:

31 35
...................................
...................................
...................................
...................................
...................................
...................................
...................................
...................................
.........

output:

543

result:

ok 1 number(s): "543"

Test #37:

score: 0
Accepted
time: 1ms
memory: 2264kb

input:

33 33
.................................
.................................
.................................
.................................
.................................
.................................
.................................
.................................
.........................

output:

545

result:

ok 1 number(s): "545"

Test #38:

score: 0
Accepted
time: 1ms
memory: 2524kb

input:

42 42
..........................................
..........................................
..........................................
..........................................
..........................................
..........................................
.......................................

output:

0

result:

ok 1 number(s): "0"

Test #39:

score: 0
Accepted
time: 1ms
memory: 2652kb

input:

47 48
................................................
................................................
................................................
................................................
................................................
................................................
...

output:

0

result:

ok 1 number(s): "0"

Test #40:

score: 0
Accepted
time: 0ms
memory: 2608kb

input:

50 50
...##.#......#....#............#...........#......
...#........#.............#.....##...#.....#.....#
.......#..#..#.#...........#...............#......
.......#........#......#.................#......#.
#....................................#...#........
........#.................#.........#.....

output:

909

result:

ok 1 number(s): "909"

Test #41:

score: 0
Accepted
time: 1ms
memory: 2408kb

input:

50 50
.##...###......#......#.......###.....#.#..#.#....
.#...#.####........#.##......#...##..#..#.........
..###..#....#.......#..##.......#...#.....#...#..#
##.#....#...#...#...##.#..##.#.#..#.......#...##..
##.#..#........#.#..#.##.....#..##.....##..#...#..
.............#..#....##.....#..##.....#...

output:

688

result:

ok 1 number(s): "688"

Test #42:

score: 0
Accepted
time: 1ms
memory: 2400kb

input:

50 50
#....#.####.###........##.#...#......#..##.##.##..
#####.#.#.######..##.###.....#.#.#...#.###.#.#....
.#.#####.#..##.#...#....#.##...#.##..####.#.#...##
#.#...##..##....#....######.##.####...#.##.##.####
#..###.....#.##..###...###.##...#..####....##.##.#
#....#.#...#.##...###..###....#.###..#....

output:

536

result:

ok 1 number(s): "536"

Test #43:

score: 0
Accepted
time: 0ms
memory: 2344kb

input:

50 50
#####.#####.###..###..#######.##.#.####.#.#.###.##
###.#.####.##...##.#.##.##..####.######.#..###.#..
###...####.########..###.###.###..###.#####..#####
###########..##.###..#..#####..#....##..######.#.#
#######.####.#.#####.#...######..#.#####.#.#######
####.#.##.#######..######.##.###.##.###...

output:

371

result:

ok 1 number(s): "371"

Test #44:

score: 0
Accepted
time: 0ms
memory: 2240kb

input:

50 50
..##.####.#..#.##..#.#.#####..####.########.###.##
###.###..#.##.##..########...#########..##########
#########.#######.###..####################..#####
#######.##.###.###.###.#..####.#####...###..###.#.
##.#.##############.###########.####...##########.
.....#.#.#####.#...#.##################...

output:

299

result:

ok 1 number(s): "299"

Test #45:

score: 0
Accepted
time: 0ms
memory: 2312kb

input:

50 50
############.########################.###########.
####.##########.#############.#############.######
#####.#######.###############.#############.#.##.#
..#.##.#####..###.###########.########.####.######
###############.#.########.##############.######..
######.#################.#..##.########...

output:

189

result:

ok 1 number(s): "189"

Test #46:

score: 0
Accepted
time: 1ms
memory: 2548kb

input:

43 44
.................#....#..#...............##.
....#..#.............................#......
.............#.....................#.#......
.#.....#......#...............#.............
#...............#...#...............#.......
.#.....#..#...........#.......#.............
..#........................

output:

776

result:

ok 1 number(s): "776"

Test #47:

score: 0
Accepted
time: 0ms
memory: 2244kb

input:

15 49
.##..#........#....#....##.....#..#.......##...#.
...#.....##....##...#.#...........#..#.........#.
#..#.........##.....#.#..#.....#.#.#..#......#...
.................#...........#.....#...........#.
..#..#.....##...#......#....#.....#........#..#..
#.#.......#..........#..#...#..................

output:

218

result:

ok 1 number(s): "218"

Test #48:

score: 0
Accepted
time: 0ms
memory: 2208kb

input:

5 10
#..#......
.#....##..
..###...##
..#...#..#
#....#....

output:

3

result:

ok 1 number(s): "3"

Test #49:

score: 0
Accepted
time: 1ms
memory: 2544kb

input:

49 49
#.#.##...#.....#..##..##..##....##..###....##.##.
####.#....#......##.........##...##......#.#...##
..#...#.##....#......###...##..#.##.#.......##.#.
.....###..#....#.##.#....####..##..#..##....#..#.
#####..#...#....#.######......#..#....###..#.###.
.#.#.....###..#...#..#..#####...#.##......#....

output:

530

result:

ok 1 number(s): "530"

Test #50:

score: 0
Accepted
time: 0ms
memory: 2080kb

input:

22 22
###.#.#######.###.##.#
..###.##...#.#.#..#..#
.####.####.###.#.....#
#####..#.##.###..#.#..
###.#.#.#.#...###.###.
...###....##..##.....#
.#..##.#......#.#..#.#
.###.##.#.....#...#.#.
##..#.#######.##...#..
##...###...##.#..#####
##.#..##.##....##.###.
..#.##...##.###.##.##.
#####.##.#.#.#.##....

output:

105

result:

ok 1 number(s): "105"

Test #51:

score: 0
Accepted
time: 0ms
memory: 2064kb

input:

13 31
.###..##.#..##.#..#.#..#.###..#
.#...######....##.####.#..#.###
##..##..######...#.#####..#####
###.######.#..#.#.##..##.###.#.
##############.###..###.##.#.#.
##..##...#..#..#####.##.##....#
.###.#.##..#.....#...#..##.##.#
####.##.....######.##.#.##.#..#
...####.#.###.###.##.#..#.#.#..
..#..#...

output:

56

result:

ok 1 number(s): "56"

Test #52:

score: 0
Accepted
time: 0ms
memory: 2132kb

input:

33 33
#.###.##..####.##.##..#.##..#####
#.#.####.##.####.#####.##.####.##
#####...#.##.###########.#.####.#
###.##....##.#######.####.#######
##################.##..#######..#
##.###.#.###.##########.###.##..#
.#..#####.#####.#####.####..#.###
.##.#.###.####.#####.####.###.##.
.###.#..############.#...

output:

160

result:

ok 1 number(s): "160"

Test #53:

score: 0
Accepted
time: 0ms
memory: 2620kb

input:

50 50
......#.....................................######
......#.....................................#.....
......#.....................................#.....
......#.....................................#.....
......#.....................................#.....
......#...................................

output:

267

result:

ok 1 number(s): "267"

Test #54:

score: 0
Accepted
time: 1ms
memory: 2696kb

input:

50 50
......#..#....###.....#.#......#..................
..#....#......#...................................
.###..........#...#.....#......#.....#...#.##.....
#.........#...#.....#.............................
#.............#..#..#.....#.....#.........##......
..............#..#....#....#........#.....

output:

862

result:

ok 1 number(s): "862"

Test #55:

score: 0
Accepted
time: 0ms
memory: 2608kb

input:

50 50
...#..............#.........#.......#........#....
.........#.#.#..#...............#.#..............#
.............#...#....##......#.#..............#..
.#.#...#.......##...........##...#....#...........
.#.#....#..#.......#.#....#.#...........#.........
..##.......#..........#...#.#....#.#......

output:

926

result:

ok 1 number(s): "926"

Test #56:

score: 0
Accepted
time: 0ms
memory: 2696kb

input:

50 50
............................................#.....
............................................#.....
............................................#.....
............................................#.....
............................................#.....
..........................................

output:

406

result:

ok 1 number(s): "406"

Test #57:

score: 0
Accepted
time: 1ms
memory: 2676kb

input:

50 50
.........#########################################
..................................................
..................................................
..................................................
###################################...............
..................................#.......

output:

664

result:

ok 1 number(s): "664"

Test #58:

score: 0
Accepted
time: 1ms
memory: 2488kb

input:

50 50
.#........................................#.#.##..
.#........#...............................#...##..
##........................................#...##..
.#.......................#.............#..#...##..
###########################################...##..
..........................................

output:

650

result:

ok 1 number(s): "650"

Test #59:

score: 0
Accepted
time: 1ms
memory: 2556kb

input:

50 50
..#...#.....#.........#...#.#....#..#...#.........
............#..#...#....##.........#....#..#......
............#.......#..................##....#####
...#........#................#..........#....#..#.
............#....#.##........#....#.....#....#....
...##...#...###########################...

output:

939

result:

ok 1 number(s): "939"

Test #60:

score: 0
Accepted
time: 0ms
memory: 2412kb

input:

50 50
.#######..####.....##..#....#.#.##.####...#..#...#
#.##..###.####.###.#.........####.##....#.....##..
##.#.##..####.####.##.##..#...#.#......###.#..##..
###..#.#..#####.#####....####...#.#########...#.#.
.#.###.##.###...##.##..#.##.#...#..#.###.######..#
###..##..###..#.#..#.####.#..###.#..#.....

output:

429

result:

ok 1 number(s): "429"

Test #61:

score: 0
Accepted
time: 0ms
memory: 2616kb

input:

50 50
..##................................#..#.....#....
..##................................#..#.....#....
..##................................#..#.....#....
..#####.............................#..#.....#....
..##..#.............................#..#.....#....
..##..#.............................#.....

output:

0

result:

ok 1 number(s): "0"

Test #62:

score: 0
Accepted
time: 1ms
memory: 2552kb

input:

50 50
.............................#......#...#...#.....
.............................#......#...#...#.....
.............................#......#...#...#.....
.............................#......#...#...#.....
.............................#......#...#...#.....
.............................#......#.....

output:

264

result:

ok 1 number(s): "264"

Test #63:

score: 0
Accepted
time: 1ms
memory: 2700kb

input:

50 50
.........#..#....................##..#......#.....
.........#..#....................##..#......#.....
.........#..#....................##..#......#.....
.........#..#....................##..#...#..#.....
.........#..#....................##..#......#.....
.........#..#....................##..#....

output:

763

result:

ok 1 number(s): "763"

Test #64:

score: 0
Accepted
time: 1ms
memory: 2628kb

input:

50 50
.....#....#.###.#.....#...........................
.....#....#.###.#.....#......................#####
.....#....#.###.#.....############################
.....#....#.###.#####...#.........................
.....#....#.###.#...#...#.........................
.....#....#.###.#...#...#.................

output:

365

result:

ok 1 number(s): "365"

Test #65:

score: 0
Accepted
time: 1ms
memory: 2488kb

input:

50 50
..........................................##.#.#..
..........................................##.#.#..
############################################.#.#..
..#.........#................#............##.#.#..
..#.........#................#............##.#.#..
#############................#............

output:

301

result:

ok 1 number(s): "301"

Extra Test:

score: 0
Extra Test Passed