北邮机试 -- 96\97 矩阵幂/二叉排序树

96. 矩阵幂

时间限制 1000 ms 内存限制 65536 KB

题目描述

​给你一个n*n的矩阵，

P，

求其矩阵的k次幂，即Pk

输入格式

第一行，一个整数T（0<T<=10），表示要求矩阵的个数。

接下来有T组数据，每组数据格式如下：

第一行：两个数据n（2<=n<=10）、k（1<=k<=5），两个数字之间用一个空格隔开，其中n表示状况空间的总数，k表示待求的转移概率矩阵的步数。接下来有n行n列个正整数，其中，第i行第j列表示pij，（0<=pij<=10）。另外，数据保证最后结果不会超过10^8。

输出格式

输出为T组数据。

每组数据为已知矩阵的k次幂，格式为：

n行n列个正整数，每行数之间用空格隔开，注意，每行最后一个数后面不应该有多余的空格。

输入样例

3
2 2
9 8
9 3
3 3
4 8 4
9 3 0
3 5 7
5 2
4 0 3 0 1
0 0 5 8 5
8 9 8 5 3
9 6 1 7 8
7 2 5 7 3

输出样例

153 96
108 81
1216 1248 708
1089 927 504
1161 1151 739
47 29 41 22 16
147 103 73 116 94
162 108 153 168 126
163 67 112 158 122
152 93 93 111 97

 

#include<iostream>
#include<string.h>

using namespace std;

struct matrix{// 矩阵类
	int value[13][13];  //存储矩阵内容
	int row;
	int col;
	matrix(){
		row=col=0; 
		memset(value,0,sizeof(value));
	}
	 
};

void identity(matrix &m){  //矩阵单位化的实现 
	for(int i=0;i<m.row;i++){
		for(int j=0;j<m.col;j++)
			if(i==j) m.value[i][j]=1;
			else m.value[i][j]=0;
	}
}

matrix  pow(matrix m,int p){//幂运算的实现
	matrix result;
	matrix temp;
	
	if(m.row!=m.col) return result;
	else{
		
		result.row=result.col=m.row;
		temp.row=temp.col=m.row;
		identity(result);
		identity(temp);
		
		for(int u=0;u<p;u++){
			
			
			for(int i=0;i<m.row;i++){
			for(int j=0;j<m.col;j++){
				
				int answer=0;
				for(int k=0;k<m.col;k++)
				{
					answer+=temp.value[i][k]*m.value[k][j];
					
				}
				
				
				result.value[i][j]=answer;
				
			}
		}
		
		   
			temp=result;
		}
		
	} 
	return result;
}

int main(){
	
	int T,n,k;
	cin>>T;
	while(T--){
		cin>>n>>k;
		matrix m,result;
		m.row=m.col=result.row=result.col=n;
		
		identity(result);
		
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				cin>>m.value[i][j];
			}
		}
		
		result=pow(m,k);
		
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(j==0)cout<<result.value[i][j];
				else cout<<" "<<result.value[i][j];
			}
			cout<<endl;
		}
}
	return 0;
}

c++ 可以把一个struct的地址空间的内容直接=赋值给另一个同类的struct，估计class也是可以的

 

97. 二叉排序树

时间限制 1000 ms 内存限制 65536 KB

题目描述

二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树：

1.        若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值；
2.        若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值；
3.        左、右子树本身也是一颗二叉排序树。

现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1。

输入格式

第一行，一个数字N（N<=100），表示待插入的节点数。

第二行，N个互不相同的正整数，表示要顺序插入节点的关键字值，这些值不超过108。

输出格式

输出共N行，每次插入节点后，该节点对应的父亲节点的关键字值

输入样例

5
2 5 1 3 4

输出样例

-1
2
2
5
3

 

 

#include<iostream> 

using namespace std;

struct TreeNode{
	int data;
	TreeNode* left;
	TreeNode* right;
	TreeNode(){
		left=NULL;
		right=NULL;
	}
	TreeNode(int d):data(d){
		left=NULL;
		right=NULL;
	}
};

TreeNode* Insert(TreeNode* root,int x){
	if(root==NULL){           //当前节点为空 直接插入
		root=new TreeNode(x);	
	}
	else if(x>root->data){ //向右节点插入 
		if(root->right==NULL) cout<<root->data<<endl;
		root->right=Insert(root->right,x);
	}else{              //向左节点插入
		if(root->left==NULL) cout<<root->data<<endl;	 
		root->left=Insert(root->left,x);
	}
	return root; 
}

int main(){
	int N;
	while(cin>>N){
		TreeNode *root=NULL;
		for(int i=0;i<N;i++){
			
			int x; cin>>x;
			if(root==NULL) cout<<-1<<endl;					
			root=Insert(root,x);
			
		}
	}
	return 0;
}

 

注意结构体的构造函数要把 node 指针初始化