难题

• 如果迷宫n * m无法解析，则打印0
• 如果可以解决迷宫n * m（以1种或多种方式），则打印1。

（所以我不是在问路径，但是是否有可能解决！！！）

输入数组（2d）：

[[0,0,0,0,0,0,1],[0,0,0,0,0,1,0],[0,0,0,0,1,0,0],[1,0,0,0,0,0,0]]

XXXXXXXXX
XS     XX
X     X X
X    X  X
XX     FX
XXXXXXXXX

0 = can pass through
1 = can not pass trough
[0][n] is the last block of the first line
[m][0] is the first block of the last line

规则 起始位置为0,0，结束位置为n，m您只能水平和垂直移动最短代码获胜

CJam，42 41 39 36 35字节

Wq3>~_s,{{[{_2$+0<{e<_}*}*]}%z}*sW=

基于这个答案的想法。

4个字节的感谢优化器。

输入格式：

[[0 0 0 0 0 0 1] [0 0 0 0 0 1 0] [0 0 0 0 1 0 0] [1 0 0 0 0 0 0]]

Dyalog APL，27个字符

⊃⌽∨.∧⍨⍣≡1≥+/¨|∘.-⍨,(~×⍳∘⍴)⎕

⎕评估输入。APL区分矩阵和向量的向量。该程序假定输入为矩阵。

(~×⍳∘⍴)A是相当于的叉子(~A) × ⍳⍴A。需要避免重复提及⎕或引入变量。

⍴A是的形状A。对于4×7矩阵，形状为4 7。

⍳是索引生成器。 ⍳4是1 2 3 4。 ⍳4 7是(1 1)(1 2)...(4 7)按4 x 7矩阵排列的向量。

~A翻转的位A。

×通过乘以⍳⍴A翻转的位，我们保留了所有自由单元的坐标，并将所有壁变为0 0。

,拉扯坐标对矩阵，即将其线性化为向量。在这种情况下，向量将由对组成。

∘.-⍨A或A∘.-A减去A成对元素。请注意，此处的元素A本身是对。

| 绝对值

+/¨对每对绝对值求和。这为我们提供了迷宫中每对细胞之间的网格距离，墙壁除外。

1≥我们仅在距离不超过1的邻居中被发现，这也排除了墙壁。现在我们有了一个图的邻接矩阵。

∨.∧⍨⍣≡ Floyd--Warshall的传递闭包算法

(f⍣n)A（此处未使用），其中n整数是幂运算符。它适用f于A n时间：f f ... f A。

(f⍣g)A在哪里g是一个函数，是定点运算符，又称“功率极限”。它使运算被系列A，f A，f f A，...，直到((f⍣i)A) g ((f⍣(i+1))A)返回true一些i。在这种情况下，我们将match（≡）用作g。

∨.∧⍨A还是A∨.∧AFloyd算法的一个步骤。 f.g是矩阵乘法（+.×）的一般化，这里我们使用合取（∧）和析取（∨）代替+和×。

⊃⌽ 在⍣≡应用该步骤足够的次数并达到稳定状态之后，我们必须查找矩阵的右上角以获得结果，因此将其翻转（⌽）并获取第一个左上角的项目（⊃）。

⍣≡步骤的可视化

Python，164字节

def s(a):
 d=[(0,0)]
 while d:i,j=d.pop();a[i][j]=2;d+=[(x,y)for x,y in[(i-1,j),(i,j-1),(i+1,j),(i,j+1)]if len(a[0])>y>-1<x<len(a)and a[x][y]<1]
 return a[-1][-1]>1

我不愿发布此消息，因为实际上这是我通常会打水的方式，只是打了些高尔夫球。但是无论如何，这是事实。

Perl，73个字节

69字节的代码+ 4字节的代码-n0E（不确定标签在2014年的计数方式，因此我将其计算为4而不是2，但这没关系）。

/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0

在线尝试！ （如果您更换1111011同线1111111，迷宫是不可解的了，输出会0代替1：！在线试玩）

说明：

