class Solution:
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        #采用动态规划的方法
        DPMa = [[0 for i in range(len(s))] for j in range(len(s))]  #初始化二维矩阵，用户动态规划预计算

        LenPa = 1
        iMax = jMax = 0
        for i in range(len(s)):
            DPMa[i][i] = 1
            if i + 1 < len(s) and s[i] == s[i + 1]:#出现相同两位的回文字符串
                DPMa[i][i + 1] = 1
                LenPa = 2
                iMax = i
                jMax = i + 1
        for k in range(2, len(s)):
            for i in range(0, len(s) - k):
                j = i + k
                if DPMa[i + 1][j - 1] and s[i] == s[j]:
                    DPMa[i][j] = 1
                    if k + 1 > LenPa:
                        LenPa = k + 1
                        iMax = i
                        jMax = j

        return s[iMax:jMax + 1]

class Solution:
    def longestPalindrome(self, s):
        s = Solution.PreProcess(s)  #预处理
        P = [0] * (len(s))  #p数组，保存回文长度
        C = 0   #中心点位置，初始化为0
        R = 0   #右边界位置，初始化为0
        for i in range(1, len(s) - 1):
            iMirror = 2*C - i
            if iMirror < 0:
                iMirror = 0
            # 计算在当前以C为中心的的最大对称位置
            P[i] = min(R - i, P[iMirror]) if R > i else 0
            # 对边界进行扩展，利用循环对边界进行扩展
            while (s[i - 1 - P[i]] == s[i + 1 + P[i]]):
                P[i] += 1
            # 计算新的C和R的位置
            if (i + P[i] > R):
                R = i + P[i]
                C = i

        MaxLen = max(P)
        index = P.index(MaxLen)
        return s[index - MaxLen: index + MaxLen + 1].replace('#', '')


    def PreProcess(s):
       """
       预处理过程，在字符串收尾插入^$ ，在字符串间插入#
       :param s: 待处理字符串
       :return: 处理完成的字符串
       """
       sList = list('^' + s + '$')
       return '#'.join(sList)

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
from sklearn.externals import joblib

