Q:

Caça palavras não encontra a palavra

Galera, tô tentando fazer um jogo de caça palavras em java, mas não estou conseguindo encontrar a palavra, alguém pode ajudar?  
Segue o código:
import java.io.BufferedReader; 
import java.io.FileReader;
import java.io.IOException; 
import java.util.Scanner;

public class File {
public static void main(String[]args) throws Exception{
//        File arquivo = new File ("C:\\teste01.txt");

FileReader arquivo = new FileReader ("C:\\teste01.txt");
    BufferedReader br = new BufferedReader(arquivo);
    Scanner sc = new Scanner(System.in);

char[][] matriz = null;
    String entrada = null;
    int coluna = 0;
    boolean primeira = true;
    while (br.ready()){
        String linha = br.readLine();
        if(primeira) {
            String []b = linha.split(" ");
            int a = Integer.parseInt(b[0]);
            int d = Integer.parseInt(b[1]);
            matriz = new char[a][d];
            primeira = false;
        } else {
            char[] auxLinha = linha.toCharArray();

            for (int i = 0; i < auxLinha.length; i++) {
                matriz[coluna][i] = auxLinha[i];
            }

            coluna++;
        }
    }

    for (int i = 0; i < matriz.length; i++) {
        for (int j = 0; j < matriz[i].length; j++) {
            System.out.print(matriz[i][j]+" ");
        }
        System.out.println("\n");
    }

br.close();

   int i, j, k, n = 0, p = 0, t; //Contadores

int encontrada = 0; // SIM = 1. NÃO = 0.

 char palavra[][] = null ;
for (i = 0; i < p; i++)
     System.out.println("DIGITE A PALAVRA:\n");
        String palavraNextLine = sc.nextLine(); //Armazena as palavras que serão buscadas na matriz.

System.out.println("RESULTADO:\n");

for (k = 0; k < p; k++) //Para cada palavra
{
    //Inicialmente a palavra é considerada Não-Encontrada.
    encontrada = 0;

    for (i = 0; i < n; i++) //Para cada linha da matriz
    {
        for (j = 0; j < n; j++) //Para cada coluna da matriz
        {
            if (palavra[k][0] == matriz[i][j]) //Se a primeira letra for encontrada
            {
                if (palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for encontrada acima (Norte)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k]).length; t++)
                        if (palavra[k][t] != matriz[i - t][j])
                            encontrada = 0;

                    if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i + 1][j]) //Se a segunda letra for encontrada abaixo (Sul)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i + t][j])
                            encontrada = 0;

                     if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i][j + 1]) //Se a segunda letra for encontrada a direita (Leste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i][j + t])
                            encontrada = 0;

                     if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i][j - 1]) //Se a segunda letra for encontrada a esquerda (Oeste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i][j - t])
                            encontrada = 0;

                    if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i - 1][j + 1]) //Se a segunda letra for encontrada acima-direita (Nordeste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i - t][j + t])
                            encontrada = 0;

                     if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i - 1][j - 1]) //Se a segunda letra for encontrada acima-esquerda (Noroeste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i - t][j - t])
                            encontrada = 0;

                    if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i + 1][j + 1]) //Se a segunda letra for encontrada abaixo-direita (Sudeste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i + t][j + t])
                            encontrada = 0;

                    if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }

                if (palavra[k][1] == matriz[i + 1][j - 1]) //Se a segunda letra for encontrada abaixo-esquerda (Sudoeste)
                {
                    encontrada = 1;

                    for (t = 0; t < (palavra[k].length); t++)
                        if (palavra[k][t] != matriz[i + t][j - t])
                            encontrada = 0;
                     if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }
            }
        }

                     if (encontrada == 1){
                        break;
                }else{
                    return;
                    }
                }
    }

    //Depois da verificação ele diz se a palavra foi encontrada ou não, então passa para a verificação da próxima palavra.
    if (encontrada == 1){
        System.out.println(" PALAVRA ENCONTRADA\n");
    }else{
        System.out.println(" PALAVRA NAO ENCONTRADA\n");
}
}
}

A:

