Convert int in int Array

Question

Und jetzt habe ich ein anderes Problem. Ich muss eine CNF Formel machen und eine Karte von Integres von 3D-Array verwenden. jetzt versuche ich, diese Aufgabe zu verwenden, mit einem Unterschied von ein 3d-Array einfügen, und nicht 2d.

Ich habe es mit Spalten (wo sind die 2 Sterne (**)) und es funktioniert.

Mit den Blöcken (wo man ********* Sterne sehen kann), sagt die Finsternis, dass

warum es schreibt, dass „nicht fron int [] int konvertieren“? in den "Spalten es nicht".

Ich hoffe, ich war klar.

public static void encode(int sqrtN, int[][] hints, int[][][] map) { 
    int[] vars = new int [sqrtN*sqrtN]; 
    int nVars = sqrtN*sqrtN*sqrtN*sqrtN*sqrtN*sqrtN; 


** //each cell in the columns gets a different value.** 
    for(int i=0; i<sqrtN*sqrtN; i=i+1){ 
     for(int j=0; j<sqrtN*sqrtN; j=j+1) { 
      for(int k=0; k<sqrtN*sqrtN; k=k+1) 
       vars[k] = columns(map)[i][k][j]; 

      SATSolver.addClauses(exactlyOne(vars)); 
     } 
    } 

    *****//each cell in the blocks gets a different value.****** 
    for(int i=0; i<sqrtN*sqrtN; i=i+1){ 
     for(int j=0; j<sqrtN*sqrtN; j=j+1) { 
      for(int k=0; k<sqrtN*sqrtN; k=k+1) 
       vars[k] = blocks(map,sqrtN)[i][k][j]; 

      SATSolver.addClauses(exactlyOne(vars)); 
     } 
    } 
    //hints. 
    int [] hintsSATS = new int[1]; 
    for (int i = 0; i < hints.length; i = i + 1) { 
     hintsSATS[0] = varName(hints[i][0],hints[i][1],hints[i][2]-1,sqrtN*sqrtN); 
     SATSolver.addClause(hintsSATS); 
    } 

} 

//A function to trunsfer to columns. 
public static int[][][] columns (int[][][] matrix) { 
    int[][][] columns = new int[matrix.length][matrix.length][matrix.length]; 
    for(int j=0; j<matrix.length; j= j+1){ 
     for(int i=0; i<matrix.length; i= i+1){ 
      columns[j][i] = matrix[i][j]; 
     } 
    } 
    return columns; 
} 

    ************ //A function to trunsfer to blocks.********** 
public static int[][][] blocks (int[][][] matrix, int sqrtN) { 
    int[][][] blocks = matrix; 
    for (int i = 0; i<matrix.length; i= i+1) { 
     for (int j = 0; j<matrix.length; j= j+1) { 
      blocks[i][j] = j%sqrtN+ i%sqrtN*sqrtN + 1; 
     } 
    } 
    return blocks; 
} 




//The name of the variable. 
public static int varName(int i, int j, int k, int n) { 
    int varName = n*n*i+n*j+k+1; 
    return varName; 
} 
    //functions for the CNF. Excactly one. 

public static int[][] atLeastOne(int[] vars) { 
    int [][] atLeastOne = new int [1][vars.length]; 
    atLeastOne[0] = vars; 
    return atLeastOne; 
} 

public static int[][] atMostOne(int[] vars) { 
    int [][]atMostOne = new int[AmountOfArrays(vars.length)][2]; 
    int k = 0; 
    for(int i= 0;i<vars.length;i= i+1){ 
     for(int j=i+1;j<vars.length;j= j+1){ 
      atMostOne[k][0] = -vars[i]; 
      atMostOne[k][1] = -vars[j]; 
      k=k+1;   
     } 
    } 
    return atMostOne; 
} 

public static int AmountOfArrays(int n){ 
    int counter = 0; 
    for(int i= 0;i<n-1;i= i+1){ 
     for(int j=i+1;j<n;j= j+1){ 
      counter= counter+1;   
     } 
    } 
    return counter; 
} 

public static int[][] exactlyOne(int[] vars) { 
    int [][] exactlyOne = new int [AmountOfArrays(vars.length)+1][vars.length]; 
    int [][]atLeastOne = new int [1][vars.length]; 
    atLeastOne = atLeastOne(vars); 
    exactlyOne[0] = atLeastOne[0]; 
    for(int i=1; i<exactlyOne.length; i= i+1){ 
     int [][]atMostOne = atMostOne(vars); 
     exactlyOne[i] = atMostOne[i-1]; 
    } 
    return exactlyOne; 
} 

Answer 1

Problem ist hier blocks[i][j] = j%sqrtN+ i%sqrtN*sqrtN + 1; die blocks[i][j] ein Array benötigt aber j%sqrtN+ i%sqrtN*sqrtN + 1; einen int zurück.

Answer 2

In der Methode public static int[][][] blocks (int[][][] matrix, int sqrtN) verwenden Sie das Multi-Array matrix nicht korrekt.

matrix -> int[][][] 
matrix[i] -> int[][] 
matrix[i][j] -> int[] 
matric[i][j][k] -> int 

Sie müssen also eine Schleife hinzufügen auf einer weiteren Array-Dimension zu durchlaufen zu können, einen int Wert in den Zellen einzustellen.

for (int i = 0; i < matrix.length; ++i) { 
    for (int j = 0; j < matrix[i].length; ++j) { 
     for (int k = 0; k < matrix[i][j].length; ++k) { 
      blocks[i][j][k] = ???? 
     } 
    } 
} 

Bitte beachte, dass ich matrix[i].length verwendet, wenn Sie Array-Dimension nicht alle gleich groß sind, dann ist dies sicherer.