• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            gzwzm06

              C++博客 :: 首頁 :: 新隨筆 :: 聯(lián)系 :: 聚合  :: 管理 ::
              1 隨筆 :: 52 文章 :: 17 評論 :: 0 Trackbacks
            Memory: 74320K Time: 797MS
            Language: C++ Result: Accepted
            #include <stdio.h>
            #include 
            <string>
            using namespace std ;

            const int MAXN = 200000 ;
            const int APSIZE = 30 ;

            struct SuffixTreeNode
            {
                SuffixTreeNode 
            *descendants[APSIZE] ;
                
            int m_left[APSIZE], m_right[APSIZE] ;
                SuffixTreeNode 
            *suffixLink ;

                SuffixTreeNode()
                
            {
                    
            for ( int i = 0 ; i < APSIZE ; ++i )
                    
            {
                        m_left[i] 
            = -1 ;
                    }

                }

            }
             ;

            SuffixTreeNode g_STNode[MAXN] ;
            int g_Level = 0 ;

            SuffixTreeNode
            * NewSuffixTreeNode()
            {
                SuffixTreeNode 
            *ptr = &g_STNode[g_Level++] ;

                
            return ptr ;
            }


            SuffixTreeNode 
            *root ;
                    
            struct UkkonenSuffixTree
            {
                
                
            int offset ;
                
            int Lt ;

                
            string T ;

                
            bool endPoint ;

                UkkonenSuffixTree(
            int from)
                
            {
                    Lt 
            = 1 ;
                    offset 
            = from ;
                }

                
                SuffixTreeNode
            * TestAndSplit( SuffixTreeNode *p, int i )
                
            {
                    
            int Rt = i - 1 ;
                    
            if ( Lt <= Rt )
                    
            {
                        
            int pos = T.at(Lt) - offset ;
                        SuffixTreeNode
            * pp = p->descendants[pos] ;
                        
            int lt = p->m_left[pos] ;
                        
            int rt = p->m_right[pos] ;

                        
            if ( T.at(i) == T.at( lt + Rt - Lt + 1 ) )
                        
            {
                            endPoint 
            = true ;
                            
            return p ;
                        }

                        
            else {
                            pos 
            = T.at(lt) - offset ;
                            SuffixTreeNode 
            *= p->descendants[pos] = NewSuffixTreeNode() ;
                            p
            ->m_right[pos] = lt + Rt - Lt ;
                            pos 
            = T.at(lt + Rt - Lt + 1- offset ;
                            r
            ->descendants[pos] = pp ;
                            r
            ->m_left[pos] = lt + Rt - Lt + 1 ;
                            r
            ->m_right[pos] = rt ;
                            endPoint 
            = false ;
                            
            return r ;
                        }

                    }

                    
            else if ( p->m_left[T.at(i) - offset] == -1 )
                    
            {
                        endPoint 
            = false ;
                    }

                    
            else
                        endPoint 
            = true ;
                    
            return p ;
                }


                SuffixTreeNode
            * FindCanonicalNode( SuffixTreeNode *p, int Rt )
                
            {
                    
            if ( Rt >= Lt )
                    
            {
                        
            int pos = T.at(Lt) - offset ;
                        SuffixTreeNode 
            *pp = p->descendants[pos] ;
                        
            int lt = p->m_left[pos] ;
                        
            int rt = p->m_right[pos] ;
                        
            while ( rt - lt <= Rt - Lt )
                        
            {
                            Lt 
            = Lt + rt - lt + 1;
                            p 
            = pp ;
                            
            if ( Lt <= Rt )
                            
            {
                                pos 
            = T.at(Lt) - offset ;
                                pp 
            = p->descendants[pos] ;
                                lt 
            = p->m_left[pos] ;
                                rt 
            = p->m_right[pos] ;
                                
            if ( p == root )
                                    pp 
            = root ;
                            }

                        }

                    }


                    
            return p ;
                }


                SuffixTreeNode
            * Update( SuffixTreeNode *p, int i )
                
            {
                    SuffixTreeNode 
            *prev = NULL , *= TestAndSplit( p, i ) ;

                    
            while ( !endPoint )
                    
            {
                        
            int pos = T.at(i) - offset ;
                        r
            ->m_left[pos] = i ;
                        r
            ->m_right[pos] = T.length() - 1 ;

                        
            if ( prev != NULL )
                            prev
            ->suffixLink = r ;
                        prev 
            = r ;

                        
            if ( p == root )
                            Lt
            ++ ;
                        
            else
                            p 
            = p->suffixLink ;

                        p 
            = FindCanonicalNode( p, i - 1 ) ;
                        r 
            = TestAndSplit( p, i ) ;

                    }


                    
            if ( prev != NULL )
                        prev
            ->suffixLink = p ;
                    
            return p ;
                }


                
            void Run( string text )
                
            {
                    T 
            = text ;
                    
            int n = T.length() , pos = T.at(0- offset ;

                    root 
            = NewSuffixTreeNode() ;
                    root
            ->suffixLink = root ;
                    
                    root
            ->m_left[pos] = 0 ;
                    root
            ->m_right[pos] = n - 1 ;
                    
                    SuffixTreeNode 
            *canonicalNodeAP = root , *canonicalNodeEP ;
                    
            for ( int i = 1 ; i < n ; ++i )
                    
            {
                        canonicalNodeEP 
            = Update( canonicalNodeAP, i ) ;
                        canonicalNodeAP 
            = FindCanonicalNode( canonicalNodeEP, i ) ;
                    }

                }


            }
             ;

            int length = 0 , s1length = 0 ;
            void TraverseTree(SuffixTreeNode *p, int lt, int len, bool& a, bool& b )
            {
                
            bool edge1 = false, edge2 = false ;

                
            for ( int i = 0 ; i < APSIZE ; ++i )
                
            {
                    
            if ( p->m_left[i] != -1 )
                    
            {
                        
            if ( p->descendants[i] == NULL )
                        
            {
                            
            if ( p->m_left[i] <= s1length )
                                a 
            = edge1 = true ;
                            
            else
                                b 
            = edge2 = true ;
                        }

                        
            else {
                            TraverseTree( p
            ->descendants[i], p->m_left[i],
                                len 
            + (p->m_right[i] - p->m_left[i] + 1) , edge1, edge2 ) ;

                            
            if ( edge1 )
                                a 
            = true ;
                            
            if ( edge2 )
                                b 
            = true ;
                        }

                        
            if ( edge1 && edge2 && len > length )
                        
            {
                            length 
            = len ;
                        }

                    }

                }

            }


            int FindLongest()
            {
                
            bool edge1 = false , edge2 = false ;

                TraverseTree( root, 
            00, edge1, edge2 ) ;

                
            return length ;
            }



            int main()
            {
                
            char s1[100000], s2[100000] ;
                gets(s1) ;
                gets(s2) ;
                
            int l1 = strlen(s1), l2 = strlen(s2) ;
                s1[l1] 
            = '|', s1[l1 + 1= '\0' ;
                s2[l2] 
            = '}', s2[l2 + 1= '\0' ;
                
                strcat( s1, s2 ) ;

                s1length 
            = l1 ;;
                UkkonenSuffixTree t(
            'a') ;
                t.Run(s1) ;

                
            int ans = FindLongest() ;

                printf(
            "%d\n", ans) ;

                
            return 0 ;
            }
            posted on 2008-11-08 14:15 閱讀(595) 評論(1)  編輯 收藏 引用 所屬分類: 字符串處理

            評論

            # re: Pku 2774--Long Long Message(后綴樹) 2011-05-15 13:51 dereky
            求教大牛,那個Lt屬性是記錄什么的  回復(fù)  更多評論
              

            精品久久久久久亚洲精品 | 一本久道久久综合狠狠躁AV| 久久国产成人午夜aⅴ影院| 久久久久久毛片免费看| 亚洲精品国产字幕久久不卡| 1000部精品久久久久久久久| 久久中文精品无码中文字幕| 午夜天堂av天堂久久久| 久久国产精品一区| 精品国产乱码久久久久久郑州公司 | 国产精品久久久久久久app| 精品久久久久久无码专区不卡| 国产免费福利体检区久久| 亚洲va久久久噜噜噜久久天堂| 久久久久久极精品久久久| 久久不见久久见免费视频7| 色播久久人人爽人人爽人人片aV| 久久香综合精品久久伊人| 一本久久综合亚洲鲁鲁五月天| 亚洲狠狠综合久久| 97久久香蕉国产线看观看| 久久综合亚洲鲁鲁五月天| 久久久久成人精品无码| 品成人欧美大片久久国产欧美| 精品久久久久中文字幕日本| A级毛片无码久久精品免费| 日韩欧美亚洲综合久久影院Ds| 国产高潮国产高潮久久久| 漂亮人妻被中出中文字幕久久 | 久久中文字幕精品| 国产精品欧美亚洲韩国日本久久 | 青青青青久久精品国产h| 久久亚洲精品人成综合网| 久久久精品国产sm调教网站 | 模特私拍国产精品久久| 久久久久亚洲精品男人的天堂| 久久99精品国产一区二区三区| 国产精品99久久久久久人| 国产午夜久久影院| 丁香五月综合久久激情| 91精品免费久久久久久久久|