码迷,mamicode.com
首页 > 其他好文 > 详细

LIS问题---HDU1025 Constructing Roads In JGShining's Kingdom

时间:2014-08-15 20:50:19      阅读:364      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   color   使用   os   io   数据   

    发现这个说的比较通俗:

假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7,可以看出来它的LIS长度为5。
下面一步一步试着找出它。
我们定义一个序列B,然后令 i = 1 to 9 逐个考察这个序列。
此外,我们用一个变量Len来记录现在最长算到多少了
首先,把d[1]有序地放到B里,令B[1] = 2,就是说当只有1一个数字2的时候,长度为1的LIS的最小末尾是2。这时Len=1
然后,把d[2]有序地放到B里,令B[1] = 1,就是说长度为1的LIS的最小末尾是1,d[1]=2已经没用了,很容易理解吧。这时Len=1
接着,d[3] = 5,d[3]>B[1],所以令B[1+1]=B[2]=d[3]=5,就是说长度为2的LIS的最小末尾是5,很容易理解吧。这时候B[1..2] = 1, 5,Len=2
再来,d[4] = 3,它正好加在1,5之间,放在1的位置显然不合适,因为1小于3,长度为1的LIS最小末尾应该是1,这样很容易推知,长度为2的LIS最小末尾是3,
于是可以把5淘汰掉,这时候B[1..2] = 1, 3,Len = 2
继续,d[5] = 6,它在3后面,因为B[2] = 3, 而6在3后面,于是很容易可以推知B[3] = 6, 这时B[1..3] = 1, 3, 6,还是很容易理解吧? Len = 3 了噢。
第6个, d[6] = 4,你看它在3和6之间,于是我们就可以把6替换掉,得到B[3] = 4。B[1..3] = 1, 3, 4, Len继续等于3
第7个, d[7] = 8,它很大,比4大,嗯。于是B[4] = 8。Len变成4了
第8个, d[8] = 9,得到B[5] = 9,嗯。Len继续增大,到5了。
最后一个, d[9] = 7,它在B[3] = 4和B[4] = 8之间,所以我们知道,最新的B[4] =7,B[1..5] = 1, 3, 4, 7, 9,Len = 5。
于是我们知道了LIS的长度为5。
!!!!! 注意。这个1,3,4,7,9不是LIS,它只是存储的对应长度LIS的最小末尾。有了这个末尾,我们就可以一个一个地插入数据。虽然最后一个d[9] = 7更新进去对于这组数据没有什么意义,但是如果后面再出现两个数字 8 和 9,那么就可以把8更新到d[5], 9更新到d[6],得出LIS的长度为6。
然后应该发现一件事情了:在B中插入数据是有序的,而且是进行替换而不需要挪动——也就是说,我们可以使用二分查找,将每一个数字的插入时间优化到O(logN)~~~~~于是算法的时间复杂度就降低到了O(NlogN)~

  还有一个严格证明的,都很不错:

设  A[t]表示序列中的第t个数,F[t]表示从1到t这一段中以t结尾的最长上升子序列的长度,初始时设F [t] = 0(t = 1, 2,  ..., len(A))。则有动态规划方程:F[t] = max{1, F[j] + 1} (j = 1, 2, ..., t - 1,  且A[j] < A[t])。 

现在,我们仔细考虑计算F[t]时的情况。假设有两个元素A[x]和A[y],满足 (1)x < y < t             (2)A[x] < A[y] < A[t]             (3)F[x] = F[y]

此时,选择F[x]和选择F[y]都可以得到同样的F[t]值,那么,在最长上升子序列的这个位置中,应该选择A[x]还是应该选择A[y]呢?  

很明显,选择A[x]比选择A[y]要好。因为由于条件(2),在A[x+1] ...  A[t-1]这一段中,如果存在A[z],A[x] < A[z] < a[y],则与选择A[y]相比,将会得到更长的上升子序列。             再根据条件(3),我们会得到一个启示:根据F[]的值进行分类。对于F[]的每一个取值k,我们只需要保留满足F[t] =  k的所有A[t]中的最小值。设D[k]记录这个值,即D[k] = min{A[t]} (F[t] = k)。
            注意到D[]的两个特点: (1) D[k]的值是在整个计算过程中是单调不下降的。 (2) D[]的值是有序的,即D[1] < D[2] < D[3] < ... < D[n]。
            利  用D[],我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[t]与D[len]。若A  [t] > D[len],则将A[t]接在D[len]后将得到一个更长的上升子序列,len = len + 1, D[len] = A  [t];否则,在D[1]..D[len]中,找到最大的j,满足D[j] < A[t]。令k = j + 1,则有A [t] <=  D[k],将A[t]接在D[j]后将得到一个更长的上升子序列,更新D[k] = A[t]。最后,len即为所要求的最长上 升子序列的长度。
            在  上述算法中,若使用朴素的顺序查找在D[1]..D[len]查找,由于共有O(n)个元素需要计算,每次计算时的复杂度是O(n),则整个算法的  时间复杂度为O(n^2),与原来的算法相比没有任何进步。但是由于D[]的特点(2),我们在D[]中查找时,可以使用二分查找高效地完成,则整个算法 的时间复杂度下降为O(nlogn),有了非常显著的提高。需要注意的是,D[]在算法结束后记录的并不是一个符合题意的最长上升子序列!

