• <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>

            我希望你是我獨(dú)家記憶

            一段永遠(yuǎn)封存的記憶,隨風(fēng)而去
            posts - 263, comments - 31, trackbacks - 0, articles - 3
               :: 首頁(yè) :: 新隨筆 ::  :: 聚合  :: 管理
            /*
            ID: wangzha4
            LANG: C++
            TASK: frameup
            */
            //JUDGE_ID: 65448BI
            /*

               Test 1: TEST OK [0.000 secs, 3312 KB]
               Test 2: TEST OK [0.000 secs, 3312 KB]
               Test 3: TEST OK [0.011 secs, 3312 KB]
               Test 4: TEST OK [0.000 secs, 3308 KB]
               Test 5: TEST OK [0.000 secs, 3444 KB]
               Test 6: TEST OK [0.000 secs, 3308 KB]
               Test 7: TEST OK [0.000 secs, 3308 KB]
               Test 8: TEST OK [0.011 secs, 3440 KB]
               Test 9: TEST OK [0.043 secs, 3440 KB]
            */
            //拓?fù)渑判虻念}目--輸出所有可能的拓?fù)渑判颍醋值湫?/span>
            /*

            具體思路 :
            1. 讀入數(shù)據(jù),用used[]記錄那些字符被使用過(guò),并將字符hash到
               從小到大的數(shù)字cnt,用mymap[]數(shù)組來(lái)將數(shù)字hash回相應(yīng)的字符
            2. 尋找矩形框--找到每種字符最大和最小的行列,存放在node[]數(shù)組中

            3. 構(gòu)建圖形edge[][]--掃描輸入,對(duì)于每個(gè)字母,按照矩形框掃描四個(gè)邊
               如果掃描到不相同的字母,建立一條有向邊,edge[][]=1
            4. DFS_Topsort()--對(duì)于已經(jīng)建立好的有向邊利用深度優(yōu)先搜索排序
            5. 輸出所有的拓?fù)湫蛄?br>
            */
            #include 
            <stdio.h>
            #include 
            <stdlib.h>
            #include 
            <string.h>
            #include 
            <ctype.h>
            #include 
            <math.h>

            #define unllong unsigned long long 
            #define unint unsigned int
            #define printline  printf( "\n" ) 
            typedef 
            long long llong ;
            //const double PI = 2.0 * acos( 0.0 ) ;

            const int Base=1000000000;
            const int Capacity=100;
            const int INF = 1000000 ;
            const int size = 35 ;

            struct NODE
            {
                
            int minr, minc ;
                
            int maxr, maxc ;
            };
            struct NODE node[28] ;

            char data[size][size] ;

            int used[200] ;//把字符映射成數(shù)字
            char mymap[200] ;//把數(shù)字映射成字符
            int cnt ;//記錄映射的最大數(shù)字--圖的最大頂點(diǎn)標(biāo)號(hào)

            int edge[30][30] ;//構(gòu)建有向圖
            int indeg[30] ;//記錄所有的點(diǎn)的入度

            int row, col ;

            char topout[30] ;//暫存生成的拓?fù)湫蛄?/span>

            struct OUT 
            {
                
            char str[30] ;
            };
            struct OUT out[20000] ;
            int ct_out ;

            int fmax( int a, int b )
            {
                
            if( a > b )    return a ;
                
            else        return b ;
            }

            int fmin( int a, int b )
            {
                
            if( a < b )    return a ;
                
            else        return b ;
            }

            void input()
            {
                memset( used, 
            0sizeof(used) ) ;
                memset( mymap, 
            0sizeof(mymap) ) ;
                memset( indeg, 
            0sizeof(indeg) ) ;
                memset( edge, 
            0sizeof(edge) ) ;

                cnt 
            = 1 ;
                
            forint i=0; i<row; i++ ) { 
                    scanf( 
            "%s", data[i] ) ;
                    
            forint j=0; j<col; j++ ) {
                        
            if'.' == data[i][j] ) continue ;
                        
            if( used[data[i][j]] )    continue ;
                        used[data[i][j]] 
            = cnt ; mymap[cnt++= data[i][j] ;
                    }
            //建立相互映射
                }

                
            forint i=0; i<=26; i++ ) {
                    node[i].minr 
            = node[i].minc = INF ;
                    node[i].maxr 
            = node[i].maxc = -1 ;
                }
            //初始化每個(gè)字母的最小最大行列
            }

            void find_degree()
            {
                
            forint i=1; i<cnt; i++ )
                    
            forint j=1; j<cnt; j++ )    
                        indeg[i] 
            += edge[j][i] ;
            }

            void DFS_Topsort( int sn, int tdep )
            {
                
            int back[30] ;//深搜的用于暫存狀態(tài)的數(shù)組
                forint i=1; i<cnt; i++ ) back[i] = indeg[i] ;

                
            if( sn == tdep )
                {
                    
            //printf( "=======%s\n", topout ) ;
                    strcpy( out[ct_out].str, topout ) ;
                    ct_out
            ++ ;
                    
            return ;
                }
                
            forint i=1; i<cnt; i++ )
                {
                    
            if0 == indeg[i] ) { 
                        topout[sn] 
            = mymap[i] ; indeg[i] = -1 ; 
                        
            forint k=1; k<cnt; k++ ) 
                            
            if( edge[i][k] ) indeg[k]-- ;//入度減1

                        DFS_Topsort( sn
            +1, tdep ) ;

                        
            forint k=1; k<cnt; k++ ) indeg[k] = back[k] ;
                    }
                }
            }

            void find_edge( int curn )
            {
            //對(duì)四個(gè)邊進(jìn)行查找--尋找矩形框
                int minr = node[curn].minr ; int minc = node[curn].minc ;
                
            int maxr = node[curn].maxr ; int maxc = node[curn].maxc ;

                
            int nodex, nodey ; nodey = used[curn+'A'] ;
                
            forint k=minc; k<=maxc; k++ )
                {
                    
            if( data[minr][k]!='.'&&data[minr][k]!=curn+'A' ) {
                        nodex 
            = used[data[minr][k]] ; edge[nodey][nodex] = 1 ;
                    }
                    
            if( data[maxr][k]!='.'&&data[maxr][k]!=curn+'A' ) {
                        nodex 
            = used[data[maxr][k]] ; edge[nodey][nodex] = 1 ;
                    }
                }
                
            forint k=minr; k<=maxr; k++ )
                {
                    
            if( data[k][minc]!='.'&&data[k][minc]!=curn+'A' ) {
                        nodex 
            = used[data[k][minc]] ; edge[nodey][nodex] = 1 ;
                    }
                    
            if( data[k][maxc]!='.'&&data[k][maxc]!=curn+'A' ) {
                        nodex 
            = used[data[k][maxc]] ; edge[nodey][nodex] = 1 ;
                    }
                }
            }

            void build_graph()
            {
                
            forint i=0; i<row; i++ ) {
                    
            forint j=0; j<col; j++ ) {
                        
            if'.' == data[i][j] )    continue ;
                        find_edge( data[i][j] 
            - 'A' ) ;
                    }
                }
                
            forint i=1; i<cnt; i++ ) edge[i][i] = 0 ;
            }

            void process()
            {
                
            int curnode ;
                
            forint i=0; i<row; i++ ) {
                    
            forint j=0; j<col; j++ ) {
                        
            if( data[i][j] != '.' ) {
                            curnode 
            = data[i][j] - 'A' ;
                            node[curnode].minr 
            = fmin( node[curnode].minr, i ) ;
                            node[curnode].minc 
            = fmin( node[curnode].minc, j ) ;
                            node[curnode].maxr 
            = fmax( node[curnode].maxr, i ) ;
                            node[curnode].maxc 
            = fmax( node[curnode].maxc, j ) ;
                        }
                    }
                }
            //尋找每個(gè)字母的矩形框

                build_graph() ; 
            //建圖

                find_degree() ;
            //計(jì)算入度

                ct_out 
            = 0 ;
                DFS_Topsort( 
            0, cnt-1 ) ;//拓?fù)渑判?/span>
            }

            int cmp( const void *a, const void *b )
            {
                
            struct OUT *= (struct OUT *)a ;
                
            struct OUT *= (struct OUT *)b ;

                
            return strcmp( c->str, d->str ) ;
            }

            void output()
            {
                qsort( 
            out, ct_out, sizeof(out[1]), cmp ) ;

                
            forint i=0; i<ct_out; i++ )
                {
                    printf( 
            "%s\n"out[i].str ) ;
                }
            }

            int main()
            {
                freopen( 
            "frameup.in""r", stdin ) ;
                freopen( 
            "frameup.out","w",stdout ) ;

                
            //freopen( "in.txt", "r", stdin ) ;

                
            while( scanf( "%d %d"&row, &col ) != EOF )
                {
                    input() ;

                    process() ;

                    output() ;
                }
                
            return 0 ;
            }
            久久综合狠狠综合久久| 久久被窝电影亚洲爽爽爽| 久久九九免费高清视频| 一本大道加勒比久久综合| 精品水蜜桃久久久久久久| 精品久久久久久国产91| 91精品国产乱码久久久久久| 色综合久久久久久久久五月| 久久久久99精品成人片欧美| 青青草国产成人久久91网| 久久久受www免费人成| 亚洲国产精品成人久久| 久久免费高清视频| 久久这里只有精品首页| 国产精品无码久久久久| 亚洲国产精品无码久久| 欧美伊人久久大香线蕉综合69 | 久久精品国产亚洲av瑜伽| 久久久久女人精品毛片| 久久久久99精品成人片直播| 91久久精品国产91性色也| 久久人妻少妇嫩草AV蜜桃| 久久精品国产精品亚洲精品| 国产精品美女久久久免费| 久久综合久久综合久久| 久久综合丝袜日本网| 久久免费国产精品| 综合久久精品色| 国产一级持黄大片99久久| 国产99久久九九精品无码| 国内精品久久久久影院老司| 久久久噜噜噜久久熟女AA片| 久久精品成人免费看| 久久www免费人成看片| 国产成人香蕉久久久久| 久久久一本精品99久久精品88| 一本色道久久综合亚洲精品| 伊人色综合久久| 午夜不卡888久久| 国内精品久久人妻互换| 精品少妇人妻av无码久久|