本博客rss订阅地址: http://feed.cnblogs.com/blog/u/147990/rss

编程之美1.3 一摞烙饼的排序

问题描述：

这是前缀翻转排序问题，书上的内容这里不详述，给个电子版下载地址

本文源码编译环境：codeblock with gcc

书上给的源码有点小错误，编译通不过，这里是修改过后的原始代码：

  1 /****************************************************************/
  2 //
  3 // 烙饼排序实现
  4 //
  5 /****************************************************************/
  6 #include <cstdio>
  7 #include<cassert>
  8 class CPrefixSorting
  9 {
 10 public:
 11 
 12     CPrefixSorting()    
 13     {
 14         m_nCakeCnt = 0;
 15         m_nMaxSwap = 0;
 16         m_CakeArray = NULL;
 17         m_SwapArray = NULL;
 18         m_ReverseCakeArray = NULL;
 19         m_ReverseCakeArraySwap = NULL;
 20     }
 21 
 22     ~CPrefixSorting()
 23     {printf("1");
 24         if( m_CakeArray != NULL )
 25         {
 26             delete []m_CakeArray;  
 27         }
 28         if( m_SwapArray != NULL )
 29         {
 30             delete []m_SwapArray;  
 31         }
 32         if( m_ReverseCakeArray != NULL )
 33         {
 34             delete []m_ReverseCakeArray;  
 35         }
 36         if( m_ReverseCakeArraySwap != NULL )
 37         {
 38             delete []m_ReverseCakeArraySwap;  
 39         }
 40         printf("2");
 41     }
 42 
 43     //
 44     // 计算烙饼翻转信息
 45     // @param
 46     // pCakeArray    存储烙饼索引数组
 47     // nCakeCnt    烙饼个数
 48     //
 49     void Run(int* pCakeArray, int nCakeCnt)
 50     {
 51         Init(pCakeArray, nCakeCnt);
 52 
 53         m_nSearch = 0;
 54         Search(0);
 55     }
 56 
 57     //
 58     // 输出烙饼具体翻转的次数
 59     //
 60     void Output()
 61     {
 62         for(int i = 0; i < m_nMaxSwap; i++)
 63         {
 64             printf("%d ", m_SwapArray[i]);
 65         }
 66 
 67         printf("\n |Search Times| : %d\n", m_nSearch);
 68         printf("Total Swap times = %d\n", m_nMaxSwap);
 69     }
 70 
 71 private:
 72 
 73     //
 74     // 初始化数组信息
 75     // @param
 76     // pCakeArray    存储烙饼索引数组
 77     // nCakeCnt    烙饼个数
 78     //
 79     void Init(int* pCakeArray, int nCakeCnt)
 80     {
 81         assert(pCakeArray != NULL);
 82         assert(nCakeCnt > 0);
 83 
 84         m_nCakeCnt = nCakeCnt;
 85 
 86         // 初始化烙饼数组
 87         m_CakeArray = new int[m_nCakeCnt]; 
 88         assert(m_CakeArray != NULL);
 89         for(int i = 0; i < m_nCakeCnt; i++)
 90         {
 91             m_CakeArray[i] = pCakeArray[i];
 92         }
 93 
 94         // 设置最多交换次数信息
 95         m_nMaxSwap = UpBound(m_nCakeCnt);
 96 
 97         // 初始化交换结果数组 
 98         m_SwapArray = new int[m_nMaxSwap + 1];
 99         assert(m_SwapArray != NULL);
100 
101         // 初始化中间交换结果信息
102         m_ReverseCakeArray = new int[m_nCakeCnt];
103         for(int i = 0; i < m_nCakeCnt; i++)
104         {
105             m_ReverseCakeArray[i] = m_CakeArray[i];
106         }
107         m_ReverseCakeArraySwap = new int[m_nMaxSwap + 1];
108     }
109 
110 
111     //
112     // 寻找当前翻转的上界
113     //
114     //
115     int UpBound(int nCakeCnt)
116     {
117         return nCakeCnt*2;
118     }
119 
120     //
121     // 寻找当前翻转的下界
122     //
123     //
124     int LowerBound(int* pCakeArray, int nCakeCnt)
125     {
126         int t, ret = 0;
127 
128         // 根据当前数组的排序信息情况来判断最少需要交换多少次
129         for(int i = 1; i < nCakeCnt; i++)
130         {
131             // 判断位置相邻的两个烙饼，是否为尺寸排序上相邻的
132             t = pCakeArray[i] - pCakeArray[i-1];
133             if((t == 1) || (t == -1))
134             {
135             } 
136             else
137             {
138                 ret++;
139             }
140         }
141         return ret;
142     }
143 
144     // 排序的主函数
145     void Search(int step)
146     {
147         int i, nEstimate;
148 
149         m_nSearch++;
150 
151         // 估算这次搜索所需要的最小交换次数
152         nEstimate = LowerBound(m_ReverseCakeArray, m_nCakeCnt);
153         if(step + nEstimate > m_nMaxSwap)
154             return;
155 
156         // 如果已经排好序，即翻转完成，输出结果
157         if(IsSorted(m_ReverseCakeArray, m_nCakeCnt))
158         {
159             if(step < m_nMaxSwap)
160             { 
161                 m_nMaxSwap = step;
162                 for(i = 0; i < m_nMaxSwap; i++)
163                     m_SwapArray[i] = m_ReverseCakeArraySwap[i];
164             }
165             return;
166         }
167 
168         // 递归进行翻转
169         for(i = 1; i < m_nCakeCnt; i++)
170         {
171             Revert(0, i);
172             m_ReverseCakeArraySwap[step] = i;
173             Search(step + 1);
174             Revert(0, i);
175         }
176     }
177     //
178     // true : 已经排好序
179     // false : 未排序
180     //
181     bool IsSorted(int* pCakeArray, int nCakeCnt)
182     {
183         for(int i = 1; i < nCakeCnt; i++)
184         {
185             if(pCakeArray[i-1] > pCakeArray[i])
186             {
187                 return false;
188             }
189         }
190         return true;
191     }
192 
193     //
194     // 翻转烙饼信息
195     //    
196     void Revert(int nBegin, int nEnd)
197     {
198         assert(nEnd > nBegin);
199         int i, j, t;
200 
201         // 翻转烙饼信息
202         for(i = nBegin, j = nEnd; i < j; i++, j--)
203         {
204             t = m_ReverseCakeArray[i]; 
205             m_ReverseCakeArray[i] = m_ReverseCakeArray[j];
206             m_ReverseCakeArray[j] = t;
207         }
208     }
209 
210 private:
211 
212     int* m_CakeArray;    // 烙饼信息数组
213     int m_nCakeCnt;    // 烙饼个数
214     int m_nMaxSwap;    // 最多交换次数。根据前面的推断，这里最多为
215     // m_nCakeCnt * 2 
216     int* m_SwapArray;    // 交换结果数组
217 
218     int* m_ReverseCakeArray;    // 当前翻转烙饼信息数组
219     int* m_ReverseCakeArraySwap;    // 当前翻转烙饼交换结果数组
220     int m_nSearch;    // 当前搜索次数信息
221 };
222 
223 
224 int main()
225 {
226     CPrefixSorting a;
227     int cakeArry[] = {3,2,1,6,5,4,9,8,7,0};
228     a.Run(cakeArry, sizeof(cakeArry) / sizeof(int));
229     a.Output();
230     printf("\n");
231     CPrefixSorting b;
232     int cakeArry1[] = {12,3,2,1,11,6,5,10,4,9,8,7,0};
233     b.Run(cakeArry1, sizeof(cakeArry1) / sizeof(int));
234     b.Output();
235     printf("\n");
236     CPrefixSorting c;
237     int cakeArry2[] = {2,0,1};
238     c.Run(cakeArry2, sizeof(cakeArry2) / sizeof(int));
239     c.Output();
240     return 0;
241 }
原始代码