class LDATrain:
    def __init__(self, DocLst, NumTopics, MaxIter, MaxFeatures):
        """初始化，DocLst为输入的训练或测试文档"""
        self.DocLst = DocLst    #输入参数，List类型数据结构，List中每一个元素为一个文档
        self.NumTopics = NumTopics  #话题数目
        self.MaxIter = MaxIter  #最大迭代数据
        self.MaxFeatures = MaxFeatures  #进行词频统计的最大数目

        #计算词频时需要用到的变量
        self.TFVectorizer = None
        self.TF = None  #词频统计结果
        #进行模型迭代时需要的变量
        self.LDAModelLst = []   #迭代产生的LDA模型列表
        self.PerplexityLst = [] #困惑度列表
        self.BestIndex = None
        self.BestLDAModel = None    #最佳LDA 模型
        self.BestLDAModelPerplexity = None  #最佳LDA模型的困惑度
        self.BestTopicNum = None    #最合适的主题数

    def LDACountVectorizer(self, MaxDf = 0.95, MinDf = 2):#这个值还有待确认
        """统计词频函数，调用CountVectorizer完成"""
        self.TFVectorizer = CountVectorizer(max_df = MaxDf,\
                                       min_df = MinDf,\
                                       max_features = self.MaxFeatures)
        self.TF = self.TFVectorizer.fit_transform(self.DocLst)

    def LDASaveTF(self, TFModelPath):
        """保存词频"""
        joblib.dump(self.TF, TFModelPath)

    def LDALoadVectorizer(self, TFModelPath):
        """导入之前计算得到的词频统计结果"""
        self.TF = joblib.load(TFModelPath)

    def LDATrain(self, NumTopic, MaxIter):
        """一次LDA训练，NumTopic为当前训练的主题数，MaxIter为最大迭代数"""
        LDAResult = LatentDirichletAllocation(n_components = NumTopic, \
                                              max_iter = MaxIter,\
                                              learning_method = 'batch',\
                                              # evaluate_every = 200, \
                                              # perp_tol = 0.01
                                              )
        # LDAResult.fit(self.TF)
        # TrainGamma = LDAResult.transform(self.TF)
        # TranPerplexity = LDAResult.perplexity(self.TF, TrainGamma)
        # return TrainGamma, TranPerplexity
        return LDAResult.fit(self.TF), LDAResult.perplexity(self.TF)

    def  IterationLDATrain(self):
        """迭代训练最佳的LDA模型，
        NumTopics为包括所有可能的主题数一个list，
        MaxIter为一次LDA训练的最大迭代数"""
        #开始进行迭代训练
        index = 0
        for NumTopic in self.NumTopics:
            lda, perplexity = self.__LDATrain(NumTopic, self.MaxIter)
            self.LDAModelLst.append(lda)
            self.PerplexityLst.append(perplexity)
            print(index)
            index += 1
        #保存最佳模型到
        BestIndex = self.PerplexityLst.index(min(self.PerplexityLst))#获取最佳模型的索引
        self.BestLDAModelPerplexity = min(self.PerplexityLst)
        self.BestTopicNum = self.NumTopics[BestIndex]
        self.BestLDAModel = self.LDAModelLst[BestIndex]
        self.BestIndex = BestIndex

    def TransformBestModel(self):
        for doc in self.TF:
            print(self.BestLDAModel.transform(doc))

    def __print_top_Words(self, model, FeatureNames, NumTopWords):
        for topic_idx, topic in enumerate(model.components_):
            print("Topic #%d:" % topic_idx)
            print(" ".join([FeatureNames[i]
                            for i in topic.argsort()[:-NumTopWords - 1:-1]]))

    def SaveTopicWords(self, NumTopWords, FilePath):
        """保存主题关键词，NumTopWord表示前多少个词"""
        TopicWords = ""
        FeatureNames = self.TFVectorizer.get_feature_names()
        for topic_idx, topic in enumerate(self.BestLDAModel.components_):
            TopicWords += "Topic #%d:" % topic_idx
            TopicWords += " ".join([FeatureNames[i]
                            for i in topic.argsort()[:-NumTopWords - 1:-1]]) +'\n'
        f = open(FilePath + 'TopicWords.txt', 'w')
        f.write(TopicWords)
        f.close()

    def PrintBestModelAndPerplexity(self, NumTopWords):
        """打印出最佳模型"""
        print("Best Number of Topic in LDA Model is ", self.BestTopicNum)
        print("the min Perplexity is", self.BestLDAModelPerplexity)
        print("Best Model is \n")
        self.__print_top_Words(self.BestLDAModel, self.TFVectorizer.get_feature_names(), NumTopWords)

    def SaveAllLDAMode(self, FilePath):
        """保存所有LDAModel"""
        #检查该目录是否存在，若不存在则创建
        CreateDir(FilePath)
        index = 0
        for m in self.LDAModelLst:
            joblib.dump(m, FilePath + 'LDA-model-' + str(index) + '.model')
            index += 1

    def SaveBestModel(self, FilePath):
        """保存最好的LDAmodel"""
        joblib.dump(self.BestLDAModel, FilePath + 'BestModel.model')

    def SavePerplexityCurveAndText(self, FilePath):
        """保存所有的困惑度（Perplexity），对应的曲线图像"""
        #检查该目录是否存在，若不存在则创建
        CreateDir(FilePath)
        # 保存perplexity结果
        with open(FilePath + 'Perplexity.txt', 'w') as f:
            PerplexityLstStr = ""
            index = 0
            for x in self.PerplexityLst:
                PerplexityLstStr += str(index) + '|' + str(self.NumTopics[index]) + '|' + str(x) + '\n'
                index += 1
            f.write(PerplexityLstStr)
        #绘制曲线并保存
        plt.close('all')
        Figure = plt.figure()
        ax = Figure.add_subplot(1, 1, 1)
        ax.plot(self.NumTopics, self.PerplexityLst)
        ax.set_xlabel("# of topics")
        ax.set_ylabel("Approximate Perplexity")
        plt.grid(True)
        plt.savefig(FilePath + 'PerplexityTrend.png')
        #plt.show()

    def PrintDocTopicDist(self):
        """打印出文档关于主题的矩阵，每一行表示文档，列表示是当前主题概率"""
        doc_topic_dist = self.BestLDAModel.transform(self.TF)
        for idx, dist in enumerate(doc_topic_dist):
            # 注意：由于sklearn LDA函数限制，此函数中输出的topic_word矩阵未normalize
            dist = [str(x) for x in dist]
            print(str(idx + 1) + ',')
            print(','.join(dist) + '\n')

    def SaveDocTopicDist(self, FilePath):
        """保存出文档关于主题的矩阵，每一行表示文档，列表示是当前主题概率"""
        doc_topic_dist = self.BestLDAModel.transform(self.TF)
        DocTopic = ''
        for idx, dist in enumerate(doc_topic_dist):
            # 注意：由于sklearn LDA函数限制，此函数中输出的topic_word矩阵未normalize
            dist = [str(x) for x in dist]
            DocTopic += 'Document ' + str(idx + 1) + ':' +','.join(dist) + '\n'
            # print str(idx + 1) + ','
            # print ','.join(dist) + '\n'
        f = open(FilePath + 'DocTopicDist.txt', 'w')
        f.write(DocTopic)
        f.close()

    def SaveConfigFile(self, FilePath):
        """保存文件配置"""
        f = open(FilePath + 'Config.txt', 'a')
        Config = \
            'k param = ' + str(max(self.NumTopics) + 1) + '\n' + \
            'MaxFeatures = ' + str(self.MaxFeatures) + '\n' + \
            'BestTopicNum = ' + str(self.BestTopicNum) + '\n' + \
            'BestIndex = ' + str(self.BestIndex)
        f.write(Config)
        f.close()

