最大最小距离算法(K-MEANS K-medoids )聚类算法的结合运用

聚类算法通常会得到一种分类，将n个点聚合成k类，同一聚类（即插槽簇）中的对象相似度较高；而不同类中的对象相似度较小。
聚类算法的基本流程如下：
（1）从n个节点中选择 k 个节点作为初始聚类中心。（2）将剩余节点根据它们与这k个聚类中心的代价大小，分别将它们分配给与其代价最小的（聚类中心所代表的）聚类。（3）更新聚类的聚类中心。不断重复（2）（3）这一过程将剩下其它节点分配完毕。（4）排序，将各聚类按照聚类间节点代价和高低降序排列。
         下面详细解释上述步骤。
（1）从n个节点中选择 k 个节点作为初始聚类中心
由于K-MEANS算法（一种典型的聚类算法，随机确定k个聚类中心）有缺点：产生类的大小相差不会很大，对于脏数据很敏感。所以采用最大最小距离算法确定这k个聚类中心。最大最小距离算法是识别领域中的一种试探性算法。思想是取尽可能离得远的对象作为聚类中心，以避免聚类中心过于邻近。
步骤如下：
1.计算各节点到其他节点的最大代价总和，取满足最大的点i（可理解为距其他节点最远）为聚类1的中心点。
2.计算其他节点到点的最大代价，取满足最大的i点为聚类2的中心点。
3. 计算其他节点到、点的最大代价，取满足最大的i点为聚类3的中心点。
4. 计算其他节点到、、点的最大代价，取满足最大的i点为聚类4的中心点。
以此类推直到找到k个聚类中心点。
 
（2）将剩余节点根据它们与这些聚类中心的代价大小，分别将它们分配给与其代价最小的（聚类中心所代表的）聚类
依次将不是聚类中心点的节点分配到k个聚类中去。若某类中已经有两个节点，则在分配进入该节点之后还要进行更新聚类中心点的操作（见后（3）详解）。
 
（3）更新聚类的聚类中心
当某个聚类中存在3个或3个以上节点时需要更新此聚类中心点。采用K-medoids算法中的更新聚类中心方式。在 K-medoids算法中，我们将从当前聚类中选取这样一个点——它到其他所有（当前聚类中）点的代价之和最小——作为中心点。
 
（4）排序，将各聚类按照聚类间代价高低降序排列。
[cpp] view plain copy
#include <stdio.h>  
#include <stdlib.h>  
#include <iostream>  
#include <math.h>  
#include "CLSlotClustering.h"  
#include "CLZone.h"  
#include "CLVMMinKCut.h"  
  
using namespace std;  
  
CLSlotClustering::CLSlotClustering()  
{  
}  
  
CLSlotClustering::~CLSlotClustering()  
{  
}  
  
int CLSlotClustering::Find(int i)  
{  
    int j;  
    if (m_Parent[i]==i)  
    {  
        return  i;  
    }  
    j=m_Parent[i];  
    Find(j);  
    return 0;  
}  
  
CLZone CLSlotClustering::SlotClustering(int C[][MAXNUMBER],int n,int k,int flag)  
{  
    m_VexOfMaxCost=0;                               //初始化  
    m_Flag=0;  
    m_Number=(-1);  
    for (int i = 0; i < MAXNUMBER; i++)  
    {  
        m_Parent[i]=i;  
        m_VexOfCostSum[i]=0;  
        for (int j = 0; j < MAXNUMBER; j++)            
        {  
            m_C[i][j]=0;  
        }  
    }  
    m_k=k;  
    m_n=n;  
    //cout<<"m_C:"<<endl;  
    for (int i = 0; i < n; i++)  
    {  
        for (int j = 0; j < n; j++)  
        {  
            m_C[i][j]=C[i][j];                      //读入代价矩阵  
            //cout<<m_C[i][j]<<"\t";  
        }  
        //cout<<"\n";  
    }  
    //Sleep(3000);  
  
    FindCenter();  
    if (!flag)  
    {  
        Clusting();  
    }  
    Sort();  
    return **m_MyZone;  
}  
int CLSlotClustering::FindCenter()              //找k个聚合类的中心点  
{  
    for (int i = 0; i < m_n; i++)  
    {  
        for (int j = 0; j < m_n; j++)  
        {  
            m_VexOfCostSum[i]+=m_C[i][j];  
        }  
        if (m_VexOfCostSum[i]>m_Flag)  
        {  
            m_VexOfMaxCost=i;  
            m_Flag=m_VexOfCostSum[i];  
        }  
    }  
    m_MyZone[0]= new CLZone;  
    m_MyZone[0]->m_Center=m_VexOfMaxCost;        //第一个中心点  
    m_MyZone[0]->m_Size=1;  
    m_MyZone[0]->m_Member[0]=m_MyZone[0]->m_Center;  
    m_Flag=0;                                 
    m_VexOfMaxCost=0;         
    for (int l = 1; l < m_k; l++)                //找其余中心点  
    {  
        for (int k = 0; k < m_n; k++)  
        {  
            if (l>1)  
            {  
                if (l==2)  
                {  
                    m_Cost[k]=m_C[m_MyZone[0]->m_Center][k];  
                }  
                m_Cost[k]=min(m_C[m_MyZone[l-1]->m_Center][k],m_Cost[k]);    //min(Dl(l-1),Dl(l-2))  
                if (m_Flag<m_Cost[k])                                        //max(min(Dl(l-1),Dl(l-2)))  
                {  
                    m_Flag=m_Cost[k];  
                    m_VexOfMaxCost=k;  
                }  
            }  
            else                                                //第二个节点，只需要maxDl1,不需要min(Dl1,Dl2)  
            {  
                if (m_Flag<m_C[m_MyZone[0]->m_Center][k])  
                {  
                    m_Flag=m_C[m_MyZone[0]->m_Center][k];  
                    m_VexOfMaxCost=k;  
                }  
            }  
        }     
        m_MyZone[l]=new CLZone;  
        m_MyZone[l]->m_Center=m_VexOfMaxCost;                    //各类中心点  
        m_MyZone[l]->m_Size=1;  
        m_MyZone[l]->m_Member[0]=m_MyZone[l]->m_Center;  
        m_Flag=0;  
    }  
    return 0;  
}  
  
