对称矩阵算法

㈠ 实对称距阵指数幂的算法

如果有n阶矩阵A，其各个元素都为实数，矩阵A的转置等于其本身(AT = A) ，则称A为实对称矩阵。

如果有n阶矩阵A，其各个元素都为实数，且aij=aji i,j=1,2,...,n（即
这儿的T表示转置），则称A为实对称矩阵。

特点

1.实对称矩阵A的不同特征值对应的特征向量是正交的。
2.实对称矩阵A的特征值都是实数，特征向量都是实向量。
3.n阶实对称矩阵A必可对角化，且相似对角阵上的元素即为矩阵本身特征值。
4.K重特征值必有K个线性无关的特征向量，或者说必有秩r(λE-A)=n-k，其中E为单位矩阵。
5.实对称矩阵的所有特征值都是实数。

㈡ 请问一下数据结构中对称矩阵的压缩存储的一 一对应关系怎么算的呀。

其实书本上说的已经够了，我就不再赘述了，下面说说不明白的地方吧！

书本上说了 1<=i,j<=n,所以矩阵下标ij是以1开始的，但书本上的k是从0开始的

则下三角区和主对角线下标ij和一维向量下标k的关系式为i(i-1)/2+j-1，如果k从1开始，则关系式为i(i-1)/2+j。

好，进入正题思路：

第1行一个，第2行两个，。。。，第i-1行i-1个；第i行元素位置在第j，也就是说，第i行截止到它有j个。

所以要分开思考，1到i-1行的元素之和+本行截止到它的元素之和=它在一维数组的位置。

第i行前面i-1行的总和为i(i-1)/2,本行第i行截止到所求元素总数为j，所以加起来为i(i-1)/2+j。然后-1，代表k从0开始。

比如想取第3行第2列矩阵元素隐射到一维数组的位置

本行第3行之前2行的元素总数为3*2/2=3 对应 [i(i-1)/2]

然后j是在本行的位置是2 对应[+j]

总的等于5

这个第3行第2列的元素应该在一维数组的第五个位置，但是一维是从零开始的，所以5-1，得到对应一维数组的下标为4.

王道书上和楼上的答案都是正确的，只不过思路和我的有点不同，我的是处的位置，他们是要求元素之前位置，区别也就+-1

㈢ k-means算法怎么为对称矩阵进行聚类

几种典型的聚类融合算法：
1.基于超图划分的聚类融合算法
(1)Cluster-based Similarity Partitioning Algorithm(GSPA)
(2)Hyper Graph-Partitioning Algorithm(HGPA)
(3)Meta-Clustering Algorithm(MCLA)
2.基于关联矩阵的聚类融合算法
Voting-K-Means算法。
3.基于投票策略的聚类融合算法
w-vote是一种典型的基于加权投票的聚类融合算法。
同时还有基于互信息的聚类融合算法和基于有限混合模型的聚类融合算法。
二、基于关联矩阵的聚类融合算法——Voting-K-Means算法
Voting-K-Means算法是一种基于关联矩阵的聚类融合算法，关联矩阵的每一行和每一列代表一个数据点，关联矩阵的元素表示数据集中数据点对共同出现在同一个簇中的概率。
算法过程：
1.在一个数据集上得到若干个聚类成员；
2.依次扫描这些聚类成员，如果数据点i和j在某个聚类成员中被划分到同一个簇中，那么就在关联矩阵对应的位置计数加1；关联矩阵中的元素值越大，说明该元素对应的两个数据点被划分到同一个簇中的概率越大；
3.得到关联矩阵之后，Voting-K-Means算法依次检查关联矩阵中的每个元素，如果它的值大于算法预先设定的阀值，就把这个元素对应的两个数据点划分到同一个簇中。

Voting-K-Means算法的优缺点：
Voting-K-Means算法不需要设置任何参数，在聚类融合的过程中可以自动地的选择簇的个数 并且可以处理任意形状的簇。因为Voting-K-Means算法在聚类融合过程中是根据两个数据点共同出现在同一个簇中的可能性大小对它们进行划分的，所以只要两个数据点距离足够近，它们就会被划分到一个簇中。
Voting-K-Means算法的缺点是时间复杂度较高，它的时间复杂度是O(n^2);需要较多的聚类成员，如果聚类成员达不到一定规模，那么关联矩阵就不能准确反映出两个数据点出现在同一个簇的概率。