三个测试样例运行结果：

下面的讨论主要是针对书上搜索算法的改进，并且在原始代码的基础上进行修改。下面是对原始程序的几点说明：

1、要尽快找到最小翻转次数，就要减少搜索过程中（深搜）搜索子树的数目，即剪枝。原文中是通过分析某个序列，使该序列有序的最小翻转次数和最大翻转次数来剪枝的。关于翻转次数的上界和下界，原文中也提到了分别是 (5n+5)/3向上取整 和 15n/14向上取整，需要注意的是这里的上界和下界是指：任意给定一个序列，最大翻转次数是(5n+5)/3向上取整 ，最小翻转次数是15n/14向上取整；而程序中的上界和下界分别是针对某个序列而言，比如对于序列5 4 3 2 1，按照公式下界是5*15/14 = 6，但其实只要翻转1次。

2、原始程序中使用2n作为上界，其实按照每次把最大的烧饼翻转的最底下的算法，上界应该为2（n-1），具体书上已经有说明（当然一开始我们也可以选择(5n+5)/3向上取整作为上界）。然后在搜索的过程中每找到一个比当前上界更好的方案，就更新上界。

3、对于下界书上做法是：因为每一次翻转最多只能使一个烙饼与大小和它相邻的烙饼排到一起，所以如果当前n个烙饼中，有m对相邻的烙饼大小不相邻，那么我们至少需要m次翻转才能排好序。

