⑴ c++最小拉丁方阵
#include<iostream>
usingnamespacestd;
#defineN6
intmain()
{
inti,j;
for(i=1;i<=N;i++)
{
for(j=i;j<N+i;j++)
cout<<(j-1)%N+1<<"";
cout<<endl;;
}
return0;
}
⑵ C语言编程题“幸运方阵”问题怎么解决
嘛啊！我走人吧！我还是初级的呢！学了不到1个月，C语言就解决了。。。。。。。。。。
⑶ Turbo Pascal编程高手们，这道题咋编（拉丁方阵）
二维数组啊
⑷ 构造一个3*3的拉丁方阵，使该矩阵中的每行每列中数字1，2，3都只出现一次。30分不成敬意。
/*
来自n个部队的n种军衔的n×n名军官，
如果能排成一个正方形，每一行，每一列的n名军官来自不同的部队并且军衔各不相同，
那么就称这个方阵叫正交拉丁方阵。
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
分配 rowSize * colSize 的二维数组空间
*/
int ** mallocTwoDimensionArray(int rowSize,int colSize)
{
int **array = (int**)malloc(sizeof(int*)*rowSize);
int i,j;
if(array == NULL)
{
return NULL;
}
else
{
for(i=0;i<rowSize;i++)
{
array[i] = (int*)malloc(sizeof(int)*colSize);
if(array[i] == NULL)
{
for(j=0;j<i;j++)
{
free(array[j]);
}
return NULL;
}
else
{
memset(array[i],0,colSize*sizeof(int));
}
}
return array;
}
}
struct LatinSquare
{
int size;
int **square;
LatinSquare * next;
};
/*
保存大小为 size * size 大小的拉丁方阵 square
到链表 head 中
返回：是否成功保存到链表中
*/
int saveLatinSquare(struct LatinSquare *head,int size,int** square)
{
struct LatinSquare *p;
int i,j;
p = (struct LatinSquare *)malloc(sizeof(struct LatinSquare));
if(p == NULL)
{
return 0;
}
else
{
// 拉丁矩阵大小
p->size = size;
p->square = mallocTwoDimensionArray(size,size);
for(i=0;i<size;i++)
{
for(j=0;j<size;j++)
{
p->square[i][j] = square[i][j];
}
}
// 添加构造好的拉丁矩阵到链表中
p->next = head->next;
head->next = p;
return 1;
}
}
/*
输出拉丁矩阵
*/
void printLatinSquare(struct LatinSquare *p)
{
int i,j;
if(p == NULL)
{
return ;
}
else
{
for(i=0;i<p->size;i++)
{
for(j=0;j<p->size;j++)
{
printf("%d ",p->square[i][j]);
}
printf("\n");
}
printf("\n");
}
}
/*
构造大小为 size * size 大小的拉丁方阵
构造结果通过链表 head 返回
square : 当前正在构造的拉丁方阵
row : 当前正在构造的拉丁方阵的行号
col : 当前正在构造的拉丁方阵的列号
generatedSquareNum : 已经构造好的拉丁方阵数
返回：
能构造出的拉丁反正种数
*/
void generateLatinSquare(int size,struct LatinSquare *head,int *totalSquareNum ,int**square,int row,int col)
{
int i,j,k;
int *isNumberUsed = (int*)malloc(sizeof(int)*(size+1));
if(row == size)
{
/*
保存构造好的拉丁矩阵到结构体中。
对于构造种数比较小的拉丁矩阵适用。
构造种数比较多的，不要保存，内存会不够。
*/
saveLatinSquare(head,size,square);
/*
构造种数加一
*/
(*totalSquareNum) ++;
/*
输出构造好的拉丁矩阵到屏幕。
根据需要可以关闭这里的输出（构造种数比较少的，结果直接通过链表返回）
*/
printf("第 %d 个大小为 %d 的拉丁方阵：\n",*totalSquareNum,size);
printLatinSquare(head->next);
}
else
{
if(square == NULL)
{
square = mallocTwoDimensionArray(size,size);
}
memset(isNumberUsed,0,sizeof(int)*(size+1));
// 所在列上已经使用过的数字
for(i=0;i<row;i++)
{
isNumberUsed[square[i][col]]=1;
}
// 所在行上已经使用过的数字
for(j=0;j<col;j++)
{
isNumberUsed[square[row][j]]=1;
}
// 枚举没有被使用过的数字
for(k=1;k<=size;k++)
{
if(!isNumberUsed[k])
{
square[row][col] = k;
// 递归构造下一位上的数字
generateLatinSquare(size,head,totalSquareNum,square,row+(col+1)/size,(col+1)%size);
}
}
free(isNumberUsed);
}
}
int main(int argc, char *argv[])
{
int i,j,k;
int size,totalSquareNum;
struct LatinSquare head ,*p;
head.next = NULL;
// 构造大小从 3 ~ 10 的拉丁方阵
for(size = 3;size <=6;size ++)
{
head.next = NULL;
totalSquareNum = 0;
generateLatinSquare(size,&head,&totalSquareNum,NULL,0,0);
printf("大小为 %d 的拉丁方阵一共能构造 %d 个。\n\n",size,totalSquareNum);
/*
for(k=0,p=head.next;p!=NULL;p=p->next,k++)
{
printf("第 %d 个大小为 %d 的拉丁方阵：\n",k,size);
for(i=0;i<p->size;i++)
{
for(j=0;j<p->size;j++)
{
printf("%d ",p->square[i][j]);
}
printf("\n");
}
printf("\n");
}
*/
}
return 0;
}
⑸ 拉丁方阵的C语言实例 拉丁方阵
构造 NXN 阶的拉丁方阵(2<=N<=9)，使方阵中的每一行和每一列中数字1到N只出现一次。如N=4时：
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
*问题分析与算法设计
构造拉丁方阵的方法很多，这里给出最简单的一种方法。观察给出的例子，可以发现：若将每 一行中第一列的数字和最后一列的数字连起来构成一个环，则该环正好是由1到N顺序构成；对于第i行，这个环的开始数字为i。按照 此规律可以很容易的写出程序。下面给出构造6阶拉丁方阵的程序。
*程序说明与注释
#include<stdio.h>
#define N 6 /*确定N值*/
int main()
{
int i,j,k,t;
printf("The possble Latin Squares of order %d are:
",N);
for(j=0;j<N;j++) /*构造N个不同的拉丁方阵*/
{
for(i=0;i<N;i++)
{
t=(i+j)%N; /*确定该拉丁方阵第i 行的第一个元素的值*/
for(k=0;k<N;k++) /*按照环的形式输出该行中的各个元素*/
printf("%d",(k+t)%N+1);
printf("
");
}
printf("
");
}
}
*运行结果
The possble Latin Squares of order 6 are:
1 2 3 4 5 6 2 3 4 5 6 1 3 4 5 6 1 2
2 3 4 5 6 1 3 4 5 6 1 2 4 5 6 1 2 3
3 4 5 6 1 2 4 5 6 1 2 3 5 6 1 2 3 4
4 5 6 1 2 3 5 6 1 2 3 4 6 1 2 3 4 5
5 6 1 2 3 4 6 1 2 3 4 5 1 2 3 4 5 6
6 1 2 3 4 5 1 2 3 4 5 6 2 3 4 5 6 1
4 5 6 1 2 3 5 6 1 2 3 4 6 1 2 3 4 5
5 6 1 2 3 4 6 1 2 3 4 5 1 2 3 4 5 6
6 1 2 3 4 5 1 2 3 4 5 6 2 3 4 5 6 1
1 2 3 4 5 6 2 3 4 5 6 1 3 4 5 6 1 2
2 3 4 5 6 1 3 4 5 6 1 2 4 5 6 1 2 3
3 4 5 6 1 2 4 5 6 1 2 3 5 6 1 2 3 4
⑹ 拉丁方阵的如何判断拉丁方阵
拉丁方阵是一种n×n的方阵，方阵中恰有n种不同的元素，每种元素恰有n个，并且每种元素在一行和一列中 恰好出现一次。着名数学家和物理学家欧拉使用拉丁字母来作为拉丁方阵里元素的符号，拉丁方阵因此而得名。例如下图是一个3×3的拉丁方阵：
3 2 1
2 1 3
1 3 2
如果一个拉丁方阵的第一行和第一列按照元素的先后顺序来排列，那么这称为拉丁方阵的标准型，例如下 图就是一个3x3的拉丁方阵标准型，第一行和第一列都是”1 2 3”。
1 2 3
2 3 1
3 1 2
【C语言】
//t=0时，不是拉丁方阵
//t=1时，是拉丁方阵
//t=2时，是标准型拉丁方阵
#include<stdio.h>
#include<string.h>
int a[101][101],b[101][101],c[101][101];
#define clr(x) memset(x,0,sizeof(x))
int main()
{
int n,i,j,k,t;
while(scanf("%d",&n)&&n)
{
t=1;k=1;
clr(a);clr(b);clr(c);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
scanf("%d",&a[i][j]);
b[i][a[i][j]]++;
c[a[i][j]][j]++;
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
if(b[i][j]!=1||c[i][j]!=1)
{t=0;break;}
}
/*判断是否是标准型*/
if(t){
for(i=1;i<=n;i++)
if(a[1][i]!=i||a[i][1]!=i)
{k=0;break;}
if(k)t=2;
}
printf("%d
",t);
}
}