 上传我的文档
 下载
 收藏
所有文档均可在线免费浏览，需要的朋友请看好是否是自己需要的文档。所有资料来源于网络,仅供大家参考学习,版权归原作者。若有侵权，敬请及时告知，本人会及时删除侵权文档,竭诚全力为您服务！！！
 下载此文档
正在努力加载中...
计算N阶矩阵的随机一致性指标RI
下载积分：1756
内容提示：计算N阶矩阵的随机一致性指标RI
文档格式：DOC|
浏览次数：114|
上传日期： 03:55:48|
文档星级：
该用户还上传了这些文档
计算N阶矩阵的随机一致性指标RI
官方公共微信递归算法之n阶矩阵行列式求解 - 推酷
递归算法之n阶矩阵行列式求解
设计算法时使用递归的思想是一个程序员的基本素质，递归可以把一个很庞大的问题转化为规模缩小了的同类问题的子问题，通过这一思想，我们编程时运用递归可以使用很少的代码来处理很大的问题。这篇文章将会讲到递归算法的运用。
在数学中，很多数学函数都是由一个公式来表达的，比如 f(x) = 100x ; 这个公式可以让我们把长度米转换成长度厘米。 有了这个公式，在程序中敲出一行代码，写出一个函数（function）来计算实在是太简单方便了，就像这样。
int convert(int m){
return 100*m;
我们就写好了一个函数来进行米到厘米的单位换算。
但是有的时候，数学函数会以不太标准的形式来定义，比如这个函数，他满足 f(0)=0 而且 f(x) = 2f(x-1)+x ; 从这个函数定义我们可以得出 f(1)=1 ; f(2)=3 ;等等。当一个函数用他自己来定义时就称为这个函数是递归的。
通俗地讲，就是从前有个山，山里有个庙，庙里有个老和尚再给小和尚讲故事，讲的是：从前有个山，山里有个庙，庙里有个老和尚再给小和尚讲故事。。。。这就是递归。
好了说了这么多你们肯定还是一头雾水，现在来实践一下。
递归求阶乘
刚开始学编程的同学一定会写求阶乘的函数，使用for循环或者while循环都可以，但是递归却完全用不上这两个循环。
public static int factorial(int a){
if (a==0 || a==1){
return a*factorial(a-1);
上面的代码就是递归求阶乘的方法，a是需要传入的参数，比如我们要求5的阶乘就传入5这样factorial函数最终的返回值为120；
分析这段代码，他的第3行到第五行处理了 基准情况（Base Case） ，在这个情况下，函数的值可以直接算出而不用求出递归。就像上文提到的函数 f(x) = 2f(x-1)+x ;如果没有f(0)=0这个事实在数学上没有意义一样。 再编程中，如果没有基准情况也是无意义的。第7行执行的是递归调用。
所以所，设计递归算法，需要包含以下两个基本法则：
1、基准情形（Base Case），必须总要有某些基准的清醒，在这个情形中，不执行递归就能求解。
2、不断推进（Making Progress），对于需要递归求解的情形，递归调用必须总能够朝着一个基准情形推进。这样的话，不断推进到基准情形，到达基准情形的时候递归才会推出，得到返回值。
n阶矩阵行列式的求解
有了刚在知识的铺垫，现在我们可以动手写一个程序来用递归计算n阶矩阵的行列式了。
首先来看下二阶矩阵的求法：
也就是说2&2矩阵的元素交叉相乘再想减即可求出行列式。
接下来是3阶矩阵：
3&3矩阵求解中，选择任意行或者列，在那一行/列中,移除那个元素所在的行和列比如选择a11，则移除第一行和第一列，这样矩阵就变成了2&2的，再按照刚才的方法求2&2矩阵的行列式即可。之后整个行或列的3个元素进行此类运算后相加就是3&3的行列式。
n x n矩阵：
n阶矩阵就和3阶矩阵求解的方法一样了，使用3&3求解的方法，比如4阶矩阵，将4阶消除成3阶，然后再变成2阶来算。但是矩阵每上升一个维度，计算量就会扩大很多。
知道了n阶矩阵行列式的计算思路后，就可以开始编写算法了。
首先是数据结构设计，我们需要设计一个矩阵类来提供便利，这个类有两个成员，一个二维数组，用来储存矩阵，一个整数，来储存矩阵的行数或列数（行列式必须是方矩阵才可以求解所以行列无所谓）。
以下是整个Matrix类的设计：
static class Matrix{
private int rowNum=0;
private int[][]
//Constructor
public Matrix(int rowNum){
this.rowNum = rowN
array = new int[rowNum][rowNum];
public Matrix(int[][] array){
this.array =
this.rowNum = array.
int counter = 0; //For add Element
public void addElement(int a){
array[(counter)/rowNum][counter%rowNum] =
counter++;
//Print the instance itself
public void printMat(){
for (int i=0;i & rowNi++){
for (int j=0;j & rowNj++){
System.out.print(array[i][j]+\t;);
System.out.println();
//Setter and Getter
public int getRowNum() {
return rowN
public int[][] getArray() {
public void setArray(int[][] array) {
this.array =
Matrix类中有两个构造方法：传入整数a会初始化一个axa大小的空矩阵，传入一个二维数组的话即可根据二维初始化一个Matrix对象。
Matrix类中有一个方法比较特殊：addElement方法，通过不断调用这个函数即可向一个Matrix实例进行有顺序的负值，第一次调用则会更改第第一行第一列位置上的值，第二次调用则会更改第一行第二列上的值，以此类推。
接下来就是设计一个MatrixCalculator类的，这个类中的一个成员方法可以求出行列式，我命名他为getDet(); 在计算行列式的时候需要移除元素所在的行和列，生成一个减小了一个维度的矩阵，我们需要编写一个方法来完成这个操作，我命名他为removeRowAndCol()；还有一个方法，由于相加的时候会产生符号的改变，所以需要写一个方法来计算矩阵中一个元素的cofactor，命名为getCofactor。
以下就是removeRowAndCol方法的代码：传入需要移除的行和列和一个Matrix对象，函数会返回消除了指定行和列的Matrix对象。
public static Matrix removeRowAndCol(int row,int col,Matrix mat){
int matRowNum = mat.getRowNum();
int[][] arr = mat.getArray();
Matrix matrix = new Matrix(matRowNum-1);
for (int i = 0;i & matRowN i++){
for (int j = 0 & matRowN j++){
if (i!=row && j!=col) {
matrix.addElement(arr[i][j]);
matrix.printMat();
以下是getCofactor方法：由于我的算法只会去遍历矩阵第一列来进行求解，所以得到Cofactor的代码就变得简单很多。
public static int getCofactor(int colNum){
if (colNum%2 == 0){
return -1;
接下来就是核心的递归求解行列式的算法了，先理一下思路， 递归算法的两个要素：基准情形，不断推进 。
对于n阶矩阵什么是基准情形呢？就是矩阵被降为2&2维度的时候，直接返回交叉相乘的差即可，不断推进，如果是一个4阶矩阵，算法会先把4将为3&3矩阵，然后3&3再拆成3个2&2矩阵来达到基准情形来算出答案，就和我们手算行列式时用到的方法一样，手算时候也遵循这一算法。
public static int getDet(Matrix targetMatrix){
//Base (Finally reduced to 2 x 2 Matrix)
if (targetMatrix.rowNum == 2){
int[][] arr = targetMatrix.getArray();
// a*d - b*c
return arr[0][0]*arr[1][1] - arr[0][1]*arr[1][0];
//MARK- Recursion: to reduce dimension
int det = 0;
int colNum = targetMatrix.rowN
for (int i = 0; & colNi++){
det+= (targetMatrix.getArray()[i][0])*getCofactor(i)*getDet(removeRowAndCol(i,0,targetMatrix));
只有不到20行代码，但是却可以解决nxn的矩阵，是不是很神奇，这就是递归的优势，把一个很庞大的问题转化为规模缩小了的同类问题的子问题来求解。n阶矩阵最后被降为若干个2&2矩阵。
加上适当的输出语句，来求解一个3阶矩阵行列式试一下：
Element: 2
Cofactor: 1
Removing Row 0 Col 0
A 2 x 2 Matrix is initialized
END State Reached
Element: -1
Cofactor: -1
Removing Row 1 Col 0
A 2 x 2 Matrix is initialized
END State Reached
Element: 13
Cofactor: 1
Removing Row 2 Col 0
A 2 x 2 Matrix is initialized
END State Reached
但是有一个问题需要注意，就是这个算法的复杂度。
算法复杂度
这个算法的复杂度为O(n!), 这意味着他的运行速度很慢，随着问题规模的增长，时间会大幅度增长。在我的电脑上，计算3&3到7&7内规模的矩阵，电脑都可以秒算出来，但是如果是一个10&10的矩阵，电脑需要54秒钟，到了11&11时间将会变得更长，下图是这个算法随着问题规模增长对运行时产生影响的曲线。
可以看出7&7矩阵需要递归517次，到了10&10需要大约260万次递归运算才能得到结果。可见问题规模增长后时间的开销是十分巨大的。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
一．&&&&&& 算术运算(Arithmetic Computation)
MATLAB 提供的两种运算方式：
（1）&& 普通的数组运算方式：(Array computation) 在数组中对应元素之间进行运算；
（2）&& 矩阵运算方式：(matrix computations) 将标量当作1×1阶矩阵，一维数组当作一行或一列的矢量（即1×n阶或 n×1阶的矩阵），二维数组当作m×n阶矩阵，然后按照矩阵的运算规则进行运算
&*二者输入形式和书写方法相同，差别仅在于使用不同的运算符号，执行不同的计算过程，数组的运算是对应元素之间的运算，而矩阵运算是根据矩阵的运算规则进行
1． 加减运算(addition and subtraction)
矩阵与数组的加减运算没有区别，运算符均为+-，运算方法相同，但两个运算对象必须是同阶矩阵，否则将给出错误信息如下例：
a=[1 2 3;4 5 6;7 8 9];
b=[1 3 5];
运行结果给出错误信息：
??? Error using ==&±
Matrix dimensions must agree.
但标量，即1×1阶矩阵可以和其他不同维数的矩阵进行加减运算，如：a+5
6&&& 7&&&& 8
9&&& 10&&& 11
12&& 12&& 14
2． 乘除运算(Multiplication and division)
矩阵在进行乘除运算时与通常的运算符号相同(*, /, \ )，而数组在进行乘除运算时要在通常的符号前加.，如：.* 和./ (或 .\ )
(1) 矩阵乘法：(Matrix multiplication)
条件：两矩阵中前一矩阵的列数与后一矩阵的行数相同， 如
x=[1& 2 ; 3& 4];
y=[5& 6 ; 7& 8];
19&&&&&&&&&&&&& 22
43&&&&&&&&&&&&& 50
也可以实现两个相同维数矢量的内积（点乘,dot product），如：
a=[-1& 0& 2 ]&&& &% (输入行矢量转置为列矢量，等同于a=[-1;0;2])
b=[-2& -1& 1]
ans =&&& 4
ans =&&& 4
MATLAB计算点乘(dot product)和叉乘(cross product)有专门的命令，用dot(a,b)计算矢量a和b的点乘，用cross(a,b) 计算叉乘
矩阵可以和标量相乘，标量可以是乘数也可以是被乘数，都是将矩阵中的每一个元素与标量相乘如：
x=[-1& 0 &2];
&& -3.1416&&&&&&&& 0&&& 6.2832
(2) 数组的乘法 (Array multiplication)
条件：a,b两数组必须有相同的维数,则a.*b 表示a和b中对应元素之间相乘，即z(i,j)=x(i,j)*y(i,j).如：
x=[1& 2& 3];
y=[4& 5& 6];
4&&& 10&&& 18
(3) 矩阵除法 (Matrix division)
条件：a矩阵是非奇异方阵，则a\b(左除)和b/a（右除）都可以实现a\b等效于a矩阵的逆左乘b矩阵，即a\b=inv(a)*b， b/a等效于a矩阵的逆右乘b矩阵，即b/a=b*inv(a).
通常x=a\b 是a*x=b 的解，x=b/a 是x*a=b的解一般a\ bb/a,
右除与左除的关系为：(b/a)=(a\b),如；
&&& 0.6038&&& 0.0153&&& 0.9318
&&& 0.2722&&& 0.7468&&& 0.4660
& &&0.1988&&& 0.4451&&& 0.4186
&&& 0.8462&&& 0.6721&&& 0.6813
&&& 0.5252&&& 0.8381&&& 0.3795
&&& 0.2026&&& 0.0196&&& 0.8318
&&& 4.3420&& 10.5808&& -9.1715
&&& 0.3128&&& 1.1052&& -0.3169
&& -1.9105&& -6.1529&&& 6.6792
&&& 1.4864&&& 5.5604&& -7.8702
&&& 0.7162&&& 4.5085&& -5.7059
&& -0.0482&& -3.6273&&& 6.1317
&&& 1.4864&&& 0.7162&& -0.0482
&&& 5.5604&&& 4.5085&& -3.6273
&& -7.8702&& -5.7059&&& 6.1317
&&& 1.4864&&& 0.7162&& -0.0482
&&& 5.5604&&& 4.5085&& -3.6273
&& -7.8702&& -5.7059&&& 6.1317
(4) 数组的除法(Array division)
条件：a与b必须具有相同的维数符号. \ 或 . / ,运算结果相同，a.\b 表示b中的元素分别除以a中的对应元素,即z(i,j)=x(i,j)\y(i,j)=y(i,j)/x(i,j) 如：
x=[1& 2& 3];
y=[4& 5& 6];
&&& 4.0000&&& 2.5000&&& 2.0000
3. 乘方(Power)
(1) 矩阵的乘方(Matrix power)
条件：在a^p 中a, p不可都是矩阵，必须一个是标量，一个是方阵
a^p 意思是a的p次方
*A是一个方阵，p是一个标量，且p 是大于1 的整数，则a的p次幂即为a自乘p次&&&&&&&&&&&&&&
*如p是不为整数的标量时， &a^p=V*D.^p/V 其中D为矩阵a的特征值矩阵,V为对应的特征矢量阵，可用eig函数求出D和V， [V,D]=eig(a).
*当p 是方阵而a是标量时，a^p=V*a.^D/V, 其中[V,D]=eig(p).
(2) 数组的乘方(Array power) &&符号& .^
条件：在底与指数均为数组的情况下，要求他们的维数必须相同
*当底和指数为同样大小的数组时，x.^y 为对应的元素做乘方运算如：
x=[1& 2& 3];
y=[4& 5& 6];
1&&& 32&& 729
这时执行的实际运算为：
z=x.^y=[1& 2& 3].^[4& 5& 6]=[1^4& 2^5& 3^6]=[1& 32& 729]
*若指数是标量，执行的运算是底的每一个元素执相同幂次的运算既z(i,j)=x(i,j)^2
x=[1& 2& 3];
得到结果为：
这时执行的运算为：
z=[1& 2& 3].^2=[1^2& 2^2&& 3^2]=[1& 4& 9]
*若底是一个标量，指数是一个数组，执行的运算是用指数数组的每个元素对底进行乘方运算，即： z(i,j)=2^x(i,j),形成新的数组 如：
x=[1& 2& 3];
2&&&& 4&&&& 8
这时执行的运算为：
z=2.^x=2.^[1& 2& 3]=[2^1& 2^2& 2^3]
4． 转置：(Transpose) &&行列转置，符号 &&
如；计算矩阵a的转置：
a=[1& 2& 3; 4& 5& 6; 7& 8& 9& ];
&&&& 1&&&& 4&&&& 7
&&&& 2&&&& 5&&&& 8
&&&& 3&&&& 6&&&& 9
也可直接对矢量或矩阵进行转置运算；
[-1& 0& 2]
如z是复数矩阵，则z 是它的复数共轭.转置(Complex conjugate transpose )，若要进行非共轭转置运算，可使用z. 或conj(z) 求得 例；
z=[1+2i& 3+4i];
&& 1.0000 - 2.0000i
&& 3.0000 - 4.0000i
&& 1.0000 + 2.0000i
&& 3.0000 + 4.0000i
&& 1.0000 + 2.0000i
&& 3.0000 + 4.0000i
CONJ &&Complex conjugate.
&&& CONJ(X) is the complex conjugate of X.
&&& For a complex X, CONJ(X) = REAL(X) - i*IMAG(X).
二． 数学函数和矩阵函数( Mathematic function and matrix function)
1． 数学函数(Math function)
(a). 基本函数：(Elementary function)三角函数(Trigonometric Function)指数函数(Exponent function)复数函数(Complex Function)取整和求余函数(round and remain function)（常用基本函数见表2-1，要求课后阅读记忆）
例: a=[1& 2& 3; 4& 5& 6]
b=fix(pi*a)&&&&&&& &%朝零方向取整
c=cos(pi*b)
&&&& 1&&&& 2&&&& 3
&&&& 4&&&& 5&&&& 6
&&&& 3&&&& 6&&&& 9
&&& 12&&& 15&&& 18
&&& -1&&&& 1&&& -1
&&&& 1&&& -1&&&& 1
说明：（1） 三角函数按弧度计算
（3）& 除后取模mod(x,y)与y符号相同，除后取余数rem(x,y) 与x符号相同，当x与y符号相同时 ，mod(x,y)等于rem(x,y).
x=[11 25 31];
y=[4 5 6];
M=mod(x,y)
R=rem(x,y)
&&&& 3&&&& 0&&&& 1
&&&& 3&&&& 0&&&& 1
x=[-11 25 -31];
y=[4 5 6];
M=mod(x,y)
R=rem(x,y)
&&&& 1&&&& 0&&&& 5
-3&&&& 0&&& -1
MOD &&&Modulus after division.
MOD(x,y) is x - n.*y where n = floor(x./y) if y ~= 0.& If y is not an
integer and the quotient x./y is within round off error of an integer, then n is that integer.& By convention, MOD(x,0) is x.& The input x and y must be real arrays of the same size, or real scalars.
The statement "x and y are congruent mod m" means mod(x,m) == mod(y,m).
REM& &&Remainder after division.
REM(x,y) is x - n.*y where n = fix(x./y) if y ~= 0.& If y is not an integer and the quotient x./y is within roundoff error of an integer,then n is that integer.& By convention, REM(x,0) is NaN.& The input x and y must be real arrays of the same size, or real scalars.
REM(x,y) has the same sign as x while MOD(x,y) has the same sign as y.
REM(x,y) and MOD(x,y) are equal if x and y have the same sign, but
&&& differ by y if x and y have different signs.
(b) 特殊函数：(Special function)特殊数学函数(special mathematics function)数理函数(Mathematic analysis function)坐标变换(Coordinates transformation function)（表2-2）
2. 矩阵函数：(Matrix function) 矩阵分析(Matrix Analysis)线性方程组(linear system of equations)特征值和特征矢量(Eigenvalues and eigenvectors.)矩阵函数(Matrix function)因式分解(Factor analysis) 等矩阵函数（表2-3）
有些矩阵函数与数学函数名称相似，区别在于矩阵函数名称后有m字符
a=[1& 4; 9& 16];
r1=sqrt(a)
r2=sqrtm(a)
&&&& 1&&& &2
&&&& 3&&&& 4
&& 0.4662 + 0.9359i&& 0.8860 - 0.2189i
&& 1.9935 - 0.4924i&& 3.7888 + 0.1152i
SQRT &&Square root.
&&& SQRT(X) is the square root of the elements of X. Complex
&&& results are produced if X is not positive.
SQRTM &&&&Matrix square root.
&&& X = SQRTM(A) is the principal square root of the matrix A, i.e. X*X = A.&&&&&&&&&&
&&& X is the unique square root for which every eigenvalue has nonnegative real part.& If A has any eigenvalues with negative real parts then a complex result is produced.& If A is singular then A may not have a square root. A warning is printed if exact singularity is detected.
三． 关系运算与逻辑运算(Relational calculus and Logical operation)
1．关系运算：(Relational calculus)
条件：对于两个矩阵的关系运算，两边的矩阵必须具有同样尺寸
关系运算符：(Relational operator)
﹤ 小于(less than)﹤=小于等于(less than or equal to)﹥大于（greater than）﹥=大于等于(greater than or equal to)== 等于(equal to)～=不等于(not equal to ,NE)
a=[0& -1& 2];
b=[-3& 1& 2];
&&&&& 0&&&& 1&&&& 0
&&&&&& 0&&&& 1&&&&& 1
&&&&&& 1&&&& 0&&&&& 0
&&&&&& 1&&&& 0&&&& 1
&&&&& &0&&&& 0&&&&& 1
&&&&&&&1&&&&& 1&&&&& 0
在程序的流程控制中，关系运算符通常if, while, for, switch 等控制命令使用
2．&&&&&&&&&&&& 逻辑运算(Logical operation)
逻辑运算符：(Logical operator)
& 与（AND），& |& 或（OR），& ~ 非（NOT）
条件：对于两个矩阵的逻辑运算，两边的矩阵必须具有同样尺寸
~ 是一元算符，当a为零时，返回信息为1，为非零时，返回信息为 0# p|(~p) 返回值为 1, # p&(~p) 返回值为0
例：a=[1& 2& 3; 4& 5& 6];
b=[-1& 0& 0; 0& 0.5& 0];
&&&& 1&&&& 0&&&& 0
&&&& 0&&&& 1&&&& 0
&&&&& 1&&&& 1&&&& 1
&&&&& 1&&&& 1&&&& 1
&&& &0&&&& 1&&&& 1
&&&& 1&&&& 0&&&& 1
3．关系函数和逻辑函数 (Relational function and Logical function)& （表26）
例： a=magic(6)&&&&&&& ％建立6阶魔术矩阵，元素由1～n2组成
p=(rem(a,3)==0)&&& ％对a求余，有余数置0，无余数置1
format +;&& p&&&&& ％以format +格式给出p的压缩格式
format&&&&&&&&&&& ％将显示格式转换为缺省的短格式
i=find(y&10);&&&&&& ％找出y矩阵中大于10的元素的位置i
y(i)=10*ones(1)&&&& % 用10代替y中所有大于10 的元素
&&& 35&&&& 1&&&& 6&&& 26&&& 19&&& 24
&&&& 3&&& 32&&&& 7&&& 21&&& 23&&& 25
&&& 31&&&& 9&&&& 2&&& 22&&& 27&&& 20
&&&& 8&&& 28&&& 33&&& 17&&& 10&&& 15
&&& 30&&&& 5&&& 34&&& 12&& &14&&& 16
&&&& 4&&& 36&&& 29&&& 13&&& 18&&& 11
&&&& 0&&&& 0&&&& 1&&&& 0&&&& 0&&&& 1
&&&& 1&&&& 0&&&& 0&&&& 1&&&& 0&&&& 0
&&&& 0&&&& 1&&&& 0&&&& 0&&&& 1&&&& 0
&&&& 0&&&& 0&&&& 1&&&& 0&&&& 0&&&& 1
&&&& 1&&&& 0&&&& 0&&&& 1&&&& 0&&&& 0
&&&& 0&&&& 1&&&& 0 &&&&0&&&& 1&&&& 0
&&&&&&&&&&&& +&&&&&&&&&&&&&&& +
+&&&&&&&&&&&&&&&&& +&
&+&&&&&&&&&&&&&&& +
&&&&&&&&&&&&&&& +&&&&&&&&&&&&&&& +
+&&&&&&&&&&&&&&&&& +&
&+&&&&&&&&&&&&&&& +
&&& 10&&&& 1&&&& 6&&& 10&&& 10&&& 10
&&&& 3&&& 10&&&& 7&&& 10&&& 10&&& 10
&&& 10&&&& 9&&&& 2&&& 10&&& 10&&& 10
&&&& 8&&& 10&&& 10&&& 10&&& 10&&& 10
&&& 10&&&& 5&&& 10&&& 10&&& 10&&& 10
&&&& 4&&& 10&&& 10&&& 10&&& 10&&& 10
阅读(266)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_082071',
blogTitle:'引用 第二章 MATLAB 的基本数学功能',
blogAbstract:'&\r\n引用\r\n
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}}