下面是改进的几个地方，改进后的代码以及改进结果见本文末尾：

1、翻转上界的改进：其实我们可以通过选择某个方案对原始序列进行翻转使之有序，计算翻转次数，那么这个翻转次数可以作为上界，因为最优的方案肯定不会比当前的方案差。改进的代码里选择书上讲的翻转方案：把最大的未就位的烙饼翻转到它对应的位置，具体见函数UpBound_case

2、翻转下届的改进：不仅要像书上那样考虑相邻位置烙饼大小是否相邻，还要考虑最大烧饼是否就位，若序列中最大烧饼不在最后的位置必然要反转一次使其就位，而这次是最大烧饼就位的翻转不改变序列的相邻烧饼的连续性，具体见LowerBound函数。

3、search中是否超过上届的条件判断：具体说明见search函数的注释（下面代码224行 和 240行）

4、在搜索的过程中，对于某个序列，原始程序是每个位置都翻转一次，改进后，对于序列后面已经排好序的位置就不进行翻转，因为对排好序的位置翻转必然不会减少翻转次数，程序中通过search函数第二个参数实现。

5、在对序列翻转再搜索时，源程序是从第一个位置依次到最后一个位置翻转再搜索，改进后，我们对翻转每个位置翻转后的序列进行一个评估，评估它离有序序列的距离，然后优先搜索距离小的序列。评估函数其实就是LowerBound函数

6、对序列翻转再搜索时，若某个翻转刚好使序列有序，那么其他翻转方案肯定会导致无序，因此可以放弃搜索，代码通过search的返回值实现，具体见下面代码292行