这段代码将找到迷宫中每个可到达的单元格（并用标记A）：如果一个单元格触摸到标记为的单元格，则该单元格A是可访问的，我们也将其标记为A；然后我们再次执行（redo）。这要归功于两个正则表达式：s/(^0|A)(.{@{+}})?0/A$2A/s检查空格是在a的右边还是底部A，而s/0(.{@{+}})?A/A$1A/s检查空格是在a的左边还是顶部A。最后，如果最后一个单元格包含一个A可访问的单元格，否则它不是可访问的（这是要say/A$/+0进行的检查；+0此处用于确保结果为0或1代替空字符串 and 1）。
请注意，/.*/它将匹配整行，因此设置@+到第一行末尾的索引，恰好是一行的大小，允许使用来.{@{+}}精确匹配一行中的所有字符。（@{+}等价于@+，但是前者只能在regex中使用）

Ruby，133130129 个字符

a=eval gets
f=->x,y{a[x][y]=1
[[-1,0],[1,0],[0,-1],[0,1]].map{|o|d,e=x+o[0],y+o[1]
f[d,e]if a[d]&&a[d][e]==0}}
f[0,0]
p a[-1][-1]

输入上STDIN，输出1或0上STDOUT。

烦人的长。它只是1从进行s 的泛洪(0, 0)，然后检查“ end”正方形是否为1。

Java，418字节

import java.util.Scanner;public class Solvable{static int w,h;public static void main(String[] a){String[]i=new Scanner(System.in).nextLine().split(";");h=i.length+2;w=i[0].length()+2;int[]m=new int[w * h];for(int x=1;x<w-1;x++)for(int y=1;y<h-1;y++)m[y*w+x]=i[y-1].charAt(x-1)<'.'?0:1;f(m,w+1);System.out.println(m[w*h-w-2]>0?0:1);}static void f(int[]m,int i){if(m[i]>0){m[i]--;f(m,i-1);f(m,i+1);f(m,i-w);f(m,i+w);}}}

我的第一个代码高尔夫。我不知道为什么选择Java-这对于xD打高尔夫球真是太糟糕了

示例迷宫将通过stdin输入，如下所示：

......#;.....#.;....#..;#......

Python 184188

def f(a,x=0,y=0,h=[]):s=h+[[x,y]];X,Y=len(a[0]),len(a);return([x,y]in h)==(x>=X)==(y>=Y)==(x<0)==(y<0)==a[y][x]<(x==X-1and y==Y-1or f(a,x-1,y,s)|f(a,x+1,y,s)|f(a,x,y-1,s)|f(a,x,y+1,s))

这比我原本想的要长得多：(无论如何，一旦我不能再打高尔夫球了，我会加一个解释。

J，75个字符

邻接矩阵的供电（时间和内存效率低下）。（用英语叫powering吗？）

   ({.@{:@(+./ .*.^:_~)@(+:/~@,*2>(>@[+/@:|@:->@])"0/~@,@(i.@#<@,"0/i.@#@|:)))

一些测试用例：

   m1=. 0 0 0 0 0 0 1,. 0 0 0 0 0 1 0,.  0 0 0 0 1 0 0,. 1 0 0 0 0 0 0
   m2=. 0 1 1 ,. 0 0 0
   m3=. 0 1 0 ,. 1 1 0
   m4=. 0 1 1 0 ,. 0 0 1 0
   ({.@{:@(+./ .*.^:_~)@(+:/~@,*2>(>@[+/@:|@:->@])"0/~@,@(i.@#<@,"0/i.@#@|:))) every m1;m2;m3;m4
1 1 0 0

Python 3，147字节

def f(g,s=[1]):w=len(g[0])+1;*p,x=s;return~-(x in p)*~-[j for i in g+[w*[1]]for j in[1]+i][x]and max(f(g,s+[x+a])for a in(-1,1,-w,w))or x==w*len(g)

在线尝试！

我在ASCII道路上查找最短路线的答案的端口。

Python 3，184字节

f=lambda m,x=0,y=0,n=0:n<len(m)*len(m[0])and m[x][y]<1and((x,y)==(len(m)-1,len(m[0])-1)or any(0<=i<len(m)and 0<=j<len(m[0])and f(m,i,j,n+1)for i,j in[(x-1,y),(x,y-1),(x+1,y),(x,y+1)]))

在线尝试！