求源码（c++、c#）实现稀疏矩阵和位矩阵佛洛依德算法要求将矩阵的顶点放在文件中，结果也放在文件中（急用

#include <iostream>

#include <iomanip>高明悄

using namespace std

template<class T>

//三元组

struct Trituple

{

int row

int col

T val

}

//稀疏矩阵声明

template<class T>

class SparseMatrix

{

public:

SparseMatrix(int maxt=100)

~SparseMatrix()

bool TransposeTo(SparseMatrix &)

bool AddTo(const SparseMatrix&)

bool TransposeTo_Faster(SparseMatrix&)

void Input()

void Output()

private:

Trituple<戚渣T>* data

int rows,cols,terms

int maxterms

}

template<class T>

SparseMatrix<T>::SparseMatrix(int maxt)

{

maxterms=maxt

data=new Trituple<T>[maxterms]

terms=rows=cols=0

}

template<class T>

SparseMatrix<T>::~SparseMatrix()

{

if (data!=NULL)

{

delete[] data

}

}

//普通转置

template<class T>

bool SparseMatrix<T>::TransposeTo(SparseMatrix &B)

{

if (terms>B.maxterms)

{

return false

}

B.rows=cols

B.cols=rows

B.terms=terms

if (terms>0)

{

int p=0

for (int j=1j<=colsj++)

{

for (int k=0k<termsk++)

{

if (data[k].col==j)

{

B.data[p].row=j

B.data[p].col=data[k].row

B.data[p].val=data[k].val

p++

}

}

}

}

return true

}

//快速转置

template<class T>

bool SparseMatrix<T>::TransposeTo_Faster(SparseMatrix&B)

{

if (terms>B.maxterms)

{

return false

}

B.rows=cols

B.cols=rows

B.terms=terms

if (terms>0)

{

int *num,*cpot

num=new int[cols]

cpot=new int[cols]

for (int j=0j<colsj++)

{

num[j]=0

}

for (int k=0k<termsk++)

{

num[data[k].col-1]++

}

//求出B中每一行的起始下标cpot[]

cpot[0]=0

for (int j=1j<colsj++)

{

cpot[j]=cpot[j-1]+num[j-1]

}

//执行转置 *** 作

for (int p,k=0k<termsk++)

{

p=cpot[data[k].col-1]++

B.data[p].row=data[k].col

B.data[p].col=data[k].row

B.data[p].val=data[k].val

}

delete[] num

delete[] cpot

}

return true

}

template<class T>

void SparseMatrix<T>::Input()

{

cout<<"intput the matrix' row:"

int row1

cin>>row1

cout<<"intput the matrix' col:"

int col1

cin>>col1

cout<<"input "<<row1<<"*"<<col1<<" matrix"<槐竖<endl

int number

rows=row1

cols=col1

for (int i=0i<rowsi++)

{

for (int j=0j<colsj++)

{

cin>>number

if (number!=0)

{

data[terms].row=i+1

data[terms].col=j+1

data[terms].val=number

terms++

}

}

}

}

template<class T> //输出好看，但是违背了最初的原则

void SparseMatrix<T>::Output()

{

T **tempArray=new T*[rows]

for (int i1=0i1<rowsi1++)

{

tempArray[i1]=new int[cols]

}

for (int j=0j<rowsj++)

{

for (int k=0k<colsk++)

{

tempArray[j][k]=0

}

}

for (int i=0i<termsi++)

{

tempArray[data[i].row-1][data[i].col-1]=data[i].val

}

for (int j=0j<rowsj++)

{

for (int k=0k<colsk++)

{

cout<<setw(4)<<tempArray[j][k]

}

cout<<endl

}

for (int l=0l<rowsl++)

{

delete[] tempArray[l]

}

delete tempArray

cout<<endl

}

template<class T>

bool SparseMatrix<T>::AddTo(const SparseMatrix&B)

{

if (rows!=B.rows||cols!=B.cols)

{

return false

}

bool flag=false

int tempTerms=terms

for (int i=0i<B.termsi++)

{

flag=false

for (int j=0j<tempTermsj++)

{

if (data[j].col==B.data[i].col&&data[j].row==B.data[i].row)

{

data[j].val+=B.data[i].val

flag=true

}

}

if (flag==false)

{

data[++terms-1].col=B.data[i].col //数组下标 *** 作注意事项

data[terms-1].row=B.data[i].row

data[terms-1].val=B.data[i].val

}

}

return true

}

int main()

{

cout<<"此程序演示稀疏矩阵的普通转置和快速转置 *** 作"<<endl

SparseMatrix<int>sm(50)

SparseMatrix<int>sm1(50)

SparseMatrix<int>sm2(50)

sm.Input()

cout<<"sm is"<<endl

sm.Output()

sm.TransposeTo(sm1)

cout<<"Transposition of sm is "<<endl

sm1.Output()

sm.TransposeTo_Faster(sm2)

cout<<"Transposition of sm is "<<endl

sm2.Output()

SparseMatrix<int>sm3

cout<<"input a new matrix"<<endl

sm3.Input()

cout<<"sm3 is"<<endl

sm3.Output()

if(sm.AddTo(sm3))

{

cout<<"after adding sm3 ,sm is"<<endl

sm.Output()

}

else

cout<<"the two matrix can't add"<<endl

cout<<"Good job!"<<endl

system("pause")

return 0

}

稀疏自编码器（SparseAutoencoder）可以自动从无标注数据中学习特征，可以给出比原始数据更好的特征描述。在实际运用时可以用稀疏编码器发现的特征取代原始数据，这样往往能带来更好的结果。本文将给出稀疏自编码器的算法描述，并演示说明扰庆稀疏编码器自动提取边缘特征。

稀疏性可以被简单地解释如下。如果当神经元的输出接近于1的时候我们认为态和它被激活，而输出接近于0的时候认为它被抑制，那么使得神经元大部分的时间都是被抑制的限制则被称作稀疏性限制。这里我们假帆李盯设的神经元的激活函数是sigmoid函数。