改进代码和结果如下：

  1 #include<cstdio>
  2 #include<cassert>
  3 #include<vector>
  4 #include<algorithm>
  5 struct node
  6 {
  7     int index;
  8     int score;
  9 };
 10 
 11 bool comp(struct node a, struct node b)
 12 {
 13     return a.score < b.score;
 14 }
 15 
 16 class CPrefixSorting
 17 {
 18 public:
 19 
 20     CPrefixSorting()
 21     {
 22         m_nCakeCnt = 0;
 23         m_nMaxSwap = 0;
 24         m_CakeArray = NULL;
 25         m_SwapArray = NULL;
 26         m_ReverseCakeArray = NULL;
 27         m_ReverseCakeArraySwap = NULL;
 28         flag1 = false;
 29     }
 30 
 31     ~CPrefixSorting()
 32     {
 33         releaseAll();
 34     }
 35 
 36     void releaseAll()
 37     {
 38         if( m_CakeArray != NULL )
 39         {
 40             delete []m_CakeArray;
 41             m_CakeArray = NULL;
 42         }
 43         if( m_SwapArray != NULL )
 44         {
 45             delete []m_SwapArray;
 46             m_SwapArray = NULL;
 47         }
 48         if( m_ReverseCakeArray != NULL )
 49         {
 50             delete []m_ReverseCakeArray;
 51             m_ReverseCakeArray = NULL;
 52         }
 53         if( m_ReverseCakeArraySwap != NULL )
 54         {
 55             delete []m_ReverseCakeArraySwap;
 56             m_ReverseCakeArraySwap = NULL;
 57         }
 58     }
 59 
 60     //
 61     // 计算烙饼翻转信息
 62     // @param
 63     // pCakeArray    存储烙饼索引数组
 64     // nCakeCnt    烙饼个数
 65     //
 66     void Run(int* pCakeArray, int nCakeCnt)
 67     {
 68 
 69         releaseAll();
 70         Init(pCakeArray, nCakeCnt);
 71 
 72         m_nSearch = 0;
 73         Search(0, nCakeCnt - 1);
 74     }
 75 
 76     //
 77     // 输出烙饼具体翻转的次数
 78     //
 79     void Output()
 80     {
 81         for(int i = 0; i < m_nMaxSwap; i++)
 82         {
 83             printf("%d ", m_SwapArray[i]);
 84         }
 85 
 86         printf("\n |Search Times| : %d\n", m_nSearch);
 87         printf("Total Swap times = %d\n\n", m_nMaxSwap);
 88     }
 89 
 90 private:
 91 
 92     //
 93     // 初始化数组信息
 94     // @param
 95     // pCakeArray    存储烙饼索引数组
 96     // nCakeCnt    烙饼个数
 97     //
 98     void Init(int* pCakeArray, int nCakeCnt)
 99     {
100         assert(pCakeArray != NULL);
101         assert(nCakeCnt > 0);
102 
103         flag1 = false;
104 
105         m_nCakeCnt = nCakeCnt;
106 
107         // 初始化烙饼数组
108         m_CakeArray = new int[m_nCakeCnt];
109         assert(m_CakeArray != NULL);
110         for(int i = 0; i < m_nCakeCnt; i++)
111         {
112             m_CakeArray[i] = pCakeArray[i];
113         }
114 
115         // 初始化中间交换结果信息
116         m_ReverseCakeArray = new int[m_nCakeCnt];
117         for(int i = 0; i < m_nCakeCnt; i++)
118         {
119             m_ReverseCakeArray[i] = m_CakeArray[i];
120         }
121 
122         // 设置最多交换次数信息
123         //m_nMaxSwap = UpBound(m_nCakeCnt);
124         m_nMaxSwap = UpBound_case(m_ReverseCakeArray, m_nCakeCnt);
125         //UpBound_case中m_ReverseCakeArray改变了
126         //m_ReverseCakeArray复原
127         for(int i = 0; i < m_nCakeCnt; i++)
128         {
129             m_ReverseCakeArray[i] = m_CakeArray[i];
130         }
131 
132         // 初始化交换结果数组
133         m_SwapArray = new int[m_nMaxSwap + 1];
134         assert(m_SwapArray != NULL);
135 
136         m_ReverseCakeArraySwap = new int[m_nMaxSwap];
137         assert(m_ReverseCakeArraySwap != NULL);
138     }
139 
140 
141     //
142     // 寻找当前翻转的上界
143     //
144     //
145     int UpBound(int nCakeCnt)
146     {
147         return nCakeCnt*2-2;
148     }
149 
150     //--每次把最大的翻转到最下面，计算这种方法所需要的次数
151     //--计算过程中保存翻转结果，因为这种方法可能就是最小翻转次数的方法
152     //--这个次数可以作为翻转次数的上界
153     int UpBound_case(int* pCakeArray, int nCakeCnt)
154     {
155         int re = 0;
156         for (int j = nCakeCnt - 1 ; ;)
157         {
158             while(j > 0 && j == pCakeArray[j])
159                 --j;
160             if (j <= 0)
161                 break;
162             int i = j;
163             while (i >= 0 && pCakeArray[i] != j)
164                 --i;
165             if (i != 0)
166             {
167                 Revert(pCakeArray, 0, i);
168                 re++;
169             }
170             Revert(pCakeArray, 0, j);
171             re++;
172             --j;
173         }
174         return re;
175     }
176 
177     //
178     // 寻找当前翻转的下界
179     //
180     //
181     int LowerBound(int* pCakeArray, int nCakeCnt)
182     {
183         int t, ret = 0;
184 
185         // 根据当前数组的排序信息情况来判断最少需要交换多少次
186         for(int i = 1; i < nCakeCnt; i++)
187         {
188             // 判断位置相邻的两个烙饼，是否为尺寸排序上相邻的
189             t = pCakeArray[i] - pCakeArray[i-1];
190             if((t == 1) || (t == -1))
191             {
192             }
193             else
194             {
195                 ret++;
196             }
197         }
198         //--如果最大的烙饼不在最后一个位置，则要多翻转一次
199         if (pCakeArray[nCakeCnt-1] != nCakeCnt-1) ret++;
200         return ret;
201     }
202 
203     //--序列评估函数，对一个序列，若到达有序状态所需的翻转次数越少，得分越少
204     //--若到达有序状态所需的翻转次数越多，得分越多
205     //--搜索时可以优先搜索得分少的序列，这样能尽快达到最优解
206     int Evaluate(int* pCakeArray, int nCakeCnt)
207     {
208         return LowerBound(pCakeArray, nCakeCnt);
209     }
210 
211     // 排序的主函数
212     //--第endBound+1 个烧饼后均以排好序，没有必要对排好序的进行交换
213     //--因为交换已经排好序的烧饼只能使交换次数增大
214     //--如果当前搜索的序列排好序则返回true，否则返回false
215     bool Search(int step, int endBound)
216     {
217         int i, nEstimate;
218 
219         m_nSearch++;
220 
221         // 估算这次搜索所需要的最小交换次数
222         nEstimate = LowerBound(m_ReverseCakeArray, m_nCakeCnt);
223 
224         //--遇到相等情形，若对于翻转次数为m_nMaxSwap的结果已经保存，流程继续。
225         //--后面再遇到就可以跳过了，因为针对该翻转次数的结果已经保存，
226         //无需再计算
227         if(step + nEstimate == m_nMaxSwap && flag1 == false);
228         else if(step + nEstimate >= m_nMaxSwap)
229             return false;
230 
231         //重新计算排好序的位置
232         int k = endBound;
233         while(k > 0 && k == m_ReverseCakeArray[k])
234             --k;
235 
236         // 如果k=0,说明已经排好序，即翻转完成，输出结果
237         //if(IsSorted(m_ReverseCakeArray, m_nCakeCnt))
238         if(k == 0)
239         {
240             if(step < m_nMaxSwap)
241             {
242                 //--当前找到的一个解
243                 m_nMaxSwap = step;
244                 for(i = 0; i < m_nMaxSwap; i++)
245                     m_SwapArray[i] = m_ReverseCakeArraySwap[i];
246             }
247             else if(step == m_nMaxSwap && flag1 == false)
248             {
249                 //--只有第一次碰到step == m_nMaxSwap时才做如下操作
250                 //--因为m_nMaxSwap可能是最小翻转次数，因此要记录此次结果
251                 //--后面再碰到相等时，可以忽略，因为不用重复保存结果
252                 for(i = 0; i < m_nMaxSwap; i++)
253                     m_SwapArray[i] = m_ReverseCakeArraySwap[i];
254                 flag1 = true;
255             }
256             return true;
257         }
258 
259         // 递归进行翻转,k之后已经排好序的位置就不用翻转了
260         std::vector<node> swapIndexScore;
261         //对翻转后的序列进行评估，评估它到排序好的序列之间的距离，优先搜索距离小的序列
262         for(i = 1; i <=k; i++)
263         {
264             struct node tnode;
265             tnode.index = i;
266             tnode.score = nEstimate;//原始序列的分数
267             //求翻转后的分数，翻转后只有翻转位置影响分数的大小
268             if(i != m_nCakeCnt - 1)
269             {
270                 if(abs(m_ReverseCakeArray[i] - m_ReverseCakeArray[i+1]) == 1)
271                     tnode.score++;
272                 if(abs(m_ReverseCakeArray[0] - m_ReverseCakeArray[i+1]) == 1)
273                     tnode.score--;
274             }
275             else
276             {
277                 if(m_ReverseCakeArray[i] == i)tnode.score++;
278                 if(m_ReverseCakeArray[0] == i)tnode.score--;
279             }
280             swapIndexScore.push_back(tnode);
281         }
282         //按照得分小到大排序，得分小的优先搜索
283         sort(swapIndexScore.begin(), swapIndexScore.end(),comp);
284 
285         for(i = 0; i < swapIndexScore.size() ; i++)
286         {
287             Revert(m_ReverseCakeArray, 0, swapIndexScore[i].index);
288             m_ReverseCakeArraySwap[step] = swapIndexScore[i].index;
289             bool isDone = Search(step + 1, k);
290             Revert(m_ReverseCakeArray, 0, swapIndexScore[i].index);
291             //如果该搜索序列有序，那么其他翻转方案肯定会导致无序，因此不需要搜索
292             if(isDone == true)break;
293         }
294 
295 //        for(i = 1; i <=k ; i++)
296 //        {
297 //            Revert(m_ReverseCakeArray, 0, i);
298 //            m_ReverseCakeArraySwap[step] = i;
299 //            Search(step + 1, k);
300 //            Revert(m_ReverseCakeArray, 0, i);
301 //        }
302         return false;
303     }
304     //
305     // true : 已经排好序
306     // false : 未排序
307     //
308     bool IsSorted(int* pCakeArray, int nCakeCnt)
309     {
310         for(int i = 1; i < nCakeCnt; i++)
311         {
312             if(pCakeArray[i-1] > pCakeArray[i])
313             {
314                 return false;
315             }
316         }
317         return true;
318     }
319 
320     //
321     // 翻转数组
322     //
323     void Revert(int arry[], int nBegin, int nEnd)
324     {
325         assert(nEnd > nBegin);
326         int i, j, t;
327 
328         // 翻转数组
329         for(i = nBegin, j = nEnd; i < j; i++, j--)
330         {
331             t = arry[i];
332             arry[i] = arry[j];
333             arry[j] = t;
334         }
335     }
336 
337 private:
338 
339     int* m_CakeArray;    // 烙饼信息数组
340     int m_nCakeCnt;    // 烙饼个数
341     int m_nMaxSwap;    // 最多交换次数。根据前面的推断，这里最多为
342     // m_nCakeCnt * 2
343     int* m_SwapArray;    // 交换结果数组
344 
345     int* m_ReverseCakeArray;    // 当前翻转烙饼信息数组
346     int* m_ReverseCakeArraySwap;    // 当前翻转烙饼交换结果数组
347     int m_nSearch;    // 当前搜索次数信息
348     bool flag1;//--当最开始计算的m_nMaxSwap是最小翻转次数时，若记录了这个翻转的
349                //结果,flag1 = ture，否则为false，详见search函数
350 };
351 
352 int main()
353 {
354     CPrefixSorting a;
355     int cakeArry[] = {3,2,1,6,5,4,9,8,7,0};
356     int cakeArry1[] = {12,3,2,1,11,6,5,10,4,9,8,7,0};
357     int cakeArry2[] = {2,0,1};
358     a.Run(cakeArry, sizeof(cakeArry) / sizeof(int));
359     a.Output();
360     a.Run(cakeArry1, sizeof(cakeArry1) / sizeof(int));
361     a.Output();
362     a.Run(cakeArry2, sizeof(cakeArry2) / sizeof(int));
363     a.Output();
364     return 0;
365 }

 

【版权声明】转载请注明出处 http://www.cnblogs.com/TenosDoIt/p/3250742.html

posted @ 2013-08-10 21:43  tenos  阅读(2727)  评论(4)  编辑  收藏  举报

本博客rss订阅地址: http://feed.cnblogs.com/blog/u/147990/rss

公益页面-寻找遗失儿童