Use o tipo boolean! Ele é seu amigo e serve para ajudar! Não utilize int com 0 e 1 para representar valores verdadeiro/falso ou sim/não.
Aprenda a identar o código. Só de ver a forma como você posicionou os blocos else, me dá a entender que você os colocou no lugar errado e com isso, você acaba entendendo errado o seu próprio código.
Isso daqui, que aparece repetido nove vezes no seu código NÃO faz o que você quer:
        if (encontrada == 1) {
            break;
        } else {
            return;
        }

Em especial, o return dentro do método main faz o seu programa abortar imediatamente, não importando se ele encontrou ou não a palavra. No caso do seu programa, você não deveria usar return em lugar nenhum.
Você não verifica os limites da matriz antes de acessar os seus elementos, e como resultado terá alguns IndexOutOfBoundsException. Por exemplo, nesta linha:
if (palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for encontrada acima (Norte)

Adivinha o que vai acontecer se i tiver o valor 0? O correto é verificar isso antes de tentar acessar o índice:
if (i > 0 && palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for encontrada acima (Norte)

Você pode dar nome para os seus laços for, while e do-while. Por exemplo:
a: for (int i = 0; i < n; i++) {
    b: for (int j = 0; j < n; j++) {
        // ... blablabla
        break a; // Interrompe o laço a (e também o laço b).
        // ... blablabla
    }
}

Usando isso, a lógica do seu programa pode ser simplificada um bocado. O mesmo vale para continue.
Dar o nome da sua classe de File é uma péssima ideia, afinal isso vai te dar dor-de-cabeça quando você for precisar da classe java.io.File. Use um nome diferente, tal como CacaPalavras.
Utilize a sintaxe try-with-resources para ler dados de arquivos, tal como você faz com o seu BufferedReader.
Prefira declarar as variáveis no ponto aonde serão usadas (dentro do for) do que todas elas juntas do lado de fora. A regra de ouro é não deixar elas terem um escopo maior que o necessário.
O algoritmo fica bem mais simples se você dividi-lo em vários métodos.

A:

Uma abordagem orientada a objetos
Este problema pode ser resolvido também com um pouco da boa e velha orientação a objetos, diminuindo a repetição de código e a quantidade de loops e ifs a fim de facilitar o desenvolvimento e ter um resultado final mais simples:
public class CacaPalavras {

    public static boolean palavraEncontrada(char[][] tabuleiro, String palavra) {

        for (int posicaoY = 0; posicaoY < tabuleiro.length; posicaoY++) {

            for (int posicaoX = 0; posicaoX < tabuleiro[posicaoY].length; posicaoX++) {

                if (tabuleiro[posicaoY][posicaoX] == palavra.charAt(0)) {

                    for(Direcao direcao: Direcao.values()) {
                        if (TabuleiroNavegavel.existePalavra(palavra, tabuleiro, direcao, 
                                posicaoY, posicaoX)) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
}

Eu utilizei a mesma lógica proposta por você: percorrer o tabuleiro da esquerda para a direita e de cima para baixo e, ao encontrar uma letra que coincida com a primeira letra da palavra procurada, passa a percorrer o tabuleiro nos mais diversos sentidos para ver se encontra a palavra completa.
O restante do código que faz a mágica acontecer está abaixo:
class TabuleiroNavegavel {
    public static boolean existePalavra(String palavra, char[][] tabuleiro, 
                    Direcao direcao, int posicaoInicialY, int posicalInicialX) {

        StringBuilder palavraEncontrada = new StringBuilder();

        NavegadorLetras letras = direcao.letras(tabuleiro, 
                                    posicaoInicialY, posicalInicialX);
        
        int qtdLetrasLidas = 0;
        
        while(letras.temProxima() && qtdLetrasLidas <= palavra.length()) {
            palavraEncontrada.append(letras.proxima());
            qtdLetrasLidas++;
        }
        return palavraEncontrada.toString().equals(palavra);
    }
}

interface NavegadorLetras {
    boolean temProxima();
    char proxima();
}

interface LetrasNavegaveis {
    NavegadorLetras navegador(final char[][] tabuleiro, 
            final int posicaoInicialY, final int posicalInicialX);
}

enum Direcao {
    LESTE(new Leste()), 
    SUDESTE(new Sudeste()),
    SUL(new Sul()),
    NORDESTE(new Nordeste());
    
    private LetrasNavegaveis letrasNavegaveis;
    
    Direcao(LetrasNavegaveis letrasNavegaveis) {
        this.letrasNavegaveis = letrasNavegaveis; 
    }
    public NavegadorLetras letras(char[][] tabuleiro, 
                            int posicaoInicialY, int posicalInicialX){
        return letrasNavegaveis.navegador(tabuleiro, posicaoInicialY, posicalInicialX);
    }
}

class Leste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {
        
        return new NavegadorLetras() {
            int posicaoX = posicalInicialX; 
            int posicaoY = posicaoInicialY;
            
            public boolean temProxima() {
                return posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoX++;
                return letra;
            }
        };
    }
}

class Sudeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {
        
        return new NavegadorLetras() {
            
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;
            
            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length
                    && posicaoX >= 0 && posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                posicaoX++;
                return letra;
            }
        };
    }
}

class Sul implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,
                            final int posicalInicialX) {
        
        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;

            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                return letra;
            }
        };
    }
}

class Nordeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, 
                            final int posicaoInicialY, final int posicalInicialX) {
        
        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;
        
            public boolean temProxima() {
                return posicaoY >= 0 && posicaoY < tabuleiro.length
                    && posicaoX < tabuleiro[posicaoY].length;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY--;
                posicaoX++;
                return letra;
            }
        };
    }
}

Um exemplo de código consumidor:
@Test
public void cacaPalavras() {
    
    char[][] tabuleiro = new char[][] { 
            {'R','X','L','X','A'},
            {'X','A','U','X','X'},
            {'R','U','I','V','A'},
            {'X','A','Z','V','X'},
            {'C','X','A','X','A'}};
    
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RAIVA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "LUIZA"));
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "CAIXA"));
    assertFalse(CacaPalavras.palavraEncontrada(tabuleiro, "INEXISTENTE"));
}

Você pode envolver este código com a sua lógica de ler o tabuleiro de um arquivo e solicitar uma lista de palavras do usuário :-)
Como estender a solução
Veja que eu só implementei o padrão mais ocidental de leitura, por assim dizer: leste, sul, sudeste, nordeste.
Mas para implementar mais padrões é muito simples. Você não precisa inserir código no meio de um grande e complexo método nem reprogramar o fluxo do programa. Ao invés, você define um nova direção de leitura na enumeração e declara uma classe especializada em ler nesta direção.
Se você quiser por exemplo implementar agora a direção sudoeste de leitura, basta declarar a seguinte classe:
class Sudoeste implements LetrasNavegaveis {

    public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,
                            final int posicalInicialX) {
        
        return new NavegadorLetras() {
            int posicaoY = posicaoInicialY;
            int posicaoX = posicalInicialX;
        
            public boolean temProxima() {
                return posicaoY < tabuleiro.length
                    && posicaoX >= 0;
            }
            public char proxima() {
                char letra = tabuleiro[posicaoY][posicaoX];
                posicaoY++;
                posicaoX--;
                return letra;
            }
        };
    }
}

E adicionar esta nova direção de leitura na enumeração:
SUDOESTE(new Sudoeste());

Agora, no teste abaixo, a palavra "Ruiva" será encontrada:
@Test
public void sudoeste() {
    char[][] tabuleiro = new char[][] { 
            {' ',' ',' ',' ','R'},
            {' ',' ',' ','U',' '},
            {' ',' ','I',' ',' '},
            {' ','V',' ',' ',' '},
            {'A',' ',' ',' ',' '}};
    
    assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
}

E pronto :-)
Conclusão
Eu e muitos dos nossos colegas consideram este código bastante simples mas eu entendo que talvez você não o compreenda completamente ainda.
Minha sugestão, é claro, é que você tente compreender.
Alguns recursos do Java que foram utilizados aí:

Interface
Enumeração.
Extensão de enumeração: eu adicionei um atributo a cada item da enumeração, que é o objeto especializado em percorrer o tabuleiro naquela direção.

E apesar de eu não considerar quantidade total de linhas muito importante, eu observo que embora meu código funcione ele tem ainda menos linhas que o código original da pergunta.

