Java 为什么我们要在SPOJ（ALLIZWELL）中应用BFS/DFS？为什么简单的暴力不起作用？

通过暴力，我的意思是，如果我取字母表a、l、I、w、e、z的6个变量a、l、I、w、e、z，并将它们的出现次数计算为：

if(a<1||l<4||i<1||w<1||e<1||z<2)
        {
            System.out.println("NO");

        }
        else
            System.out.println("YES");

---

if（a仅仅因为矩阵包含足够多的字母，并不意味着有一条路径可以将它们按正确的顺序排列

举个简单的例子，考虑

艾尔兹韦尔

你需要一个与A相邻的L，但没有

你玩过“Boggle”游戏吗？这基本上是同一个概念。
在大多数情况下，暴力不起作用的说法是实际意义上的（即时间太长）.DFS/BFS尝试确定哪些“路径”是不必要的，以避免浪费时间检查不必要的东西。我还建议您阅读该页。因此，路径是否意味着我只能垂直/水平/对角？是的。根据您链接的问题说明：“从任何单元到其所有相邻单元都有一条路径。相邻单元可以共享一条边或一个角。”
    import java.io.*;

    public class Main {

        public static void main(String asd[]) throws Exception {

            Parser in = new Parser(System.in);
            int t=in.nextInt();
            while(t-->0)
            {
                int r=in.nextInt();
                int c=in.nextInt();int a,l,i,z,w,e;
                a=l=i=z=w=e=0;
                for(int j=0;j<r;j++)
                {
                    String s=in.next();
                    for(int k=0;k<s.length();k++)
                    {
                        char ch=s.charAt(k);
                        switch(ch)
                        {
                            case 'A':a++;break;
                            case 'L':l++;break;
                            case 'I':i++;break;
                            case 'Z':z++;break;
                            case 'W':w++;break;
                            case 'E':e++;break;
                        }
                    }
                }
                if(a<1||l<4||i<1||w<1||e<1||z<2)
                {
                    System.out.println("NO");

                }
                else
                    System.out.println("YES");
            }

        }
    }
   // for inputting  
    class Parser {
        final private int BUFFER_SIZE = 1 << 16;

        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Parser(InputStream in) {
            din = new DataInputStream(in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public long nextLong() throws Exception {
            long ret = 0;
            byte c = read();
            while (c <= ' ') c = read();
            boolean neg = c == '-';
            if (neg) c = read();
            do {
                ret = ret * 10 + c - '0';
                c = read();
            } while (c > ' ');
            if (neg) return -ret;
            return ret;
        }

        //reads in the next string
        public String next() throws Exception {
            StringBuilder ret = new StringBuilder();
            byte c = read();
            while (c <= ' ') c = read();
            do {
                ret = ret.append((char) c);
                c = read();
            } while (c > ' ');
            return ret.toString();
        }

        public int nextInt() throws Exception {
            int ret = 0;
            byte c = read();
            while (c <= ' ') c = read();
            boolean neg = c == '-';
            if (neg) c = read();
            do {
                ret = ret * 10 + c - '0';
                c = read();
            } while (c > ' ');
            if (neg) return -ret;
            return ret;
        }

        private void fillBuffer() throws Exception {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) buffer[0] = -1;
        }

        private byte read() throws Exception {
            if (bufferPointer == bytesRead) fillBuffer();
            return buffer[bufferPointer++];
        }
    }