def KMeansPPChooseSeeds(self):
    """K-Means++算法，用于选择初始均值向量"""
    #1a. Take one center c1, chosen uniformly at random from Tweets.（the english annotations are from D.Arthur paper ）
    seed = random.choice(list(self.tweets.keys()))

    #Take a new center ci, choosing x from X with probability D(x)^2 / Sum(D(xi)^2)
    seeds = set([seed])
    while len(seeds) < self.k:
        DistanceMatrix = {}
        SumSqrDist = 0
        for seed in seeds:
            #V1 = set(self.tweets[seed].strip(' ').split(' '))
            for ID in self.tweets:
                if ID == seed:
                    continue
                #V2 = set(self.tweets[ID].strip(' ').split(' '))
                Dist = self.JaccardDistance(self.tweets[seed], self.tweets[ID])
                if ID not in DistanceMatrix or Dist < DistanceMatrix[ID]:
                    DistanceMatrix[ID] = Dist
        ProbabilityDict = {}
        for ID in DistanceMatrix:
            SumSqrDist += DistanceMatrix[ID] * DistanceMatrix[ID]
        for ID in DistanceMatrix:
            ProbabilityDict[ID] = DistanceMatrix[ID] * DistanceMatrix[ID] / SumSqrDist ##可以优化

#!/usr/bin/python
# -*- coding: UTF-8 -*-

"""基于jaccard 距离的迭代K-Means算法实现
"""

#   一些功能函数
import os

def CreateDir(FilePath):
    if not os.path.exists(FilePath):  # 目录不存在时，创建目录
        os.mkdir(FilePath)


def WriteFileLine(FilePath, DataList, style):
    try:
        f = open(FilePath, style)
        for DataLine in DataList:
            f.write(DataLine)
        f.close()
    except Exception as e:
        print('Create File ERROR' + str(e))


def ReadFile(FilePath):
    """读取预处理文件，返回值为Dict"""
    try:
        f = open(FilePath)
    except IOError:
        print("Can't find the file")
        return
    tweets = {}
    while True:
        line = f.readline()
        if not line:
            break
        try:
            ID = line.split('|')[0]
            Text = line.split('|')[1].strip('\n')
            tweets[ID] = set(Text.strip(' ').split(' '))
        except IndexError:
            continue
    return tweets


import copy
import random as Inrandom
from numpy import random
import time