int CLSlotClustering::Clusting()  
{  
      
    m_VexOfCostSum[m_n-1]=10000;                    //临时变量  
    for (int i = 0; i < m_n; i++)  
    {  
        m_Flag=10000;  
        m_Flag_IsCenter=0;  
        for (int j = 0; j < m_k; j++)      
        {  
            if (i==m_MyZone[j]->m_Member[0])     //验证是否是首个中心点，如果是则不进行聚合操作  
            {  
                m_Parent[i]=i;  
                m_Flag_IsCenter=1;  
                break;  
            }  
            if (m_Flag>m_C[i][m_MyZone[j]->m_Center]&&m_C[i][m_MyZone[j]->m_Center]!=0)        //记录i点离某个中心最近  
            {  
                m_Flag=m_C[i][m_MyZone[j]->m_Center];  
                m_Parent[i]=Find(m_MyZone[j]->m_Center);  
                m_Number=j;  
            }  
        }  
        if (m_Flag_IsCenter==0&&m_Number!=(-1))                             //将i点聚合  
        {  
            m_MyZone[m_Number]->m_Member[m_MyZone[m_Number]->m_Size]=i;  
            (m_MyZone[m_Number]->m_Size)++;  
            if (m_MyZone[m_Number]->m_Size>2)                             //当某聚合类中数量大于2时需要检验是否要改变聚合类中心  
            {  
                for (int k = 0; k < m_MyZone[m_Number]->m_Size; k++)  
                {  
                    m_VexOfCostSum[k]=0;  
                    for (int l = 0; l < m_MyZone[m_Number]->m_Size; l++)  
                    {  
                        m_VexOfCostSum[k]+=m_C[m_MyZone[m_Number]->m_Member[k]][m_MyZone[m_Number]->m_Member[l]];  
                    }  
                    if (m_VexOfCostSum[k]<m_VexOfCostSum[m_n-1])  
                    {  
                        m_VexOfCostSum[m_n-1]=m_VexOfCostSum[k];  
                        m_MyZone[m_Number]->m_Center=m_MyZone[m_Number]->m_Member[k];  
                    }  
                }  
                //cout<<"changed--m_MyZone["<<m_Number<<"]->m_Center:"<<m_MyZone[m_Number]->m_Center<<endl;  
            }  
        }  
        m_Number=(-1);  
    }  
    return 0;  
}  
  
int CLSlotClustering::Sort()  
{  
    m_Flag=0;  
    for (int i = 0; i < m_n; i++)                        //得到各点到其他聚合类的代价和  
    {  
        m_VexOfCostSum[i]=0;  
        for (int j = 0; j < m_n; j++)                      
        {  
            if (m_Parent[i]==m_Parent[j])               //若i,j为同一个集合，则查看下一个点  
            {  
                continue;  
            }  
            else  
            {  
                m_VexOfCostSum[i]+=m_C[i][j];  
            }                             
        }  
    }  
    m_MyZone[m_k]=new CLZone;  
    for (int k = 0; k < m_k; k++)                                    //得到各类到其他类的代价和  
    {  
        m_MyZone[k]->m_SumOfCost=0;  
        for (int l = 0; l < m_MyZone[k]->m_Size; l++)  
        {  
            m_MyZone[k]->m_SumOfCost+=m_VexOfCostSum[m_MyZone[k]->m_Member[l]];             
        }  
    }  
    for (int i = 0; i < m_k; i++)                                        //各聚合类降序排序  
    {  
        for (int j = i+1; j < m_k; j++)  
        {  
            if (m_MyZone[i]->m_SumOfCost<m_MyZone[j]->m_SumOfCost)  
            {  
                m_MyZone[m_k]=m_MyZone[i];  
                m_MyZone[i]=m_MyZone[j];  
                m_MyZone[j]=m_MyZone[m_k];  
            }  
        }  
    }  
    /*for (int i = 0; i < m_k; i++) 
    { 
        cout<<"m_MyZone["<<i<<"]->m_Center:"<<m_MyZone[i]->m_Center<<"\t"<<"m_MyZone["<<i<<"]->Size:"<<m_MyZone[i]->m_Size<<"\t"<<"m_MyZone["<<i<<"]->Member:\n"; 
        for (int j = 0; j < m_MyZone[i]->m_Size; j++) 
        { 
            cout<<m_MyZone[i]->m_Member[j]<<"\t"; 
        } 
        cout<<endl; 
    }*/  
    return 0;  
}