java编程题,在九宫格内填入1—9九个数字,使得横竖排的数字相加之和都相等

/*直接复制运行就可以，每一行的九个数字代表一个九宫格的9个数字，从左到右，从上到下*/
import java.util.ArrayList;
import java.util.Arrays;

public class Test1 {
	private static ArrayList arrangeList = new ArrayList(); 
	
	 public static void main(String[] args) {
		String str = "123456789";//你要排列组合的字符串
		char list[] = str.toCharArray();//将字符串转换为字符数组
		genernateData(list, 0, list.length - 1);//参数为字符数组和0和字符数组最大下标
		int arr[]=new int[9];
		for(String str1 : arrangeList){
			for(int k=0;k<9;k++){
				arr[k]=Integer.parseInt(str1.substring(k,k+1));
			}
			if(arr[0]+arr[1]+arr[2]==15&&arr[3]+arr[4]+arr[5]==15&&arr[6]+arr[7]+arr[8]==15&&arr[0]+arr[3]+arr[6]==15&&arr[1]+arr[4]+arr[7]==15&&arr[2]+arr[5]+arr[8]==15&&arr[0]+arr[4]+arr[8]==15&&arr[2]+arr[4]+arr[6]==15){
				System.out.println(Arrays.toString(arr));
			}
		}
	}
	 	
	public static void genernateData(char list[], int k, int m) {
		 if (k > m) {
			 StringBuffer sb = new StringBuffer();//创建一个StringBuffer对象sb
			 for (int i = 0; i <= m; i++) {
				 sb.append(list[i]);//循环将字符数组值追加到StringBuffer中
			 }
			 arrangeList.add(sb.toString());
		 } else {
			 for (int i = k; i <= m; i++) {
				 swapData(list, k, i);//将下表为k和i的值调换位置
				 genernateData(list, k + 1, m);
				 swapData(list, k, i);
			 }
		 }
	}

	private static void swapData(char list[], int k, int i) {
		char temp = list[k];
		list[k] = list[i];
		list[i] = temp;
	}	
}

这个是可以随意生成不同大小的九宫格,相对会复杂一点不过大体算法是一样的

// 定义 N 为九宫格的行列数，需要输入
		System.out.println("请输入九宫格的行列规模(只能是奇数的)");
		Scanner n = new Scanner(System.in);
		int N;
		// 判断格局是否奇数 （可判断出偶数、负数 及小数）
		double d;
		while (true) {
			d = n.nextDouble();
			N = (int) d;
			if ((d - N) > 1.0E-4 || N % 2 == 0 || N < 0) {
				System.out.println("输入出错,格局只能是正奇数。请重新输入");
			} else
				break;
		}
		int[][] result = new int[N][N];// 定义保存九宫格的数组
		int row = 0; // 行 初始位置
		int col = N / 2; // 列 初始位置,因为列由0开始，故N/2是中间位置
		for (int i = 1; i <= N * N; i++) {
			result[row][col] = i;
			row--;
			col++;
			if (row < 0 && col >= N) {
				col--;
				row += 2;
			} // 行列都越界
			else if (row < 0) {
				row = N - 1;
			} // 行越界
			else if (col >= N) {
				col = 0;
			} // 列越界
			else if (result[row][col] != 0) {
				col--;
				row += 2;
			} // 有冲突
		}
		// 打印出九宫格
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				System.out.print(result[i][j] + "\t");
			}
			System.out.println();
		}

思路：

1. 第一行（数组第0行）的正中间放入1；（a[0][1]=1）

2. 下一个数总是放在放一个数的右上角45°，实际为以下两种情况：

   行越界：把这个数放到同列的末行

3. 列越界：把这个数放到同行的首列

4. .如果遇到n的整数倍数，则放到上个数的正下方，实际为以下两种情况：行列同时越界

   冲突（位置上已经有了数字）

代码：

int[][] nine= new int[n][n];   //定义二位数组，默认赋0值

int row = 0,col=n/2;            //行列赋初值

for(int i=1;i<=n*n;i++){

nine[row][col]=i;
row--;

col++;

//行列同时越界：放到上个数的正下方

if(row<0&&col>=n){
row+=2;
col--;

}           // 行越界：把这个数放到同列的末行

else if(row<0){

row=n-1;

}        // 列越界：把这个数放到同行的首列

else if(col>=n){

col=0;

}

//冲突： 放到上个数的正下方  

else if(nine[row][col]!=0){

row+=2;
col--;
}

}

//打印 n*n

for(int i=0;ifor(int j=0;jSystem.out.print(nine[i][j]+" ");
}
System.out.println();
}

所有情况如下，请采纳

public class Jiugongge {
 public static void main(String[] args) {
  int[] c=new int[12];
  dfs(c,0);
 }
 
 static void dfs(int[] c,int cur){
  if (cur == 9&&c[6]+c[7]+c[8]==15) {
   for (int i = 0; i < 9; i++) {
    System.out.print(c[i] + " ");
    if((i+1)%3==0) System.out.println();
   }
   System.out.println();
  }
  else{
   for(int i=1;i<=9;i++){
    boolean ok=true;
    for(int j=0;j     if(c[j]==i) {
      ok=false;break;
     }
    if(cur==3&&c[0]+c[1]+c[2]!=15
      ||cur==6&&c[3]+c[4]+c[5]!=15
      ||cur==7&&c[0]+c[3]+c[6]!=15
      ||cur==8&&c[1]+c[4]+c[7]!=15)
     ok=false;
    if(ok){
     c[cur]=i;
     dfs(c, cur+1);
    }
   }
  }
 }
}

package test;

public class 九宫格 {

static int[][] nine=new int[3][3];
static boolean[] used=new boolean[10];
static int jishu = 0;
public static void main(String[] args){

for(int i=0;i<10;++i){
used[i]=true;
}

dfs(0);
System.out.println(jishu);
}

public static void dfs(int step){
if(step==9){
if(check()==true){
for(int i=0;i<3;++i){
for(int j=0;j<3;++j){
System.out.print(nine[i][j]+" ");
}
System.out.println();
}
System.out.println("===========");
jishu ++ ;
}
}

for(int i=1;i<=9;++i){
if(used[i]==true){
used[i]=false;
nine[step/3][step%3]=i;
dfs(step+1);
used[i]=true;
}
}
}

public static boolean check(){
int[] sum_i=new int[3];
for(int i=0;i<3;++i){
sum_i[i]=0;
for(int j=0;j<3;++j){
sum_i[i]+=nine[i][j];
}
}
if(sum_i[0]!=sum_i[1] || sum_i[1]!=sum_i[2] || sum_i[0]!=sum_i[2]) return false;

int[] sum_j=new int[3];
for(int j=0;j<3;++j){
sum_j[j]=0;
for(int i=0;i<3;++i){
sum_j[j]+=nine[i][j];
}
}
if(sum_j[0]!=sum_j[1] || sum_j[1]!=sum_j[2] || sum_j[0]!=sum_j[2]) return false;

int sum1=nine[0][0]+nine[1][1]+nine[2][2];

if(sum_i[0]!=sum1) return false;

int sum2=nine[1][1]+nine[0][2]+nine[2][0];

if(sum_i[0]!=sum2) return false;

return true;
}

}