class KMeans:
    def __init__(self, tweets, k, MaxIterations):
        """初始参数，tweets为推文，数据类型为Dict，键：tweetID，值：分词后的tweet，以集合的形式保存
        k为聚类簇数，MaxIterations为最大迭代次数'"""
        self.tweets = tweets
        self.k = k
        self.MaxIterations = MaxIterations

        self.seeds = []#随机选取的初始均值向量的ID
        self.Clusters = {}#用户存放聚类结果，字典之中的每一个键对应一簇
        self.RevClusters = {}#反向索引，字典之中键为tweets向量ID，值为簇序号
        self.JaccardMatrix = {}#设置为矩阵，用于存储每一对向量的jaccard距离
        self.LenTwitter = len(tweets)#推文的长度

        #运行初始均值向量随机选取函数
        self.InitializeChooseSeeds()
        #运行初始化聚类函数
        self.InitializeClusters()
        #运行计算Jaccard距离矩阵函数，修改：由于增加了LoadJaccardMatrix矩阵，所以不在__init__中直接运行，
        if self.LenTwitter <= 1500:
            self.InitializeJaccardMatrix()

    def JaccardDistance(self, SetA, SetB):
        """计算Jaccard距离函数，SetA 和 SetB为两个集合"""
        try:
            return 1 - float(len(SetA.intersection(SetB))) / float(len(SetA.union(SetB)))
        except TypeError:
            print('Error, SetA or SetB is none.')

    def InitializeChooseSeeds(self):
        """kmeans算法，选取初始均值向量，利用sample函数，从tweets键中随机选取k个ID"""
        self.seeds = Inrandom.sample(list(self.tweets.keys()), self.k)

    def InitializeClusters(self):
        """对聚类进行初始化"""
        #对反向索引进行初始化，由于当前没有进行聚类，反向索引置为-1
        for ID in self.tweets:
            self.RevClusters[ID] = -1

        #对聚类簇字典进行初始化，初始化使用随机选取的初始均值向量
        for i in range(self.k):
            self.Clusters[i] = set([self.seeds[i]]) #将tweet的ID以集合形式存储起来，i为簇序号也是字典键
            self.RevClusters[self.seeds[i]] = i #初始均值向量对应的簇序号已经确定，对反向索引进行赋值

    def InitializeJaccardMatrix(self):
        """计算出每一对tweet的Jaccard距离,动态规划思想，以空间换时间
        数据量过大时，可能会发生memoryerror的错误
        """
        #利用两层循环进行每一对ID的匹配
        k = 0 #调试变量
        try:
            for ID1 in self.tweets:
                self.JaccardMatrix[ID1] = {}
                for ID2 in self.tweets:
                    if ID2 not in self.JaccardMatrix:
                        self.JaccardMatrix[ID2] = {}
                    Distance = self.JaccardDistance(self.tweets[ID1], self.tweets[ID2])#计算出jaccard距离
                    self.JaccardMatrix[ID1][ID2] = Distance#距离赋值
                    self.JaccardMatrix[ID2][ID1] = Distance
                    k += 1
        except MemoryError:
            print(k)

    def LoadJaccardMatrix(self, FilePath):
        """导入已经计算好的Jaccard矩阵
        数据格式为：ID1 | ID2 | Value
        """
        try:
            f = open(FilePath, 'r')
        except IOError:
            print("Error! The file don't exist")
            return
        while True:
            line = f.readline()
            if not line:
                break
            try:
                #读出当前行的ID1 ID2 Distance
                ID1 = line.split('|')[0]
                ID2 = line.split('|')[1]
                Distance = float(line.split('|')[2])
                #若不存在啊ID1 ID2等相关键，则进行创建
                if ID1 not in self.JaccardMatrix:
                    self.JaccardMatrix[ID1] = {}
                if ID2 not in self.JaccardMatrix:
                    self.JaccardMatrix[ID2] = {}
                self.JaccardMatrix[ID1][ID2] = Distance  # 距离赋值
                self.JaccardMatrix[ID2][ID1] = Distance
            except IndexError:
                continue
        f.close()

    def CalcNewClusters(self):
        """计算新的聚类"""
        #初始化
        NewClusters = {}#新的聚类
        NewRevCluster = {}#新的反向索引
        for i in range(self.k):
            NewClusters[i] = set()#初始化为空集

        #遍历tweets中每一个元素，通过之前的聚类簇，构造出新的聚类
        k = 0   #调试变量
        for ID1 in self.tweets:
            MinDist = float("inf")  #将最小距离初始化为无穷小，保证存在出口
            MinCluster = self.RevClusters[ID1]

            #遍历每一个簇，计算出对于元素ID具有最小的簇数
            for j in self.Clusters:
            #for j in SampleResult:
                Dist = 0
                Count = float(0)
                #遍历当前簇之中的所有元素，计算出ID与其他元素的Jaccard之和
                #计算当前ID与当前簇的距离
                for ID2 in self.Clusters[j]:
                    if self.LenTwitter <= 1500:
                        Dist += self.JaccardMatrix[ID1][ID2]
                    else:
                        Dist += 1 - \
                                float(len(self.tweets[ID1].intersection(self.tweets[ID2]))) \
                                / float(len(self.tweets[ID1].union(self.tweets[ID2])))  # 计算当前选定元素ID与该类之中其他元素的距离和
                    #Dist += self.jaccardMatrix[ID1][ID2]
                    Count += 1 #计算当前类里元素的数量
                    k += 1  #调试变量
                if Count > 0:#若之前遍历的簇不为空，则进行距离判定
                    AvgDist = Dist / Count
                    if MinDist > AvgDist: #如果当前最小距离小于当前元素与该类的距离，则修改最小距离
                        MinDist = AvgDist
                        MinCluster = j
            NewClusters[MinCluster].add(ID1)#将当前元素添加到具有最小距离的类中
            NewRevCluster[ID1] = MinCluster#添加反向索引
        return NewClusters, NewRevCluster#返回新的聚类结果

    def Converge(self):
        """聚类顶层函数"""
        #初始化运行赋值
        NewClusters, NewRevCluster = self.CalcNewClusters()
        self.Clusters = copy.deepcopy(NewClusters)
        self.RevClusters = copy.deepcopy(NewRevCluster)

        #开始进行迭代，直至收敛或达到最大迭代次数
        Interations = 1
        while Interations < self.MaxIterations:#循环出口条件，小于最大迭代次数
            NewClusters, NewRevCluster = self.CalcNewClusters()
            Interations += 1
            if self.RevClusters != NewRevCluster: #当最新的迭代结果与之前结果不一致时，对聚类结果进行更新
                self.Clusters = copy.deepcopy(NewClusters)
                self.RevClusters = copy.deepcopy(NewRevCluster)
            else:#若结果收敛，则循环结束，聚类完成
                print(Interations)
                return Interations
        print('Get the Max!')
        return self.MaxIterations + 1

    def OneClusterSSE(self, Cluster):
        """计算每一簇聚类之中的误差平方"""
        OneClusterSSE = 0
        Len = len(Cluster)
        for ID1 in Cluster:
            S = 0
            for ID2 in Cluster:
                if self.LenTwitter <= 1500:
                    S += self.JaccardMatrix[ID1][ID2]
                else:
                    S += self.JaccardDistance(self.tweets[ID1], self.tweets[ID2])
            S /= Len
            #S = S*S
            OneClusterSSE += S*S

        return OneClusterSSE

    def CalculateSSE(self):
        """用于计算误差平方和，Sum Of The Squared Errors, SSE"""
        SSE = 0 #误差平方和
        for Ci in self.Clusters:
            SSE += self.OneClusterSSE(self.Clusters[Ci])
        return SSE

    def CalculateMinValue(self, Cluster1, Cluster2):
        MinValue = float("inf")#表示值为无穷大
        for ID1 in Cluster1:
            for ID2 in Cluster2:
                if self.LenTwitter <= 1500:
                    Dist = self.JaccardMatrix[ID1][ID2]
                else:
                    Dist = self.JaccardDistance(self.tweets[ID1], self.tweets[ID2])
                if MinValue > Dist:
                    MinValue = Dist
        return Dist

    def CalculateDiam(self,Cluster):
        """
        计算聚类之中元素的最大距离
        :param Cluster: 输入聚类
        :return: 返回最大值
        """
        Max = float('-inf')#令初始最大值为无限小，保证存在出口
        for ID1 in Cluster:
            for ID2 in Cluster:
                if self.LenTwitter <= 1500:
                    dist = self.JaccardMatrix[ID1][ID2]
                else:
                    dist = self.JaccardDistance(self.tweets[ID1], self.tweets[ID2])
                if dist > Max:
                    Max = dist

        return Max


    def CalculateDI(self):
        """
        计算DI指数
        :return:
        """
        #先计算分子
        DMin = float("inf")  # 表示值为无穷大
        for i in self.Clusters:
            for j in self.Clusters:
                if self.Clusters[i] is self.Clusters[j]:
                    continue
                else:
                    dist = self.CalculateMinValue(self.Clusters[i], self.Clusters[j])
                    if dist < DMin:
                        DMin = dist

        #在计算分母
        DMax = float('-inf')#令初始最大值为无限小，保证存在出口
        for l in self.Clusters:
            dist = self.CalculateDiam(self.Clusters[l])
            if dist > DMax:
                DMax = dist

        return DMin / DMax

    def PrintCluster(self):
        for i in self.Clusters:
            print('\n\nCluster ' + str(i))
            for ID in self.Clusters[i]:#遍历簇中每一个ID以及ID对应的tweet
                print(str(ID) + ' | ' + ' '.join(self.tweets[ID]) + '\n')

    def PrintJaccardMatrix(self):
        for ID in self.tweets:
            for ID2 in self.tweets:
                print(ID, ID2, self.JaccardMatrix[ID][ID2])

    def SaveClusterFile(self, FilePath):
        """以文件的形式保存聚类结果，FilePath为文件路径"""
        #若目录不存在，则创建路径
        CreateDir(FilePath)
        #遍历每一个簇
        for i in self.Clusters:
            TempCache = []#设置缓冲，存储当前簇中所有tweets
            for ID in self.Clusters[i]:#遍历簇中每一个ID以及ID对应的tweet
                #TempCache.append(str(ID) + '|' + self.tweets[ID] + '\n')    #还需要修改了这一部分东西
                TempCache.append(str(ID) + '|' + ' '.join(self.tweets[ID]) + '\n')  # 还需要修改了这一部分东西
            WriteFileLine(FilePath + 'C' + str(i) + '.txt', TempCache, 'w')

    def SaveJaccardMatrix(self, FilePath):
        """以文件的形式保存Jaccard矩阵计算结果，便于下次计算加速"""
        TempCache = []#设置缓冲
        #遍历矩阵之中的每一个元素
        for ID1 in self.tweets:
            for ID2 in self.tweets:
                TempCache.append(str(ID1) + '|' + str(ID2) + '|' + str(self.JaccardMatrix[ID1][ID2]) + '\n')
        #写入文件
        try:
            WriteFileLine(FilePath + 'JaccardMatrix.txt', TempCache, 'w')
        except IOError:
            print("Error! The file fail to create!")

def main():
    tweets = ReadFile('ClusterTest.txt')
    k = 27 #设置k参数
    MaxIterations = 50 #设置最大迭代次数
    kmeans = KMeans(tweets, 27, MaxIterations)
    Iterations = kmeans.Converge()  #方法返回最大迭代次数
    kmeans.SaveClusterFile("ClusterResult/")
    SSE = kmeans.CalculateSSE() #计算SSE
    DI = kmeans.CalculateDI() #计算DI
    print("MaxIterations: " + str(MaxIterations) + "\n" + "SSE: " + str(SSE) + '\n' + "DI: " + str(DI))


if __name__ == "__main__":
    time_start = time.time()  # time.time()为1970.1.1到当前时间的毫秒数
    main()
    time_end = time.time()  # time.time()为1970.1.1到当前时间的毫秒数
    print("the K-Means algorithm time:")
    print (str((time_end - time_start) / 60) + 'min')