最后一个星期就要交了

[loleney]

只剩最后一个星期了,老师要逼我们交了,一点头绪还没有,有会的帮帮忙啊!

一:稀疏矩阵的算法设计。设计矩阵为N*M的。
（1）选用一种存储结构（三元组、邻接表或十字链表）
（2）实现矩阵的转置运算
（3）实现两个矩阵的乘法
（4）实现两个矩阵的加法
（5）矩阵输入以三元组方式从键盘输入或从文件导入
（6）矩阵的输出按普通矩阵的阵列输出

二、皇后问题
求出在N*N的棋盘上放置N个棋子（皇后）的所有合法布局。布局合理规则是：在棋盘任一行、一列和任意对角线上都不能出现两个棋子。

要求：
（1）用递归与非递归算法均可
（2）从键盘输入N
（3）输出所有合法布局

[jxegong]

我想很多数据结构的书上应该有现成的代码吧，因为这些都是典型的例子。

[loleney]

知道，但是都实现不了啊，我要的是详细的代码啊．谢谢哦

[我啃]

一:稀疏矩阵的算法设计。设计矩阵为N*M的。
（1）选用一种存储结构（三元组、邻接表或十字链表）
（2）实现矩阵的转置运算
（3）实现两个矩阵的乘法
（4）实现两个矩阵的加法
（5）矩阵输入以三元组方式从键盘输入或从文件导入
（6）矩阵的输出按普通矩阵的阵列输出
强烈要求用MTL
二、皇后问题
求出在N*N的棋盘上放置N个棋子（皇后）的所有合法布局。布局合理规则是：在棋盘任一行、一列和任意对角线上都不能出现两个棋子。

一个二维数组,每次尝试标记不可放置区域为1其他为0,尝试求解,就是8皇后问题地推广

要求：
（1）用递归与非递归算法均可
（2）从键盘输入N
（3）输出所有合法布局

[happytang]

