精华内容
下载资源
问答
  • 另一类题是从通过道路距离拓扑图,计算从地点A到地点B的最短距离。两种路径解题思路一致。不同指点是求最大最小数。 2 采用方法 关键路径采用标号求取关键路径 3 求取步骤 3.1 关键路径(最长路径) 根据下图...

    1 概述

    在软考中,有两类关于路径的问题。第一类为通过项目网络图(一般为单代号网络图或者是双代号网络图)求取关键路径,也就是求出从起始点到终点的最远距离。另一类题是从通过道路距离拓扑图,计算从地点A到地点B的最短距离。两种路径解题思路一致。不同指点是求最大和最小数。

    2 采用方法

    关键路径采用标号法求取关键路径

    3 求取步骤

    3.1 关键路径(最长路径)

    根据下图,求出项目关键路径,并计算历时时间。

    1)从圈1开始,在圈1上标0。

    2)根据上图,我们分析,圈2和圈4的紧前事件为圈1和圈3,圈3的紧前事件仅为圈1,所以我们可以确认圈3的时间,为6。

    3)目前圈2和圈4的紧前事件都已经确认,找出紧前事件最大的数值,圈2的紧前事件分别为圈1和圈3,圈1到圈2位0+3=3,圈3到圈2位6,所以圈2为6,同理,圈4为6.

    4)接下来我们找圈5.圈5的紧前事件为圈2和圈3,圈2到圈5的距离为6+4=10;圈3到圈5距离为6+5=11,所以取最大11。

    5)圈6和圈7只有一个紧前事件,所以圈6为6+2=8,圈7为 6+5=11。

    6)圈8有三个紧前事件,从圈5到圈8为11+3=14,圈6到圈8为8+3=11,圈7到圈8为11+3=14,所以圈8取最大14.

    7)所以关键路径为DEC和HIJ,历时天数为14天。

    3.2 最短路径

    和最长路径思路一致,区别在于如果一个事件出现多个紧前事件,则取最短的那个即可。

    展开全文
  • 下面给出五个元素两两之间的距离,试利用最短距离法最长距离法和类平均法做出五个元素的谱系聚类,画谱系图并做出比较。 如何将其数据导入R中如图所示 其表面R语言中dist()函数与as.dist()函数区别不一,...

    R语言中dist()函数与as.dist()函数

    下面给出五个元素两两之间的距离,试利用最短距离法、最长距离法和类平均法做出五个元素的谱系聚类,画谱系图并做出比较。
    在这里插入图片描述

    如何将其数据导入R中如图所示

    在这里插入图片描述
    其表面R语言中dist()函数与as.dist()函数区别不一,dist()函数是默认使用最长距离法计算数据之间的距离,而as.dist()函数笔者经查询,没有具体资料显示,由图中代码显示可得出点与点之间的距离。

    展开全文
  • 2. 字符串编辑距离 3. 格子取数问题 4. 交替字符串 5. 最长递增子序列 本章导读 学习一个算法,可分为3个步骤:首先了解算法本身解决什么问题,然后学习它的解决策略,最后了解某些相似算法之间的联系。例如图算法...

    第五章 动态规划

    小结:
    不太会动态规划
    1.最大连续乘积子串
    2. 字符串编辑距离
    3. 格子取数问题
    4. 交替字符串
    5. 最长递增子序列


    本章导读

    学习一个算法,可分为3个步骤:首先了解算法本身解决什么问题,然后学习它的解决策略,最后了解某些相似算法之间的联系。例如图算法中,

    • 广搜是一层一层往外遍历,寻找最短路径,其策略是采取队列的方法。
    • 最小生成树是最小代价连接所有点,其策略是贪心,比如Prim的策略是贪心+权重队列。
    • Dijkstra是寻找单源最短路径,其策略是贪心+非负权重队列。
    • Floyd是多结点对的最短路径,其策略是动态规划。

    而贪心和动态规划是有联系的,贪心是“最优子结构+局部最优”,动态规划是“最优独立重叠子结构+全局最优”。一句话理解动态规划,则是枚举所有状态,然后剪枝,寻找最优状态,同时将每一次求解子问题的结果保存在一张“表格”中,以后再遇到重叠的子问题,从表格中保存的状态中查找(俗称记忆化搜索)。

    1. 最大连续乘积子串

    题目描述

    给一个浮点数序列,取最大乘积连续子串的值,例如 -2.5,4,0,3,0.5,8,-1,则取出的最大乘积连续子串为3,0.5,8。也就是说,上述数组中,3 0.5 8这3个数的乘积30.58=12是最大的,而且是连续的。

    分析与解法

    此最大乘积连续子串与最大乘积子序列不同,请勿混淆,前者子串要求连续,后者子序列(LCS)不要求连续。LCS可以使用动态规划解决

    解法一:暴力

    两重for循环,时间复杂度O(n^2)

    解法二:动态规划

    考虑到乘积子序列中有正有负也还可能有0,我们可以把问题简化成这样:数组中找一个子序列,使得它的乘积最大;同时找一个子序列,使得它的乘积最小(负数的情况)。

    假设数组为a[],直接利用动态规划来求解,考虑到可能存在负数的情况,我们用maxend来表示以a[i]结尾的最大连续子串的乘积值,用minend表示以a[i]结尾的最小的子串的乘积值,那么状态转移方程为:

     maxend = max(max(maxend * a[i], minend * a[i]), a[i]);
     minend = min(min(maxend * a[i], minend * a[i]), a[i]);
     初始状态为maxend = minend = a[0]。  
    

    参考代码如下:

    double MaxProductSubstring(double *a, int length)
    {
    	double maxEnd = a[0];
    	double minEnd = a[0];
    	double maxResult = a[0];
    	for (int i = 1; i < length; ++i)
    	{
    		double end1 = maxEnd * a[i], end2 = minEnd * a[i];
    		maxEnd = max(max(end1, end2), a[i]);
    		minEnd = min(min(end1, end2), a[i]);
    		maxResult = max(maxResult, maxEnd);
    	}
    	return maxResult;
    }
    

    动态规划求解的方法一个for循环搞定,所以时间复杂度为O(n)。

    2. 字符串编辑距离

    题目描述

    给定一个源串和目标串,能够对源串进行如下操作:

    1. 在给定位置上插入一个字符
    2. 替换任意字符
    3. 删除任意字符
      写一个程序,返回最小操作数,使得对源串进行这些操作后等于目标串,源串和目标串的长度都小于2000。

    分析与解法

    此问题的常见思路是动态规划,假如令dp[i][j]表示原串S[0…i]和目标串T[0…j]的最短编辑距离,其边界:dp[0][j] = j, dp[i][0] = i,那么我们可以得出状态转移方程:

    • dp[i][j] = min{
      • dp[i-1][j]+1, S[i]不在T[0…j]中
      • dp[i-1][j-1] +1/0, S[i]在T[j]
      • dp[i][j-1] + 1, S[i]在T[0…j-1]中
        }

    接下来,我们重点解释一下上述3个式子的含义

    • 关于dp[i-1][j] + 1, s.t. s[i]不在T[0…j]中的说明
      • S[i]没有落在T[0…j]中,即S[i]在中间的某次编辑操作中被删除。因为删除操作没有前后相关性,不妨将其在第一次操作中删除,除首次操作时删除外,后续编辑操作是将长度的i - 1的字符串编辑成长度为j的字符串:即dp[i - 1][j]
      • 因此,dp[i][j] = dp[i-1][j] + 1
    • 关于dp[i - 1][j - 1] + 0/1, s.t. s[i] 在T[j]的说明
      • 若s[i]经过编辑,最终落在T[j]的位置。
      • 则要么s[i] == t[j], s[i]直接落在T[j]:即dp[i-1][j-1];
      • 则要么s[i] != t[j],s[i]落在T[j]后,要将s[i]修改成T[j],增加一次修改操作:即dp[i-1][j-1]+1
    • 关于dp[i][j-1] + 1, s.t. s[i]在T[0…j-1]中的说明
      • 若若s[i]落在了T[1…j-1]的某个位置,不妨认为是k,因为最小编辑步数的定义,那么,在k+1到j-1的字符,必然是通过插入新字符完成的。因为共插入了(j-k)个字符,故编辑次数为(j-k)次。而字符串S[1…i]经过编辑,得到了T[1…k],编辑次数为dp[i][k]。故: dp[i][j] = dp[i][k] + (j-k)。
      • 由于最后的(j-k)次是插入操作,可以讲(j-k)逐次规约到dp[i][k]中。即:dp[i][k]+(j-k)=dp[i][k+1] + (j-k-1) 规约到插入操作为1次,得到 dp[i][k]+(j-k) =dp[i][k+1] + (j-k-1) =dp[i][k+2] + (j-k-2)=… =dp[i][k+(j-k-1)] + (j-k)-(j-k-1) =dp[i][j-1] + 1。

    换一个角度,其实就是字符串对齐的思路。例如把字符串“ALGORITHM”,变成“ALTRUISTIC”,那么把相关字符各自对齐后,如下图所示:
    在这里插入图片描述
    把图中上面的源串S[0…i] = “ALGORITHM”编辑成下面的目标串T[0…j] = “ALTRUISTIC”,我们枚举字符串S和T最后一个字符s[i]、t[j]对应四种情况:(字符-空白)(空白-字符)(字符-字符)(空白-空白)。
    由于(空白-空白)是多余的编辑操作。所以,事实上只存在以下3种情况:

    • 下面的目标串空白,即S + 字符X,T + 空白,S变成T,意味着源串要删字符
      • dp[i - 1, j] + 1
    • 上面的源串空白,S + 空白,T + 字符,S变成T,最后,在S的最后插入“字符”,意味着源串要添加字符
      • dp[i, j - 1] + 1
    • 上面源串中的的字符跟下面目标串中的字符不一样,即S + 字符X,T + 字符Y,S变成T,意味着源串要修改字符
      • dp[i - 1, j - 1] + (s[i] == t[j] ? 0 : 1)
    //dp[i,j]表示表示源串S[0…i] 和目标串T[0…j] 的最短编辑距离
    dp[i, j] = min { dp[i - 1, j] + 1,  dp[i, j - 1] + 1,  dp[i - 1, j - 1] + (s[i] == t[j] ? 0 : 1) }
    //分别表示:删除1个,添加1个,替换1个(相同就不用替换)。
    

    3. 格子取数问题???

    题目描述
    有n*n个格子,每个格子里有正数或者0,从最左上角往最右下角走,只能向下和向右,一共走两次(即从左上角走到右下角走两趟),把所有经过的格子的数加起来,求最大值SUM,且两次如果经过同一个格子,则最后总和SUM中该格子的计数只加一次。
    在这里插入图片描述

    分析与解法

    因为要让两次走下来的路径总和最大,读者可能最初想到的思路可能是让每一次的路径都是最优的,即不顾全局,只看局部,让第一次和第二次的路径都是最优。
    在这里插入图片描述
    也就是说,上面图二中的走法太追求每一次最优,所以第一次最优,导致第二次将是很差;而图三第一次虽然不是最优,但保证了第二次不差,所以图三的结果优于图二。由此可知不要只顾局部而贪图一时最优,而丧失了全局最优。

    为了方便讨论,我们先对矩阵做一个编号,且以5*5的矩阵为例(给这个矩阵起个名字叫M1):
    M1

    0 1 2 3 4

    1 2 3 4 5

    2 3 4 5 6

    3 4 5 6 7

    4 5 6 7 8
    从左上(0)走到右下(8)共需要走8步(2*5-2)。我们设所走的步数为s。因为限定了只能向右和向下走,因此无论如何走,经过8步后(s = 8)都将走到右下。而DP的状态也是依据所走的步数来记录的。

    再来分析一下经过其他s步后所处的位置,根据上面的讨论,可以知道:

    • 经过8步后,一定处于右下角(8);
    • 那么经过5步后(s = 5),肯定会处于编号为5的位置;
    • 3步后肯定处于编号为3的位置;
    • s = 4的时候,处于编号为4的位置,此时对于方格中,共有5(相当于n)个不同的位置,也是所有编号中最多的。

    故推广来说,对于n*n的方格,总共需要走2n - 2步,且当s = n - 1时,编号为n个,也是编号数最多的。

    如果用DP[s,i,j]来记录2次所走的状态获得的最大值,其中s表示走s步,i和j分别表示在s步后第1趟走的位置和第2趟走的位置。

    为了方便描述,再对矩阵做一个编号(给这个矩阵起个名字叫M2):
    M2

    0 0 0 0 0

    1 1 1 1 1

    2 2 2 2 2

    3 3 3 3 3

    4 4 4 4 4

    我们先看M1,在经过6步后,肯定处于M1中编号为6的位置。而M1中共有3个编号为6的,它们分别对应M2中的2 3 4。故对于M2来说,假设第1次经过6步走到了M2中的2,第2次经过6步走到了M2中的4,DP[s,i,j] 则对应 DP[6,2,4]。由于s = 2n - 2,0 <= i <= j <= n,所以这个DP共有O(n^3)个状态。

    再来分析一下状态转移,以DP[6,2,3]为例,可以到达DP[6,2,3]的状态包括DP[5,1,2],DP[5,1,3],DP[5,2,2],DP[5,2,3]

    下面,我们就来看看这几个状态:DP[5,1,2],DP[5,1,3],DP[5,2,2],DP[5,2,3],用加粗表示位置DP[5,1,2] DP[5,1,3] DP[5,2,2] DP[5,2,3] (加红表示要达到的状态DP[6,2,3])

    0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4

    1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5

    2 3 4 5 6 2 3 4 5 6 2 3 4 5 6 2 3 4 5 6

    3 4 5 6 7 3 4 5 6 7 3 4 5 6 7 3 4 5 6 7

    4 5 6 7 8 4 5 6 7 8 4 5 6 7 8 4 5 6 7 8

    因此:
    DP[6,2,3] = Max(DP[5,1,2] ,DP[5,1,3],DP[5,2,2],DP[5,2,3]) + 6,2和6,3格子中对应的数值 (式一)
    上面(式一)所示的这个递推看起来没有涉及:“如果两次经过同一个格子,那么该数只加一次的这个条件”,讨论这个条件需要换一个例子,以DP[6,2,2]为例:DP[6,2,2]可以由DP[5,1,1],DP[5,1,2],DP[5,2,2]到达,但由于i = j,也就是2次走到同一个格子,那么数值只能加1次。 所以当i = j时,
    DP[6,2,2] = Max(DP[5,1,1],DP[5,1,2],DP[5,2,2]) + 6,2格子中对应的数值

    故,综合上述的(式一),(式二)最后的递推式就是

    f(i != j) DP[s, i ,j] = Max(DP[s - 1, i - 1, j - 1], DP[s - 1, i - 1, j], DP[s - 1, i, j - 1], DP[s - 1, i, j]) + W[s,i] + W[s,j] else DP[s, i ,j] = Max(DP[s - 1, i - 1, j - 1], DP[s - 1, i - 1, j], DP[s - 1, i, j]) + W[s,i] 
    

    其中W[s,i]表示经过s步后,处于i位置,位置i对应的方格中的数字。下一节我们将根据上述DP方程编码实现。

    //copyright@caopengcs 2013
    const int N = 202;
    const int inf = 1000000000;  //无穷大
    int dp[N * 2][N][N];
    bool IsValid(int step, int x1, int x2, int n) //判断状态是否合法
    {
        int y1 = step - x1, y2 = step - x2;
        return ((x1 >= 0) && (x1 < n) && (x2 >= 0) && (x2 < n) && (y1 >= 0) && (y1 < n) && (y2 >= 0) && (y2 < n));
    }
    
    int GetValue(int step, int x1, int x2, int n)  //处理越界 不存在的位置 给负无穷的值
    {
        return IsValid(step, x1, x2, n) ? dp[step][x1][x2] : (-inf);
    }
    
    //状态表示dp[step][i][j] 并且i <= j, 第step步  两个人分别在第i行和第j行的最大得分 时间复杂度O(n^3) 空间复杂度O(n^3)
    int MinPathSum(int a[N][N], int n)
    {
        int P = n * 2 - 2; //最终的步数
        int i, j, step;
    
        //不能到达的位置 设置为负无穷大
        for (i = 0; i < n; ++i)
        {
            for (j = i; j < n; ++j)
            {
                dp[0][i][j] = -inf;
            }
        }
        dp[0][0][0] = a[0][0];
    
        for (step = 1; step <= P; ++step)
        {
            for (i = 0; i < n; ++i)
            {
                for (j = i; j < n; ++j)
                {
                    dp[step][i][j] = -inf;
                    if (!IsValid(step, i, j, n))   //非法位置
                    {
                        continue;
                    }
                    //对于合法的位置进行dp
                    if (i != j)
                    {
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i - 1, j - 1, n));
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i - 1, j, n));
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i, j - 1, n));
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i, j, n));
                        dp[step][i][j] += a[i][step - i] + a[j][step - j];  //不在同一个格子,加两个数
                    }
                    else
                    {
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i - 1, j - 1, n));
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i - 1, j,  n));
                        dp[step][i][j] = max(dp[step][i][j], GetValue(step - 1, i, j,  n));
                        dp[step][i][j] += a[i][step - i]; // 在同一个格子里,只能加一次
                    }
                }
            }
        }
        return dp[P][n - 1][n - 1];
    }
    

    复杂度分析:状态转移最多需要统计4个变量的情况,看做是O(1)的,共有O(n3)个状态,所以总的时间复杂度是O(n3)的,且dp数组开了N3大小,故其空间复杂度亦为O(n3)。

    事实上,空间上可以利用滚动数组优化,由于每一步的递推只跟上1步的情况有关,因此可以循环利用数组,将空间复杂度降为O(n^2)。

    即我们在推算dp[step]的时候,只依靠它上一次的状态dp[step - 1],所以dp数组的第一维,我们只开到2就可以了。即step为奇数时,我们用dp[1][i][j]表示状态,step为偶数我们用dp[0][i][j]表示状态,这样我们只需要O(n^2)的空间,这就是滚动数组的方法。滚动数组写起来并不复杂,只需要对上面的代码稍作修改即可,感兴趣的读者可以自己写代码实现下。

    4. 交替字符串

    题目描述
    输入三个字符串s1、s2和s3,判断第三个字符串s3是否由前两个字符串s1和s2交错而成,即不改变s1和s2中各个字符原有的相对顺序,例如当s1 = “aabcc”,s2 = “dbbca”,s3 = “aadbbcbcac”时,则输出true,但如果s3=“accabdbbca”,则输出false。

    分析与解法

    此题不能简单的排序,因为一旦排序,便改变了s1或s2中各个字符原始的相对顺序,既然不能排序,咱们可以考虑下用动态规划的方法,令dp[i][j]代表s3[0…i+j-1]是否由s1[0…i-1]和s2[0…j-1]的字符组成

    • 如果s1当前字符(即s1[i-1])等于s3当前字符(即s3[i+j-1]),而且dp[i-1][j]为真,那么可以取s1当前字符而忽略s2的情况,dp[i][j]返回真;
    • 如果s2当前字符等于s3当前字符,并且dp[i][j-1]为真,那么可以取s2而忽略s1的情况,dp[i][j]返回真,其它情况,dp[i][j]返回假
    public boolean IsInterleave(String s1, String s2, String s3){
    	int n = s1.length(), m = s2.length(), s = s3.length();
    
    	//如果长度不一致,则s3不可能由s1和s2交错组成
    	if (n + m != s)
    		return false;
    
    	boolean[][]dp = new boolean[n + 1][m + 1];
    
    	//在初始化边界时,我们认为空串可以由空串组成,因此dp[0][0]赋值为true。
    	dp[0][0] = true;
    
    	for (int i = 0; i < n + 1; i++){
    		for (int j = 0; j < m + 1; j++){
    			if ( dp[i][j] || (i - 1 >= 0 && dp[i - 1][j] == true &&
    				//取s1字符
    				s1.charAT(i - 1) == s3.charAT(i + j - 1)) ||
    
    				(j - 1 >= 0 && dp[i][j - 1] == true &&
    				//取s2字符
    				s2.charAT(j - 1) == s3.charAT(i + j - 1)) )
    
    				dp[i][j] = true;
    			else
    				dp[i][j] = false;
    		}
    	}
    	return dp[n][m]
    }
    

    5. 最长递增子序列

    题目描述
    给定一个长度为N的数组a0,a1,a2…,an-1,找出一个最长的单调递增子序列(注:递增的意思是对于任意的i<j,都满足ai<aj,此外子序列的意思是不要求连续,顺序不乱即可)。例如:给定一个长度为6的数组A{5, 6, 7, 1, 2, 8},则其最长的单调递增子序列为{5,6,7,8},长度为4。

    分析与解法

    解法一:转换为最长公共子序列问题

    比如原数组为
    A{5, 6, 7, 1, 2, 8},
    当我们对这个数组进行排序后,排序后的数组为:
    A‘{1, 2, 5, 6, 7, 8}。

    然后想求数组A的最长递增子序列,其实就是求数组A与它的排序数组A‘的最长公共子序列,原因是原数组A的子序列顺序保持不变,而且排序后A‘本身就是递增的,这样,就保证了两序列的最长公共子序列的递增特性。

    如此,若想求数组A的最长递增子序列,其实就是求数组A与它的排序数组A‘的最长公共子序列。

    解法二:动态规划

    定义dp[i]为以ai为末尾的最长递增子序列的长度,故以ai结尾的递增子序列

    • 要么是只包含ai的子序列
    • 要么是在满足j<i并且aj<ai的以ai为结尾的递增子序列末尾,追加上ai后得到的子序列
    int n;
    int a[n];
    
    int dp[n];
    
    void lis()
    {
    	int res = 0;
    	int i;
    	for (i = 0; i < n; i++)
    	{
    		dp[i] = (dp[i] > dp[i + 1] )? dp[i]:dp[i + 1];
    	}
    	res = (res > dp[i])?res:dp[i];
    	printf("%d\n,res");
    }
    
    展开全文
  • 凝聚分层聚类中有一堆方法可以用来算两点(pair)之间的距离:欧式,欧式平方...(即最短最长平均,离差平方)   其他的好像都挺好理解,就是最后这个有点麻烦。。。   这个方法说白了叫离差平方...

     

    凝聚法分层聚类中有一堆方法可以用来算两点(pair)之间的距离:欧式,欧式平方,manhattan等,还有一堆方法可以算类(cluster)与类之间的距离,什么single-linkage、complete-linkage、还有这个ward linkage。(即最短最长平均,离差平方和)

     

    其他的好像都挺好理解,就是最后这个有点麻烦。。。

     

    这个方法说白了叫离差平方和(这是个啥?)。是ward写那篇文章时候举的一个特例。这篇文章是说分层凝聚聚类方法的一个通用流程。在选择合并类与类时基于一个object function optimise value,这个object function可以是任何反应研究目的的方程,所以许多标准的方法也被归入了。为了阐明这个过程,ward举了一个例子,用的object function 是error sum of squares(ESS),这个例子就成为ward's method。

     

    找了N多资料,终于把这个算法的过程搞清楚了。首先输入的是一个距离矩阵,知道每两个点之间的距离。然后初始化是每个点做为一个cluster,假设总共N组,此时每个组内的ESS都是0,ESS的公式,如下(从原稿《Hierarchical Grouping To Optimize An Objective Function》上摘的):

    我当时还有点蒙ESS是个啥?——我现在知道了,凡是蒙的都是概率没学好(我是说我)……先从wiki上转个公式过来:

    这是方差的公式,写的再通俗点,就是:

    等号两边同时乘上n,好了,你应该知道ESS是啥了——ESS就是【方差×n】!so easy了~~

     

     

    但是等下——这看起来是个一维的公式啊——因为你已经知道ESS是【方差×n】了,那多维的还不会算吗?先求所有点的均值点,然后再算所有点到这个均值点(central)的距离(距离公式你得自己定,见开头,但是最后算出来就是一个数),然后把所有距离平方后加起来(此时即为方差乘上n),就得到ESS了。

     

    说了半天光说ESS了,列位看官,人只有一张嘴,故ESS此处按下不表,接着说ward method。ward method是要求每次合并后ESS的增量最小,这怎么讲呢?还是上图吧(图是从youtube上的一个教程里截的):

    只看最下面ward's method的两个图好了,先看下面的图,合并前红色组和黄色组分别能算各自的ESS,总的ESS是什么呢?很简单,加起来就好了,即:

    ESS(总-合并前)=ESS(红)+ESS(黄)+ESS(其他没画出来的组)

    如果合并这两个组,则可以作为一个新组再算一个ESS,此时

    ESS(总-合并后)=ESS(红黄)+ESS(其他没画出来的组)

    你注意这里还没有真的合并,只是算了一下合并红黄两组的“成本”(即:ESS(总-合并后)-ESS(总-合并前),当然这个成本肯定是增加的),如果总共有N个组,必须把每两个组合并的成本都算一遍,也就是算N×(N-1)/2个数出来,然后找里面合并后成本最小的两组合并。然后再重复这个过程。

    我说清楚了吧!?

     

    嗯,至于画的那个树状图的高度,可以认为是上面说的这个“成本”。

     

    对了,还得说一下这个公式:

    啥意思呢,就是说,如果用ward's method来度量两个cluster之间的距离,那么两个cluster之间的距离就是把这两个cluster合并后新cluster的ESS,其中x就表示合并前两个cluster中所有点,而就是合并后那个新cluster的中心点(均值点),就表示每个点x到中心点的距离,平方后加起来,就是ESS了。

     

    好了,总结一下,ward's method是凝聚法分层聚类中一种度量cluster之间距离的方法。按照这个方法,任意两个cluster之间的距离就是这两个cluster合并后新cluster的ESS

     

    摘要: ward linkage method是什么不介绍了,只说下怎么算,有一个快速的计算方法叫Lance-Williams Algorithm可以大大简化ward method的计算

    ward's method是分层聚类凝聚法的一种常见的度量cluster之间距离的方法,其基本过程是这样的(参考:http://blog.sciencenet.cn/blog-2827057-921772.html )

    1. 计算每个cluster的ESS
    2. 计算总的ESS
    3. 枚举所有二项cluster【N个cluster是N*(N-1)/2个二项集】,计算合并这两个cluster后的总ESS值
    4. 选择总ESS值增长最小的那两个cluster合并
    5. 重复以上过程直到N减少到1

    这个方法其实效率比较低,特别是算cluster的ESS值还要先求均值点,然后算距离的平方再求和,不过有一个快速的计算方法叫Lance-Williams Algorithm可以大大简化ward method的计算。先来一个图(来源:https://www.youtube.com/watch?v=aXsaFNVzzfI

    输入图片说明

    然后你其实可以发现,这个算法简化的是合并后更新ESS的那部分过程,比如有ABCDE五个cluster,合并了AB,那么后面要更新CDE到这个AB的距离,怎么算?ESS呗——平方和——好复杂!

    那用这个新算法怎么算?答,新算法可以不用ESS的公式计算ESS,直接套用上面那个公式(注意最后绝对值里面应该一个i一个j,他写错了)。初始的ESS由两点之间的距离决定——所以就是说完全不需要算ESS了!

    好了,试着写一下算法:输入是一个距离矩阵,输出是一个合并序列[(cluster1id, cluster2id, distance), ...]

    clusterDistance=dict() #存放cluster之间的距离,形如'1-2':3表示cluster1与cluster2之间的距离为3
    clusterMap=dict()  #存放cluster的情况,形如'1':4表示cluster1里面有4个元素(样本)
    clusterCount=0  #每合并一次生成新的序号来命名cluster
    
    def ward_linkage_method(distance_matrix):
        N=len(distance_matrix)
        clusterCount=N-1
        for i in range(0,N-1):
            for j in range(i,N):
                name=getName(i,j)
                clusterDistance[name]=distance_matrix[i][j]
        for k in range(0,N):
            clusterMap[k]=1
        while True:
            # 查找距离最短的两个cluster
            # clusterDistance里面有冗余(即合并后之前的距离仍在,
            # 所以循环以clusterMap为准,这个里面没有冗余。
            tmp=max(clusterDistance.values())
            clusterList = clusterMap.keys()
            clusterListLength=len(clusterList)
            for iii in range(0, clusterListLength-1):
                for jjj in range(iii+1, clusterListLength):
                    name=getName(clusterList[iii], clusterList[jjj])
                    if tmp > clusterDistance[name]:
                        i=iii
                        j=jjj
                        tmp=clusterDistance[name]
            ni=clusterMap[i]  # 第i个cluster内的元素数
            nj=clusterMap[j]
            del clusterMap[i] # 删掉原来的cluster
            del clusterMap[j]
            clusterCount+=1     # 新增新的cluster
            clusterMap[clusterCount]=ni+nj #新cluster的元素数是之前的总和
    
            print i,j,'->',clusterCount,tmp # 输出合并信息:i,j合并为clusterCount,合并高度(距离)为tmp
    
            if len(clusterMap)==1:break # 合并到只剩一个集合为止,然后退出
    
            # 更新没合并的cluster到新合并后的cluster的距离
            for k in clusterMap.keys():
                if k==clusterCount:continue
                else:  # 计算新的距离
                    nk=clusterMap[k]
                    alpha_i=(ni+nk)/(ni+nj+nk)
                    alpha_j=(nj+nk)/(ni+nj+nk)
                    beta= -nk/(ni+nj+nk)
                    newDistance =  alpha_i * clusterDistance[getName(i,k)]
                    newDistance += alpha_j * clusterDistance[getName(j,k)]
                    newDistance += beta * clusterDistance[getName(i,j)]
                    # 把新的距离加入距离集合
                    clusterDistance[getName(clusterCount,k,'.')]=newDistance
    
    def getName(i,j):
        t=[i,j]
        t.sort()
        return t[0]+'-'+t[1]
    

    当然了,这段代码只是一个示意,可以改进的地方还很多。



    转载本文请联系原作者获取授权,同时请注明本文来自宋景和科学网博客。
    链接地址:http://blog.sciencenet.cn/blog-2827057-921772.html 
    展开全文
  • 其中类与类 的距离的计算方法有:最短距离法,最长距离法,中间距离法,类平均法等。比如最短距离法,将类与类 的距离定义为类与类之间样本的最短距离。 层次聚类算法根据层次分解的顺序分为:自下底向上自上向下...
  • 7.2聚类分析05.mp4

    2020-07-26 10:35:09
    基于王斌会《多元统计分析及R语言建模》第7章第2节聚类分析。主要介绍聚类分析的系统聚类法(层次聚类法)中的最短距离法最长距离法和ward法的比较,以及基于中心化和标准化数据的相关算例。
  • 需要强调的是,我这个代码并不是...目标:组委会计划移走一些岩石,使得选手们的最短跳跃距离最长,至多移走M块岩石 输入要求:三个整数:起点到终点的距离L,起点终点之间的岩石数N,移走的岩石数M,L>=1, N&g.
  • 题目链接: URAL 1990 Podracing 题意: 左边有一条折线,右边有一条折线,两条折线的起点终点的纵坐标相同,保证两条折线不相交,还有一些...先计算从左折线所有顶点到右折线的最短距离, 再计算从右折线所有
  • 我们将一棵树T = ( V,E )的直径定义为maxδ ( u,v ) ( u,v ∈ V ),也就是说,树中所有最短路径距离的最大值即为树的直径。 对于这类问题,我们主要有两种求解方法。 我们拿一个题目当例子: 题目链接 题意:若是...
  • 验证了聚类分析用于卫星雷达测高波形分类的可行性。...以Topex/Poseidon卫星的近岸波形为例,比较了最短距离法最长距离法、类平均法和最小方差法等4种聚类方法的聚类效果,结果表明最小方差法效果最优。
  • 聚类实战:一个聚类实例及解答 ...2. 采用层次聚类(讨论采用欧式距离,分别用最短距离法最长距离法、类平均法、中间距离法、重心法和ward法得出的聚类图,哪个是最优的)。 实验结果 请阅读 程序参考 已经上传Github
  • 1)下面给出5个元素两两之间的距离,利用最短距离法最长距离法和类平均法做出5个元素的谱系聚类,画谱系图并做出比较。 x1 <- c(0,4,6,1,6) x2 <- c(4,0,9,7,3) x3 <- c(6,9,0,10,5) x4 <- c(1,7,10,0...
  • 模式识别笔记(1)

    2016-11-13 18:42:39
    模式识别笔记(1) 一、聚类-相似性(近邻准则)[1] 1.近邻准则一般有两种计算方法: ①与样本库中所有样品特征分别做相似性测度 ②与样本库中不同类别...②最长距离法:是两个类别中的元素间最长的距离作为类间距离
  • 3 2 编辑距离(列文斯登距离45 3 3 最长公共子序列 47 3 4 升序最长子序列 49 3 5 两位玩家游戏中的必胜策略 52 第 4 章 数组 53 4 1 合并已排序列表 53 4 2 区间的总和 54 4 3 区间内的重复内容 54 4 4 区间的最大...
  • 2、方式:最短最长距离法、重心法、类平均法、离差平方法等 二、K-means聚类 流程:把样品粗略分为K个初始类——循环(计算距离[欧式距离,每个类的均值]、进行修改,逐个分派样品到其最近
  • 算法总结

    2012-09-10 10:52:37
    1、背包问题(01背包、完全背包、多重背包) 2、最小生成树(kruskal算法) 3、快速质数生成办法 4、最短距离和最长距离(dijkstra算法) 5、bfs遍历求
  • 2.层次聚类 概念:通过计算不同类别数据点间的相似度来创建一个有层次有嵌套的聚类树 特点:不需要指定具体的...簇与簇之间的距离计算方法有:最短距离法Single Linkage(距离为簇与簇之间样本的最短距离)、最长距离法
  • 找所有字母异位词、最长无重复子串、最小覆盖子串、最小覆盖字串1、子串检测、字符串预处理、序列匹配 测试案例 序列字符串 人民币大小写转换、最小循环的字符串、IP地址转化 测试案例 字符串...
  • 1.1.2 乘法 1.2 模运算 1.2.1 模的加法乘法 1.2.2 模的指数运算 1.2.3 Euclid的最大公因数算法 1.2.4 Euclid算法的一种扩展 1.2.5 模的除 1.3 素性测试 1.4 密码学 1.4.1 密钥机制:一次一密乱码本AES...
  • 动态规划 ppt演示

    热门讨论 2008-09-30 13:06:29
    最长公共子序列问题时最容易想到的算法是穷举搜索,即对X的每一个子序列,检查它是否也是Y的子序列,从而确定它是否为XY的公共子序列,并且在检查过程中选出最长的公共子序列。X的所有子序列都检查过后即可求...
  • 13.5 回溯法和分枝限界法 13.5.1 回溯法 13.5.2 分枝限界法 13.6 习题 基础题 创新题 程序设计 13.7 本章注记 第14章 算法框架 14.1 外存算法 14.1.1 分层的存储器管理 14.1.2 (a, 树和B树 14.1.3 外存排序 14.2 ...
  •  第3章结构之——字符串及链表的探索 219  3.1字符串移位包含的问题 221  3.2电话号码对应英语单词 224  3.3计算字符串的相似度 230  3.4从无头单链表中删除节点 234  3.5最短摘要的生成 237  3.6编程判断...
  • 9.点到线段最短距离 10.求两直线的交点 11.判断一个封闭图形是凹集还是凸集 12.Graham扫描寻找凸包 数论: 1.x的二进制长度 2.返回x的二进制表示中从低到高的第i位 3.模取幂运算 4.求解模线性方程 5....
  • ACM算法模版大集合

    2009-10-15 23:18:39
    极小极大距离 / 极大极小距离 Euler Path / Tour 圈套圈算法 混合图的 Euler Path / Tour Hamilton Path / Tour 特殊图的Hamilton Path / Tour 构造 生成树问题 最小生成树 第k小生成树 最优比率生成树 ...
  • 6.4 寻找最短全1位串 115 6.5 习题 115 第7章 重排位元与字节 117 7.1 反转位元与字节 117 7.1.1 位元反转算法的推广 122 7.1.2 奇特的位元反转算法 122 7.1.3 递增反转后的整数 124 7.2 乱序排列位元 126 ...
  • 编程之美.rar

    2019-06-03 11:45:05
    3.5 最短摘要的生成 3.6 编程判断两个链表是否相交 3.7 队列中取最大值操作问题 3.8 求二叉树中节点的最大距离 3.9 重建二叉树 3.10 分层遍历二叉树 3.11 程序改错 第4章 数学之趣——数学游戏的乐趣 4.1 金刚坐飞机...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

最长距离法和最短距离法