牛客 四面楚歌

在游戏中，由于一个错误的决定，你的士兵被敌人包围和镇压。为了挽回人员损失，你必须打开金手指暂停敌人士兵的移动，以便试图让你的士兵成功突破。

已知地图是一块$n\times m$每个格子有以下几种类型：

.：这意味着这地。

1：这意味着这里有敌方士兵，不允许通过。敌方士兵不会移动，因为他们打开了金手指。

0：说这里有我们的士兵。

现在规定我们的士兵只能从上/下/左/右四个方向移动。只要一个士兵移出地图边界，即使士兵成功突破。有多少士兵能成功突破？

第一行有两个正整数$n,m,n\le 1000,m\le 1000$。接下来$n$行，每行$m$表示地图情况的个字符。

成功输出突破的士兵数量。

输入

4 5 111.. 101.. 111.. ..0.. 

输出

1 

#include  using namespace std; char mg[1010][1010]; int dx[4] = { 
        -1, 0, 1, 0}, dy[
       
        4
        ] 
        = 
        { 
         
        0
        , 
        1
        , 
        0
        , 
        -
        1
        }
        ; 
        int n
        , m
        , ans
        , xi
        , yi
        ; 
        void 
        dfs
        (
        int x
        , 
        int y
        ) 
        { 
          
        for 
        (
        int i 
        = 
        0
        ; i 
        <= 
        3
        ; i
        ++
        ) 
        { 
          
        //顺时针遍历四周 xi 
        = x 
        + dx
        [i
        ]
        , yi 
        = y 
        + dy
        [i
        ]
        ; 
        if 
        (xi 
        >= 
        0 
        && xi 
        <= n 
        + 
        1 
        && yi 
        >= 
        0 
        && yi 
        <= m 
        + 
        1 
        && mg
        [xi
        ]
        [yi
        ] 
        != 
        '1'
        ) 
        { 
          
        //迷宫范围内&没敌人 
        if 
        (mg
        [xi
        ]
        [yi
        ] 
        == 
        '0'
        ) ans
        ++
        ; mg
        [xi
        ]
        [yi
        ] 
        = 
        '1'
        ; 
        // flag 
        dfs
        (xi
        , yi
        )
        ; 
        } 
        } 
        } 
        int 
        main
        (
        ) 
        { 
          cin 
        >> n 
        >> m
        ; 
        // n*m的迷宫 1~n 1~m 
        for 
        (
        int i 
        = 
        1
        ; i 
        <= n
        ; i
        ++
        ) 
        { 
          
        for 
        (
        int j 
        = 
        1
        ; j 
        <= m
        ; j
        ++
        ) 
        { 
          cin 
        >> mg
        [i
        ]
        [j
        ]
        ; 
        } 
        } 
        dfs
        (
        0
        , 
        0
        )
        ; 
        //从墙开始 cout 
        << ans 
        << endl
        ; 
        return 
        0
        ; 
        }