From Gossip@caterpillar

Algorithm Gossip: 2(2N+1) 魔方陣

說明

方陣的維度整體來看是偶數，但是其實是一個奇數乘以一個偶數，例如6X6，其中6=2X3，我們也稱這種方陣與單偶數方陣。

解法

如果您會解奇數魔術方陣，要解這種方陣也就不難理解，首先我們令n=2(2m+1)，並將整個方陣看作是數個奇數方陣的組合，如下所示：
2(2N+1)魔方陣

首先依序將A、B、C、D四個位置，依奇數方陣的規則填入數字，填完之後，方陣中各行的和就相同了，但列與對角線則否，此時必須在A-D與C- B之間，作一些對應的調換，規則如下：
  1. 將A中每一列(中間列除外)的頭m個元素，與D中對應位置的元素調換。
  2. 將A的中央列、中央那一格向左取m格，並與D中對應位置對調
  3. 將C中每一列的倒數m-1個元素，與B中對應的元素對調

舉個實例來說，如何填6X6方陣，我們首先將之分解為奇數方陣，並填入數字，如下所示：
2(2N+1)魔方陣

接下來進行互換的動作，互換的元素以不同顏色標示，如下：
2(2N+1)魔方陣

由於m-1的數為0，所以在這個例子中，C-B部份並不用進行對調。

實作

  • C 
#include <stdio.h> 
#include <stdlib.h> 

#define N 6 
#define SWAP(x,y) {int t; t = x; x = y; y = t;} 

void magic_o(int [][N], int); 
void exchange(int [][N], int); 

int main(void) { 
    int square[N][N] = {0}; 
    int i, j; 

    magic_o(square, N/2); 
    exchange(square, N); 

    for(i = 0; i < N; i++) { 
        for(j = 0; j < N; j++) 
            printf("%2d ", square[i][j]); 
        printf("\n"); 
    } 

    return 0; 
} 

void magic_o(int square[][N], int n) { 
    int count, row, column; 

    row = 0; 
    column = n / 2; 

    for(count = 1; count <= n*n; count++) { 
        square[row][column] = count;            // 填A 
        square[row+n][column+n] = count + n*n;  // 填B 
        square[row][column+n] = count + 2*n*n;  // 填C 
        square[row+n][column] = count + 3*n*n;  // 填D 
        if(count % n == 0) 
            row++; 
        else { 
            row = (row == 0) ? n - 1 : row - 1 ; 
            column = (column == n-1) ? 0 : column + 1; 
        } 
    } 
} 

void exchange(int x[][N], int n) { 
    int i, j; 
    int m = n / 4; 
    int m1 = m - 1; 

    for(i = 0; i < n/2; i++) { 
        if(i != m)  {    
            for(j = 0; j < m; j++)          // 處理規則 1 
                SWAP(x[i][j], x[n/2+i][j]); 
            for(j = 0; j < m1; j++)         // 處理規則 2 
                SWAP(x[i][n-1-j], x[n/2+i][n-1-j]); 
        } 
        else {  // 處理規則 3 
            for(j = 1; j <= m; j++) 
                SWAP(x[m][j], x[n/2+m][j]); 
            for(j = 0; j < m1; j++) 
                SWAP(x[m][n-1-j], x[n/2+m][n-1-j]); 
        } 
    } 
}

  • Java 
public class Matrix {
    public static int[][] magic22mp1(int n) {
        int[][] square = new int[n][n]; 

        magic_o(square, n/2); 
        exchange(square, n);         
        
        return square;
    }
    
    private static void magic_o(int[][] square, int n) {
        int row = 0; 
        int column = n / 2; 

        for(int count = 1; count <= n*n; count++) { 
            square[row][column] = count;            // 填A 
            square[row+n][column+n] = count + n*n;  // 填B 
            square[row][column+n] = count + 2*n*n;  // 填C 
            square[row+n][column] = count + 3*n*n;  // 填D 
            if(count % n == 0) 
                row++; 
            else { 
                row = (row == 0) ? n - 1 : row - 1 ; 
                column = (column == n-1) ? 0 : column + 1; 
            } 
        }
    }
    
    private static void exchange(int[][] x, int n) {
        int i, j; 
        int m = n / 4; 
        int m1 = m - 1; 

        for(i = 0; i < n/2; i++) { 
            if(i != m)  {    
                for(j = 0; j < m; j++)          // 處理規則 1 
                    swap(x, i, j, n/2+i, j); 
                for(j = 0; j < m1; j++)         // 處理規則 2 
                    swap(x, i, n-1-j, n/2+i, n-1-j); 
            } 
            else {  // 處理規則 3 
                for(j = 1; j <= m; j++) 
                    swap(x, m, j, n/2+m, j); 
                for(j = 0; j < m1; j++) 
                    swap(x, m, n-1-j, n/2+m, n-1-j); 
            } 
        } 
    }
    
    private static void swap(int[][] number,
                                int i, int j, int k, int l) {
        int t; 
        t = number[i][j]; 
        number[i][j] = number[k][l]; 
        number[k][l] = t;
    }
    
    public static void main(String[] args) {
        int[][] magic = Matrix.magic22mp1(6);
        
        for(int k = 0; k < magic.length; k++) {
            for(int l = 0; l < magic[0].length; l++) {
                System.out.print(magic[k][l] + " ");
            }
            System.out.println();
         }
    }
}