Varrer elementos de uma matriz bidimensional[RESOLVIDO]

estou com uma operação que dada uma matriz, eu tenho q verificar se ela tem o elemento neutro, e funciona da seguinte forma

0 1 2 3
1 0 3 2
2 3 0 1
3 2 1 0

Se você prestar atenção, na primeira posição lá no 0 os elementos se encontram, tipo assim:

0 1 2 3
1
2
3

Isso mostra que ele tem el. neutro, que é o 0.

Então, eu estou fazendo um método pra verificar, se onde eles se encontram , eles são simétricos, tipo, ele é igual tanto na horizontal qto na vertical, onde eles se encontram. Eu gostaria de saber como faço pra verificar se o elemento da horizontal é igual ao da vertical, isso assim, tipo, que o a[1] = b[1].

eu to fazendo assim:

private static boolean temElNeutro(Integer[][] mat, Integer[] e){
		int a,b,c;
		for(a = 0;a<e.length;a++){
			for(b=0;b<e.length;b++){
				for(c=0;c<e.length;c++){
				int k1 = mat[e[a]][e[b]];
				int k2 = mat[e[b]][e[c]];
				if (mat[k1][e[c]] != mat[e[a]][k2]){
					return false;
				}
			}			
		}
		}
		return true;
	}
}

Se alguem poder me ajudar, com uma ideia diferente da minha. Vlw.
>

Cara, não estou conseguindo entender muito bem o que você está querendo fazer…

Pelo exemplo de matriz que você passou deu de entender que você quer descobrir se uma determinada matriz é ou não simétrica.

É isso?

O que é uma matriz? na matemática, um vetor com duas dimensões m = i x j(respectivamente colunas e linhas).

[code]for(int j = 0; j<altura; j++){

for(int i = 0; i<largura; i++{
if(i == j){

}
}

}[/code]

A diagonal principal é o que você quer encontrar. Isso acontece quando linha = coluna, ou seja j = i. Não se esqueça da álgebra linear. :]

[quote=juliocbq]O que é uma matriz? na matemática, um vetor com duas dimensões m = i x j(respectivamente colunas e linhas).

[code]for(int j = 0; j<altura; j++){

for(int i = 0; i<largura; i++{
if(i == j){

}
}

}[/code]

A diagonal principal é o que você quer encontrar. Isso acontece quando linha = coluna, ou seja j = i. Não se esqueça da álgebra linear. :][/quote]

Foi praticamente isso que eu fiz, considerando o i e j como posicoes da matriz. Vê se está certo:

private static boolean temElNeutro(Integer[][] mat){
		int a,b = 0;
		for(a = 0;a<mat.length;a++){
			for(b=0;b<mat.length;b++){				
				if (mat[a][b] != mat[b][a]){
					System.out.println("nao tem el.neutro\n");
					return false;
				}
			}			
		}
		System.out.printf("tem el.neutro\n");
		return true;
	}

Obrigado.

private static boolean temElNeutro(Integer[][] mat){
int a,b = 0;
for(a = 0;a<mat.length;a++){
for(b=0;b<mat.length;b++){
if (mat[a][b] != mat[b][a]){
System.out.println(“nao tem el.neutro\n”);
return false;
}
}
}
System.out.printf(“tem el.neutro\n”);
return true;
}

você está percorrendo a capacidade da matriz, e não a altura pela largura. Length aí é largura x altura, entendeu?

[quote=juliocbq]
private static boolean temElNeutro(Integer[][] mat){
int a,b = 0;
for(a = 0;a<mat.length;a++){
for(b=0;b<mat.length;b++){
if (mat[a][b] != mat[b][a]){
System.out.println(“nao tem el.neutro\n”);
return false;
}
}
}
System.out.printf(“tem el.neutro\n”);
return true;
}

você está percorrendo a capacidade da matriz, e não a altura pela largura. Length aí é largura x altura, entendeu?[/quote]

Então como é que eu vou representar a largura e altura?

Acho que seria mat[0].length. Se for sempre uma matriz quadrada, dá pra tirar o length numa variável e usar ela nos dois fors.

Vc pode ter a seguinte situacao tb?

|   0    
| 0 1 2 3
|   2
|   3[/code]


Nesse caso o ponto neutro é o 1...?

Podem existir mais de um ponto neutro?

Necessariamente tem que ser 0 1 2 3? ou pode ser números aleatorios?


        [code]
        12
        23
12  23  52  84
        84

?

[quote=rogelgarcia]Vc pode ter a seguinte situacao tb?

   0    
 0 1 2 3
   2
   3[/code]


Nesse caso o ponto neutro é o 1...?

Podem existir mais de um ponto neutro?

Necessariamente tem que ser 0 1 2 3? ou pode ser números aleatorios?


        [code]
          12
          23