package clustering;import java.io.FileWriter;import weka.clusterers.ClusterEvaluation;import weka.clusterers.SimpleKMeans;import weka.core.DistanceFunction;import weka.core.EuclideanDistance;import weka.core.Instances;import weka.core.converters.ConverterUtils.DataSource;import weka.filters.unsupervised.attribute.Remove;public class Votingkmeans2 extends SimpleKMeans { /** 生成的序列号 */ private static final long serialVersionUID = 1557181390469997876L; /** 划分的簇数 */ private int m_NumClusters; /** 每个划分的簇中的实例的数量 */ public int[] m_ClusterSizes; /** 使用的距离函数，这里是欧几里德距离 */ protected DistanceFunction m_DistanceFunction = new EuclideanDistance(); /** 实例的簇号赋值 */ protected int[] m_Assignments; /** 设定聚类成员融合阀值 */ private final static double THREASOD = 0.5; /** 生成一个聚类器 */ public void buildClusterer(Instances data) throws Exception{ final int numinst = data.numInstances(); // 数据集的大小 double [][]association = new double[numinst][numinst]; // 定义并初始化一个关联矩阵 int numIteration = 40; // 设置生成的聚类成员数 final int k = (int)Math.sqrt(numinst); // 设置K-Means聚类算法参数——簇数 for(int i = 0; i < numIteration; i++) { if(data.classIndex() == -1) data.setClassIndex(data.numAttributes() - 1); // 索引是从0开始 String[] filteroption = new String[2]; filteroption[0] = "-R"; filteroption[1] = String.valueOf(data.classIndex() + 1);// 索引是从1开始 Remove remove = new Remove(); remove.setOptions(filteroption); remove.setInputFormat(data); /* 使用过滤器模式生成新的数据集；新数据集是去掉类标签之后的数据集 */ Instances newdata = weka.filters.Filter.useFilter(data, remove); /* 生成一个K-Means聚类器 */ SimpleKMeans sm = new SimpleKMeans(); sm.setNumClusters(k); sm.setPreserveInstancesOrder(true); // 保持数据集实例的原始顺序 sm.setSeed(i); // 通过设置不同的种子，设置不同的簇初始中心点，从而得到不同的聚类结果 sm.buildClusterer(newdata); int[] assigm = sm.getAssignments(); // 得到数据集各个实例的赋值 /* 建立关联矩阵 */ for(int j = 0; j < numinst; j++) { for(int m = j; m < numinst; m++) { if(assigm[j] == assigm[m]) { association[j][m] = association[j][m] + 1.0 / numIteration ; } } } } System.out.println(); /* 将生成的关联矩阵写入.txt文件（注：生成的txt文本文件在e:/result.txt中） */ FileWriter fw = new FileWriter("e://result.txt"); for(int j = 0; j < numinst; j++) { for(int m = j; m < numinst; m++) { //由于关联矩阵是对称的，为了改进算法的效率，只计算矩阵的上三角 String number = String.format("%8.2f", association[j][m]); fw.write(number); } fw.write("\n"); } /* 处理关联矩阵，分别考虑了两种情况 ：1.关联矩阵中某个元素对应的两个数据点已经被划分到了不同的簇中 * 2.两个数据点中有一个或者两个都没有被划分到某个簇中。 */ int[] flag = new int[numinst]; int[] flagk = new int[k]; int[] finallabel = new int[numinst]; for(int m = 0; m < numinst; m++) { for(int n = m; n < numinst; n++) { if(association[m][n] > THREASOD) { if(flag[m] == 0 && flag[n] == 0) { // 两个数据点都没有被划分到某个簇中， int i = 0; // 将他们划分到同一个簇中即可 while (i < k && flagk[i] == 1) i = i + 1; finallabel[m] = i; finallabel[n] = i; flag[m] = 1; flag[n] = 1; flagk[i] = 1; } else if (flag[m] == 0 && flag[n] == 1) { // 两个数据点中有一个没有被划分到某个簇中， finallabel[m] = finallabel[n]; // 将他们划分到同一个簇中即可 flag[m] = 1; } else if (flag[m] == 1 && flag[n] == 0) { finallabel[n] = finallabel[m]; flag[n] = 1; } else if (flag[m] == 1 && flag[n] == 1 && finallabel[m] != finallabel[n]) { // 两个数据点已被划分到了不同的簇中， flagk[finallabel[n]] = 0; // 将它们所在的簇合并 int temp = finallabel[n]; for(int i = 0; i < numinst; i++) { if(finallabel[i] == temp) finallabel[i] = finallabel[m]; } } } } } m_Assignments = new int[numinst]; System.out.println("基于关联矩阵的聚类融合算法——Voting-K-Means算法的最终聚类结果"); for(int i = 0; i < numinst; i++) { m_Assignments[i] = finallabel[i]; System.out.print(finallabel[i] + " "); if((i+1) % 50 == 0) System.out.println(); } for(int i = 0; i < k; i++) { if(flagk[i] == 1) m_NumClusters++; } } /** * return a string describing this clusterer * * @return a description of the clusterer as a string */ public String toString() { return "Voting-KMeans\n"; } public static void main(String []args) { try {String filename="e://weka-data//iris.arff"; Instances data = DataSource.read(filename); Votingkmeans2 vk = new Votingkmeans2(); vk.buildClusterer(data); /* 要生成Voting-K-Means的聚类评估结果包括准确率等需要覆盖重写toString()方法； * 因为没有覆盖重写，所以这里生产的评估结果没有具体内容。 */ ClusterEvaluation eval = new ClusterEvaluation(); eval.setClusterer(vk); eval.evaluateClusterer(new Instances(data)); System.out.println(eval.clusterResultsToString()); } catch (Exception e) { e.printStackTrace(); }}}

分析代码时注意：得到的类成员变量m_Assignments就是最终Voting-K-Means聚类结果；由于是采用了开源机器学习软件Weka中实现的SimpleKMeans聚类算法，初始时要指定簇的个数，这里是数据集大小开根号向下取整；指定的阀值为0.5，即当关联矩阵元素的值大于阀值时，才对该元素对应的两个数据点进行融合，划分到一个簇中，考虑两种情况，代码注释已有，这里不再详述。但聚类融合的实验结果并不理想，莺尾花数据集irsi.arff是数据挖掘实验中最常用的数据集，原数据集共有三个类；但本实验进行四十个聚类成员的融合，其最终聚类结果划分成两个簇；其原因可能有两个：一是算法本身的问题，需要使用其他更加优化的聚类融合算法；二是实现上的问题，主要就在聚类结果的融合上，需要进行一步对照关联矩阵进行逻辑上的分析，找出代码中的问题。关联矩阵文本文件http://download.csdn.net/detail/lhkaikai/7294323

---------------------

本文来自 Turingkk 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/lhkaikai/article/details/25004823?utm_source=

㈣ 实对称矩阵行列式的值怎么求，求方法！！！！！！

解: |A-λE|=

|2-λ 2 -2|

|2 5-λ -4|

|-2 -4 5-λ|

r3+r2 (消0的同时, 还能提出公因子, 这是最好的结果)

|2-λ 2 -2|

|2 5-λ -4|

|0 1-λ 1-λ|

c2-c3

|2-λ 4 -2|

|2 9-λ -4|

|0 0 1-λ|

= (1-λ)[(2-λ)(9-λ)-8] (按第3行展开, 再用十字相乘法)

= (1-λ)(λ^2-11λ+10)

= (10-λ)(1-λ)^2.

如果有n阶矩阵A，其矩阵的元素都为实数，且矩阵A的转置等于其本身（aij=aji）(i,j为元素的脚标)，而且该矩阵对应的特征值全部为实数，则称A为实对称矩阵。

主要性质：

1.实对称矩阵A的不同特征值对应的特征向量是正交的。

2.实对称矩阵A的特征值都是实数，特征向量都是实向量。

3.n阶实对称矩阵A必可对角化，且相似对角阵上的元素即为矩阵本身特征值。

4.若λ0具有k重特征值必有k个线性无关的特征向量，或者说必有秩r(λ0E-A)=n-k，其中E为单位矩阵。

之前恰有j个元素，即ai0,ai1,…,ai,j-1，因此有：

sa[i×(i+1)/2+j]=aij

③aij和sa[k]之间的对应关系：

若i≥j，k=i×(i+1)/2+j0≤k<n(n+1)/2

若i<j，k=j×(j+1)/2+i0≤k<n(n+1)/2

令I=max(i，j)，J=min(i，j)，则k和i，j的对应关系可统一为：

k=i×(i+1)/2+j0≤k<n(n+1)/2

（3）对称矩阵的地址计算公式

LOC(aij)=LOC(sa[k])

=LOC(sa[0])+k×d=LOC(sa[0])+[I×(I+1)/2+J]×d

通过下标变换公式，能立即找到矩阵元素aij在其压缩存储表示sa中的对应位置k。因此是随机存取结构。