• <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>
            alpc60 ACM/ICPC程序設計
            成長的路……源
            posts - 20,comments - 42,trackbacks - 0

            The Rotation Game

            Time Limit: 15000MS

             

            Memory Limit: 150000K

            Total Submissions: 944

             

            Accepted: 218

            Description

            The rotation game uses a # shaped board, which can hold 24 pieces of square blocks (see Fig.1). The blocks are marked with symbols 1, 2 and 3, with exactly 8 pieces of each kind.


            Initially, the blocks are placed on the board randomly. Your task is to move the blocks so that the eight blocks placed in the center square have the same symbol marked. There is only one type of valid move, which is to rotate one of the four lines, each consisting of seven blocks. That is, six blocks in the line are moved towards the head by one block and the head block is moved to the end of the line. The eight possible moves are marked with capital letters A to H. Figure 1 illustrates two consecutive moves, move A and move C from some initial configuration.

            Input

            The input consists of no more than 30 test cases. Each test case has only one line that contains 24 numbers, which are the symbols of the blocks in the initial configuration. The rows of blocks are listed from top to bottom. For each row the blocks are listed from left to right. The numbers are separated by spaces. For example, the first test case in the sample input corresponds to the initial configuration in Fig.1. There are no blank lines between cases. There is a line containing a single `0' after the last test case that ends the input.

            Output

            For each test case, you must output two lines. The first line contains all the moves needed to reach the final configuration. Each move is a letter, ranging from `A' to `H', and there should not be any spaces between the letters in the line. If no moves are needed, output `No moves needed' instead. In the second line, you must output the symbol of the blocks in the center square after these moves. If there are several possible solutions, you must output the one that uses the least number of moves. If there is still more than one possible solution, you must output the solution that is smallest in dictionary order for the letters of the moves. There is no need to output blank lines between cases.

            Sample Input

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

            Sample Output

            AC
            2
            DDHH
            2

            Source

            Shanghai 2004

             

             

            圖中的#字格的4條豎線,可以按8個方向倒轉里面的數字方塊,當中間的8個數字方塊是同一個數字時,游戲結束。這道題就要求搜索一個最短路徑,倒轉8個方向使得中間8個數字相等。這道題目看起來很像一道單純的BFS,看了POJ里面說BFS會爆內存,我沒試,估計寫得好的也爆不了。但是估計寫BFS還要涉及到狀態的判重,程序寫起來也不方便。我用了迭代加深的搜索方法。第一次接觸這個算法,我說一下我的理解:

                   原來我很不理解迭代加深,搜索的深度一層一層地加,在后面的某一深度限制下搜索,必定會搜到前面深度所能搜到的結果,這會造成重復搜索。基于這點,我一直都認為迭代加深搜索的方法很冗余,當然也是自己從來都沒有動手試過。像這道題就給我的收獲不少,有的時候選擇一定的策略進行搜索,我們是很難確定解所在狀態空間的深度的,有時可能解的深度不大,但整個狀態空間的深度很大,盲目的dfs搜索在狀態空間里就有可能會越陷越深,遲遲出不了解,同時整個狀態空間的寬度也很大,用BFS可能就會爆空間。迭代加深搜索恰恰是取了一個折中。利用了dfs的優勢,限制了搜索的深度,避免了出現無解的境地。由于深度是逐個增加的,當搜到一個解后就退出,所以避免了BFS中判重的一步操作,當然在迭代深搜的過程中,還可以加入剪枝,可以優化程序。但是我的程序在POJ上還不快,還要找找原因,也許還有優化。下面是一些關鍵代碼:


            for(limit=0; ;limit++)
                    
            {
                        
            if(dfs(start,0))
                        
            {
                            
            if(limit == 0)
                            
            {
                                printf(
            "No moves needed\n");
                            }

                            
            else
                            
            {
                                
            for(i=0; i<limit; i++)
                                
            {
                                    printf(
            "%c",'A'+pre[i]);
                                }

                                printf(
            "\n");
                            }

                            printf(
            "%d\n",rlt);
                            
            break;
                        }

                    }

            ///迭代過程
            int dfs(struct S now, int depth)
            {
                
            int c1,c2,c3;
                struct S st;
                test(now,c1,c2,c3);
                
            if(c1 == 8)
                
            {
                    rlt
            =1;
                    
            return 1;
                }

                
            else if(c2 == 8)
                
            {
                    rlt
            =2;
                    
            return 1;
                }

                
            else if(c3 == 8)
                
            {
                    rlt
            =3;
                    
            return 1;
                }

                
            if(depth == limit)
                    
            return 0;
                
            if(8-c1 > limit-depth && 8-c2 > limit-depth && 8-c3 > limit-depth)
                    
            return 0;
                st
            =NewStateA(now);
                pre[depth]
            =0;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateB(now);
                pre[depth]
            =1;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateC(now);
                pre[depth]
            =2;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateD(now);
                pre[depth]
            =3;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateE(now);
                pre[depth]
            =4;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateF(now);
                pre[depth]
            =5;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateG(now);
                pre[depth]
            =6;
                
            if(dfs(st,depth+1))
                    
            return 1;
                st
            =NewStateH(now);
                pre[depth]
            =7;
                
            if(dfs(st,depth+1))
                    
            return 1;
                
            return 0;
            }

            ///深搜
            posted on 2008-04-20 15:44 飛飛 閱讀(2712) 評論(1)  編輯 收藏 引用 所屬分類: ACM/ICPC

            FeedBack:
            # re: 迭代加深搜索
            2008-07-04 20:08 | wzc1989
            謝謝大牛分享!!!  回復  更多評論
              
            中文国产成人精品久久不卡| 亚洲国产成人久久综合一区77| 一级a性色生活片久久无| 久久久久久久久久久久久久| 久久精品国产网红主播| 国产亚洲精品自在久久| 久久综合丁香激情久久| 一本久久精品一区二区| 成人国内精品久久久久一区| 久久精品国产99久久丝袜| 天堂久久天堂AV色综合| 欧美伊香蕉久久综合类网站| 97久久婷婷五月综合色d啪蜜芽 | 久久国产精品一区| 精品人妻伦九区久久AAA片69| 国产精品久久久久久搜索| 久久久久人妻一区精品| 久久国产乱子伦免费精品| 亚洲国产精品成人久久蜜臀| 国产 亚洲 欧美 另类 久久 | 无码精品久久久天天影视| 精品综合久久久久久888蜜芽| 一级做a爰片久久毛片免费陪| 精品久久久久久亚洲| 中文字幕日本人妻久久久免费| 久久99久久无码毛片一区二区| 精品国际久久久久999波多野| 久久久久久久久久久精品尤物 | 97视频久久久| 婷婷久久综合九色综合九七| 美女写真久久影院| 国产美女久久久| 精品国产福利久久久| 久久国产精品99国产精| 无码日韩人妻精品久久蜜桃| 狠狠色综合网站久久久久久久高清 | 一本大道久久东京热无码AV| 一级a性色生活片久久无| 亚洲人成电影网站久久| 亚洲国产成人久久综合野外| 青春久久|