12  23 52 84
          84

?[/quote]

Então, o el.neutro é unico, pode ser dessas formas que vc mostrou, mas nesse caso nao vai dar, pois para dar el. neutro, onde eles se encontrar tem q formar um grupo igual ao cabeçalho e a coluna tipo:
//cabecalho e o extremo esquerda na vertical e a coluna, entao vc ve q onde eles se encontram , que e no zero, forma um grupo igual ao cabecalho e a coluna.
*|0 1 2 3
0|0|1|2|3
1|1|3|0|2
2|2|1|3|0
3|3|2|0|1

[youtube]http://www.youtube.com/watch?v=DgqOEsX74T0[/youtube]

kkkkkkkkkkkkk, cara vc me perguntou se poderia ter matrizes diferentes, tipo:

   1

12342
3
4

não foi isso? eu disse q sim, mas só que nesse caso não haveria elemento neutro, pois onde eles se encontrar não se forma um grupo igual ao cabeçalho da matriz, e igual a coluna tipo

0123
1
2
3

encima da matriz, tem o cabeçalho e a coluna:
0123 -> cabeçalho
0x123
11
22
33
|
v
coluna

então se ele se encontra no x, logo forma elementos iguais ao cabeçalho e a coluna. entendeu??

Para ter elementos iguais no cabeçalho e na coluna…

Então só tem jeito de o ponto neutro… ser na posicao 0 0

certo?

O problema então é só descobrir se o ponto 0 0 é neutro?!

[quote=rogelgarcia]Para ter elementos iguais no cabeçalho e na coluna…

Então só tem jeito de o ponto neutro… ser na posicao 0 0

certo?

O problema então é só descobrir se o ponto 0 0 é neutro?![/quote]

Nõ, ele também poderia ser aki:

0 1 2 3
0 0 0 0 0
1 0 1 2 3
2 0 2 3 1
3 0 3 1 2

no caso, eles se encontrar ai no negrito, e formaram valores iguais ao cabecalho e a coluna , entendeu?

Agora entendi :smiley:

A matriz é necessariamente quadrada?

[quote=rogelgarcia]Agora entendi :smiley:

A matriz é necessariamente quadrada?[/quote]

nao, se ela for quadrada ela tera el neutro, se nao, so se onde eles se encontrarem formar elementos igual ao cabecalho e a coluna.

public class PontoNeutro {

	public static void main(String[] args) {
		int[][] matriz = {
				{0, 1, 2, 3},
				{1, 2, 8, 3},
				{2, 8, 3, 3},
				{3, 3, 0, 3},
				{3, 3, 0, 3}
		};
		
		for (int x = 0; x < matriz.length -1; x++) { 
			for (int y = 0; y < matriz[x].length -1; y++) {
				System.out.println("Possível ponto neutro? "+x+" "+y+"  "+verificarPossivelPontoNeutro(x, y, matriz));
				if(verificarPossivelPontoNeutro(x, y, matriz)){
					System.out.println("   > Ponto neutro? "+x+" "+y+"  "+verificarPontoNeutro(x, y, matriz));
				}
			}
		}
	}

	private static boolean verificarPossivelPontoNeutro(int x, int y, int[][] matriz) {
		int tamanhoX = matriz.length - x;
		int tamanhoY = matriz[x].length - y;
		return tamanhoX == tamanhoY;
	}

	private static boolean verificarPontoNeutro(int x, int y, int[][] matriz) {
		for (int i = x + 1; i < matriz.length; i++) {
			for (int j = y + 1; j < matriz[i].length; j++) {
				if(matriz[i][y] != matriz[x][j]){
					return false;
				}
			}
		}
		return true;
	}
}

A ultima linha e ultima coluna não serão checadas (por causa do -1 lá no inicio do loop do método main)

O algoritmo verifica primeiro se o ponto é candidato a ser neutro

E depois… verifica se o candidato… é neutro

Resultado no console:

[code]Possível ponto neutro? 0 0 false
Possível ponto neutro? 0 1 false
Possível ponto neutro? 0 2 false
Possível ponto neutro? 1 0 true

Ponto neutro? 1 0 false
Possível ponto neutro? 1 1 false
Possível ponto neutro? 1 2 false
Possível ponto neutro? 2 0 false
Possível ponto neutro? 2 1 true
Ponto neutro? 2 1 true
Possível ponto neutro? 2 2 false
Possível ponto neutro? 3 0 false
Possível ponto neutro? 3 1 false
Possível ponto neutro? 3 2 true
Ponto neutro? 3 2 false[/code]

Com alguma matemática… tem como o algotímo ficar mais eficiente… não sendo necessário verificar todos os pontos… para possiveis candidatos