bubuko.com,布布扣
 1 #include <iostream>
 2 using namespace std;
 3 int find(int *a,int len,int n)//若返回值为x,则a[x]>=n>a[x-1]
 4 {
 5     int left=0,right=len,mid=(left+right)/2;
 6     while(left<=right)
 7     {
 8         if(n>a[mid]) left=mid+1;
 9         else if(n<a[mid]) right=mid-1;
10         else return mid;
11         mid=(left+right)/2;
12     }
13     return left;  
14 }
15      
16 void fill(int *a,int n)
17 {
18     for(int i=0;i<=n;i++)
19         a[i]=1000;
20 }
21      
22 int main(void)
23 {
24     int max,i,j,n,a[100],b[100],c[100];
25     while(cin>>n)
26     {
27         fill(c,n+1);
28         for(i=0;i<n;i++)
29             cin>>a[i];
30         c[0]=-1;//     …………………………………1
31         c[1]=a[0];//         …………………………2
32         b[0]=1;//      …………………………………3
33         for(i=1;i<n;i++)//           ………………4
34         {
35             j=find(c,n+1,a[i]);//  …………………5
36             c[j]=a[i];// ………………………………6
37             b[i]=j;//……………………………………7
38         }
39         for(max=i=0;i<n;i++)// ………………………8
40             if(b[i]>max)
41                 max=b[i];
42        cout<<max<<endl;
43     }
44     return 0;
45 }&nbsp;
View Code

对于这段程序,我们可以用算法导论上的loop  invariants来帮助理解.          

       loop invariant : 

          1、每次循环结束后c都是单调递增的。(这一性质决定了可以用二分查找)    

                            2、每次循环后,c[i]总是保存长度为i的递增子序列的最末的元素,若长度为i的递增子序列有多个,刚保存末尾元素最小的那个.(这一性质决定是第3条性质成立的前提)                      3、每次循环完后,b[i]总是保存以a[i]结尾的最长递增子序列。   

     initialization:   

           1、进入循环之前,c[0]=-1,c[1]=a[0],c的其他元素均为1000,c是单调递增的;

                            2、进入循环之前,c[1]=a[0],保存了长度为1时的递增序列的最末的元素,且此时长度为1 的递增了序列只有一个,c[1]也是最小的;                                                                                   3、 进入循环之前,b[0]=1,此时以a[0]结尾的最长递增子序列的长度为1.  

      maintenance:    

           1、若在第n次循环之前c是单调递增的,则第n次循环时,c的值只在第6行发生变化,而由 c进入循环前单调递增及find函数的性质可知(见find的注释), 此时c[j+1]>c[j]>=a[i]>c[j-1],所以把c[j]的值更新为a[i]后,c[j+1]>c[j]> c[j-1]的性质仍然成 立,即c仍然是单调递增的;           

                    2、循环中,c的值只在第6行发生变化,由c[j]>=a[i]可知,c[j]更新为a[i]后,c[j]的值只会变  小不会变大,因为进入循环前c[j]的值是最小的,则循环中把c[j]更新为更小的a[i],当 然此时c[j]的值仍是最小的;                                      

         3、循环中,b[i]的值在第7行发生了变化,因为有loop  invariant的性质2,find函数返回值 为j有:c[j-1]<a[i]<=c[j],这说明c[j-1]是小于a[i]的,且以c[j-1]结尾的递增子序列有最大的 长度,即为j-1,把a[i]接在c[j-1]后可得到以a[i]结尾的最长递增子序列,长度为(j-1)+1=j; 

     termination:         

          循环完后,i=n-1,b[0],b[1],...,b[n-1]的值均已求出,即以a[0],a[1],...,a[n-1]结尾的最长递 增子序列的长度均已求出,再通过第8行的循环,即求出了整个数组的最长递增子序列。

    仔细分析上面的代码可以发现,每次循环结束后,假设已经求出c[1],c[2],c[3],...,c[len]的值,则此时最长递增子序列的长度为 len,因此可以把上面的代码更加简化,即可以不需要数组b来辅助存储,第8行的循环也可以省略。

 

bubuko.com,布布扣
 1 #include <iostream>
 2 #include <cstdio>
 3 
 4 using namespace std;
 5 
 6 int poor[500008],Update[500008];
 7 int main()
 8 {
 9     int a,b,n,len,high,low,mid,cal=1;
10     while(scanf("%d",&n)!=EOF)
11     {
12         for(int i=1;i<=n;i++) {scanf("%d%d",&a,&b);poor[a]=b;}
13         len=1;Update[1]=poor[1];
14         for(int i=1;i<=n;i++)
15         {
16             low=1;high=len;
17             while(low<=high)
18             {
19                 mid=(low+high)/2;
20                 if(Update[mid]>=poor[i]) high=mid-1;
21                 else low=mid+1;
22             }
23             Update[low]=poor[i];
24             if(low>len) len++;
25         }
26         printf("Case %d:\n",cal++);
27         if(len>1) printf("My king, at most %d roads can be built.\n\n",len);
28         else printf("My king, at most 1 road can be built.\n\n");
29     }
30     return 0;
31 }
View Code

 

LIS问题---HDU1025 Constructing Roads In JGShining's Kingdom,布布扣,bubuko.com

LIS问题---HDU1025 Constructing Roads In JGShining's Kingdom

标签:style   blog   http   color   使用   os   io   数据   

原文地址:http://www.cnblogs.com/Chinahenu/p/3915581.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!