一.转置:
1.数据结构定义:(三元组)
#define smax 16 ； /* 最大非零元素个数的常数 */
typedef int datatype；
typedef struct
{ int i, j； /* 行号，列号 */
datatype v； /* 元素值 */
}node；
typedef struct
{ int m, n, t； /* 行数，列数，非零元素个数 */
node data[smax]； /* 三元组表 */
} spmatrix； /* 稀疏矩阵类型 */
2.稀疏矩阵转置算法:
spmatrix* transmat(spmatrix *a)
{
/*返回稀疏矩阵的转置*/
int ano,bno,col;
spmatrix *b;
b=(spmatrix*)malloc(sizeof(spmatrix));
b->m=a->n;b->n=a->m;
b->t=a->t;
if(b->t>0){
bno=0;
for(col=0;col<a->n;col++)
for(ano=0;ano<a->t;ano++)
if(a->data[ano].j==col){
b->data[bno].i=a->data[ano].j;
b->data[bno].j=a->data[ano].i;
b->data[bno].v=a->data[ano].v;
bno++;
}
}
return b;
}
二.稀疏矩阵的加法:(LMatrix为稀疏矩阵类型,以下为C++代码)
1.数据结构定义:(三元组)
struct TripleNode{//表示一个元素的三元组
int row,col;

Elemtylpe val;

};
struct LMatrix {//稀疏矩阵的顺序存储类型
int m,n,t;
TripleNode vector[MaxTerms + 1];
}；
2.两稀疏矩阵相加算法:
LMatrix Add(LMatrix& M1, LMatrix& M2) {
LMatrix M; InitMatrix(M);
if ((M1.m != M2.m)||(M1.n != M2.n)) {
cerr<<“Can’t add two matrix”<<endl;
exit(1); }
M.m=M1.m; M.n=M1.n;
if ((M1.t==0 &&(m2.t==0)) return M;
int k=0; //统计非0 项数
for(int i=1; i<=M1.m; i++) { //按行扫描
TripleNode *p1,*p2, *p;
p1=M1.vector[i]; // M1的行指针
p2=M2.vector[i]; // M2的行指针
p=M.vector[i]; // M的行指针
While((P1 !=NULL) &&(p2 !=NULL)) {
TripleNode *newptr=new TripleNode;
if(p1->col < p2->col) { //列不相同时先连接小的
*newptr= *p1;
p1=p1->next;
}
else if(p1->col > p2->col) {
*newptr= *p2;
p2=p2->next;
}
else //列相同则值相加
newptr->next = NULL;
if (p==NULL) m.vector[ i ]=newptr;
else p->next = newptr;
p=newptr;
k++;
} // end of while
while (p2 !=NULL) { //p1已经结束
TripleNode * newptr= new TripleNode;
*newptr= *p2;
newptr->next=NULL;
if(p==NULL) M.vector[ i ]=newptr;
else p->next= newptr;
p=newptr;
p2=p2->next;
k++; }//end of while
}// end of for
M.t=k;
return M;
}
三.稀疏矩阵的乘法:
1.数据结构定义:(行逻辑连接的顺序表)
typedef struct{
Triple data[MAXSIZE+1]; //非零元三元组表
int rpos[MAXRC+1]； //各行第一个非零元的位置表
int mu，nu， tu； //矩阵的行数、列数和非零元个数
}RLSMatrix；
2.稀疏矩阵相乘算法:(RLSMatrix为行逻辑连接的顺序表表示的稀疏矩阵类型,以下为C++代码)
Status MultSMatrix( RLSMatrix M，RLSMatrix N，RLSMatrix &Q){
//求矩阵乘积Q=M*N，采用行逻辑链接存储表示。
if(M.nu!=N.mu)return ERROR；
Q.mu=M.mu；Q.nu=N.nu；Q.tu=0； //Q初始化
if(M.tu*N.tu!=0){ //Q是非零矩阵
for(arow=1; arow<=M.mu; ++arow){ //处理M的每一行
ctemp[ ]=0； //当前行各元素累加器清零
Q.rpos[arow]=Q.tu+1；
for(p=M.rpos[arow]；p<M.rpos[arow+1]；++p){ //对当前行中每个非零元
brow=M.data[p].j //找到对应元在N中的行号
if(brow<N.nu) t=N.rpos[brow+1]；
else { t=N.tu+1 }
for( q=N.rpos[brow]； q<t； ++q){
ccol=N.data[q].j； //乘积元素在Q中列号
ctemp[ccol]+=M.data[p].e*N.data[q].e；}//for q
}//求得Q中第crow(=arow)行的非零元
//压缩存储该行非零元
for(ccol=1；ccol<=Q.nu；++ccol)
if(ctemp[ccol]){
if(++Q.tu>MAXSIZE) return ERROR；
Q.data[Q.tu]={arow，ccol，ctemp[ccol]}；}//if
}//for arow
}//if
return OK；
}// MultSMatrix

[happytang]

N皇后问题答案太多了
递归的，非递归的。效率有高有低
只给各简单的例子：
语言中应用递归解N皇后问题.
/* ======================================== */
/* 程式实例: 6_6.c */
/* 应用递归来解 N 皇后问题 */
/* 数字 1: 表示是放置皇后 */
/* 数字 0: 表示没有放置 */
/* ======================================== */
#define MAXQUEEN 8 /* 最大放置的皇后数 */

int pad[MAXQUEEN][MAXQUEEN] = { /* N X N 的棋盘 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };

/* ---------------------------------------- */
/* 放 N 个皇后的递归函数 */
/* ---------------------------------------- */
int put_queen(int x,int y,int times)
{
int i,j,result = 0;

if ( times > MAXQUEEN ) /* 终止条件 */
return 1;
else
if ( place(x,y) ) /* 检查是否可放置皇后 */
{
pad[x][y] = 1; /* 放置皇后 */
for ( i = 0; i < MAXQUEEN; i++)
for ( j = 0; j < MAXQUEEN; j++)
{
/* 递归调用放置下一个皇后 */
result += put_queen(i,j,times + 1);
if ( result > 0 )
break;
}
if ( result > 0 ) /* 找到了解 */
return 1;
else
{
pad[x][y] = 0; /* 清除皇后 */
return 0;
}
}
else
return 0;
}

/* ---------------------------------------- */
/* 检查皇后是否有相互攻击 */
/* ---------------------------------------- */
int place(int x,int y)
{
int x1,y1;

if ( pad[x][y] != 0 ) /* 己放置皇后 */
return 0;
x1 = x - 1; /* 检查左上方 */
y1 = y - 1;
while ( x1 >= 0 && y1 >= 0 )
if ( pad[x1--][y1--] != 0 )
return 0;
x1 = x + 1; /* 检查右下方 */
y1 = y + 1;
while ( x1 < MAXQUEEN && y1 < MAXQUEEN )
if ( pad[x1++][y1++] != 0 )
return 0;
x1 = x + 1; /* 检查右上方 */
y1 = y - 1;
while ( x1 < MAXQUEEN && y1 >= 0 )
if ( pad[x1++][y1--] != 0 )
return 0;
x1 = x - 1; /* 检查左下方 */
y1 = y + 1;
while ( x1 >=0 && y1 < MAXQUEEN )
if ( pad[x1--][y1++] != 0 )
return 0;
x1 = x; /* 检查下方 */
y1 = y + 1;
while ( y1 < MAXQUEEN )
if ( pad[x1][y1++] != 0 )
return 0;
x1 = x; /* 检查上方 */
y1 = y - 1;
while ( y1 >= 0 )
if ( pad[x1][y1--] != 0 )
return 0;
x1 = x + 1; /* 检查右方 */
y1 = y;
while ( x1 < MAXQUEEN )
if ( pad[x1++][y1] != 0 )
return 0;
x1 = x - 1; /* 检查左方 */
y1 = y;
while ( x1 >= 0 )
if ( pad[x1--][y1] != 0 )
return 0;
return 1;
}

/* ---------------------------------------- */
/* 主程式: 用递归的方法解 N = 8 皇后问题. */
/* ---------------------------------------- */
void main()
{
int i,j;

put_queen(0,0,1); /* 调用递归函数 */
printf("放置八皇后的棋盘图形:\n");
for ( i = 0; i < MAXQUEEN; i++) /* 印出棋盘的图形 */
{
for ( j = 0; j < MAXQUEEN; j++)
printf("%d",pad[i][j]); /* 印出各座标值 */
printf("\n"); /* 换行 */
}
}