[quote=rogelgarcia][code]
public class PontoNeutro {

public static void main(String[] args) {
	int[][] matriz = {
			{0, 1, 2, 3},
			{1, 2, 8, 3},
			{2, 8, 3, 3},
			{3, 3, 0, 3},
			{3, 3, 0, 3}
	};
	
	for (int x = 0; x < matriz.length -1; x++) { 
		for (int y = 0; y < matriz[x].length -1; y++) {
			System.out.println("Possível ponto neutro? "+x+" "+y+"  "+verificarPossivelPontoNeutro(x, y, matriz));
			if(verificarPossivelPontoNeutro(x, y, matriz)){
				System.out.println("   > Ponto neutro? "+x+" "+y+"  "+verificarPontoNeutro(x, y, matriz));
			}
		}
	}
}

private static boolean verificarPossivelPontoNeutro(int x, int y, int[][] matriz) {
	int tamanhoX = matriz.length - x;
	int tamanhoY = matriz[x].length - y;
	return tamanhoX == tamanhoY;
}

private static boolean verificarPontoNeutro(int x, int y, int[][] matriz) {
	for (int i = x + 1; i < matriz.length; i++) {
		for (int j = y + 1; j < matriz[i].length; j++) {
			if(matriz[i][y] != matriz[x][j]){
				return false;
			}
		}
	}
	return true;
}

}
[/code]

A ultima linha e ultima coluna não serão checadas (por causa do -1 lá no inicio do loop do método main)

O algoritmo verifica primeiro se o ponto é candidato a ser neutro

E depois… verifica se o candidato… é neutro

Resultado no console:

[code]Possível ponto neutro? 0 0 false
Possível ponto neutro? 0 1 false
Possível ponto neutro? 0 2 false
Possível ponto neutro? 1 0 true

Ponto neutro? 1 0 false
Possível ponto neutro? 1 1 false
Possível ponto neutro? 1 2 false
Possível ponto neutro? 2 0 false
Possível ponto neutro? 2 1 true
Ponto neutro? 2 1 true
Possível ponto neutro? 2 2 false
Possível ponto neutro? 3 0 false
Possível ponto neutro? 3 1 false
Possível ponto neutro? 3 2 true
Ponto neutro? 3 2 false[/code]

Com alguma matemática… tem como o algotímo ficar mais eficiente… não sendo necessário verificar todos os pontos… para possiveis candidatos[/quote]

Interessante essa sua abordagem, mas acho q vc ta confundindo um pouco. Me parece que vc esta verificando se existem elemento neutro para todas as posicoes? Se for assim, não é assim que se verifica. Basta verificar se onde eles se encontram, a linha e a coluna são iguais.

Eu verifico os possiveis pontos neutros… e depois verifico se ele realmente é neutro…

No exemplo… o ponto neutro é

Ponto neutro? 2 1 true (linha 2, coluna 1) (indice baseado em 0)

{0, 1, 2, 3},
{1, 2, 8, 3},
{2, [color=blue]8[/color], [color=blue]3[/color], [color=blue]3[/color]},
{3, [color=blue]3[/color], 0, 3},
{3, [color=blue]3[/color], 0, 3}

Eles se encontram na linha 2 coluna 1

[quote=rogelgarcia]{0, 1, 2, 3},
{1, 2, 8, 3},
{2, [color=blue]8[/color], [color=blue]3[/color], [color=blue]3[/color]},
{3, [color=blue]3[/color], 0, 3},
{3, [color=blue]3[/color], 0, 3}

Eles se encontram na linha 2 coluna 1[/quote]

então, seu cabeçalho e coluna é 0 1 2 3? se for, teria q forma 1 2 3 não 8 3 3. entende? tem q formar igual o cabeçalho e coluna. testa esse metodo aki:

private static boolean temElNeutro(Integer[][] mat){
		int a,b = 0;
		for(a = 0;a<mat.length;a++){
			for(b=0;b<mat.length;b++){				
				if (mat[a][b] != mat[b][a]){
					System.out.println("nao tem el.neutro");
					return false;
				}
			}			
		}
		System.out.printf("tem el.neutro");
		return true;
	}

e passa essa ,matriz:

public static Integer Mat1[][] = {{0,1,2,3}, 
					       {1,0,3,2},  
					       {2,3,0,1}, 
					       {3,2,1,0}};

Se voce cer, o cabecalho ela é 0 1 2 3, e onde eles se encontram forma esse valor.
Da mesma forma essa aki:

public static Integer Mat3[][] = {{0,0,0,0}, 
		                              {0,1,2,3},  
		                              {0,2,0,2}, 
		                              {0,3,2,1}};

usa esse metodo, declara essas matrizes e chama o metodo, ah e depois pra ver se nao tem el.neutro, apaga a ultima linha de qqr matriz pra vc ver.
chama o metodo assim:

 temElNeutro(Mat2);