8-3-COMPETITION

链接：8.3比赛

这次是动态规划里的LCS,LIS,LCIS专场.......

A.Common Subsequence

就是：给出两个字符串，求出其中的最长公共子序列的长度~LCS

代码：

 //memory:4276KB  time:109ms
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 using namespace std;

 int c[][];

 int maxx(int a,int b,int c)
 {
     if(b>a) a=b;
     if(c>a) a=c;
     return a;
 }

 int LCS_Lenght(string x,string y)
 {
     int m=x.length();
     int n=y.length();
     int i,j,v1,v2,v3;
     memset(c,,sizeof(c));
     for(i=;i<=m;i++)
         for(j=;j<=n;j++)
     {
         v3=c[i-][j-];
         if(x[i-]==y[j-]) v3=v3+;
         v2=c[i-][j];
         v1=c[i][j-];
         c[i][j]=maxx(v1,v2,v3);
     }
     return c[m][n];
 }

 int main()
 {
     string x,y;
     while(cin>>x>>y)
     {
         int p=LCS_Lenght(x,y);
         cout<<p<<endl;
     }
     return ;
 }

B.Palindrome

题意：给出一个字符串，求出它的最长上升子序列~LIS

如果表格直接用5001x5001的会超内存（在POJ上的内存开的很大，代码能过），因此就要进行优化......因为在表格上走的每一步只与与它左侧、上侧，左斜上侧的三个点有关，每一排的点只与上一排的点有关，因此在不要求回溯求出要求点的值时，可以只用2x5001的表格即可~

代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<string>
 using namespace std;

 int c[][],k;

 int maxx(int a,int b,int c)
 {
     if(b>a) a=b;
     if(c>a) a=c;
     return a;
 }

 int LCS_Lenght(string x)
 {
     int i,j,v1,v2,v3;
     memset(c,,sizeof(c));
     for(i=;i<=k;i++)
         for(j=;j<=k;j++)
     {
         v3=c[(i-)%][j-];                        //对二取余是重点~
         if(x[i-]==x[k-j]) v3=v3+;
         v2=c[(i-)%][j];
         v1=c[i%][j-];
         c[i%][j]=maxx(v1,v2,v3);
     }
     return c[k%][k];
 }

 int main()
 {
     string x;
     while(cin>>k)
     {
         cin>>x;
         int p=LCS_Lenght(x);
         cout<<k-p<<endl;
     }
     return ;
 }

//memory:344KB  time：687ms

C.魔法串

给出两个字符串a和b，并给出一些转换关系，看b是否能通过这些转换关系和删除字符得到a~

代码：

//打出一个转换表，看b中的字符是否能通过转换关系与a中的字符相等~

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 using namespace std;

 const int N = ;

 int main()
 {
     int cas,t;
     scanf("%d",&t);
     for(cas = ; cas<=t; cas++)
     {
         getchar();
         char s1[N],s2[N];
         int len1,len2;
         gets(s1);
         gets(s2);
         len1 = strlen(s1);
         len2 = strlen(s2);
         int n,i,j;
         int change[][] = {};
         scanf("%d",&n);
         for(i = ; i<n; i++)
         {
             char a,b;
             getchar();
             scanf("%c %c",&a,&b);
             change[a-'a'][b-'a'] = ;//打下一个转换表
         }
         j = ;
         int flag = ;
         for(i = ; i<len1; i++)
         {
             if(j == len2)
                 break;
             if(s1[i] == s2[j])       //相等继续
             {
                 j++;
                 continue;
             }
             while(s2[j]!=s1[i])
             {
                 if(j==len2)
                 {
                     flag = ;
                     break;
                 }
                 if(change[s2[j]-'a'][s1[i]-'a'] == )
                 {
                     j++;
                     break;
                 }
                 else
                     j++;
             }
         }
         printf("Case #%d: ",cas);
         if(!flag)
             printf("happy\n");
         else
             printf("unhappy\n");
     }
     return ;
 }

//memory:232KB  time:0ms

代码来自：http://blog.csdn.net/libin56842/article/details/8960511

方法二：

找最长公共子序列（LCS），在对应关系中略有改动~

代码：

 #include<iostream>
 #include<string>
 #include<cstring>
 using namespace std;
 int dp[][];
 bool has[][];
 int maxi(int x,int y)
 {
     if(x>y)
         return x;
     else return y;
 }
 int main()
 {
     int i,j,t,m,count=,len1,len2;
     char a,b;
     string str1,str2;
     cin>>t;
     while(t--)
     {
         count=count+;

         cin>>str1>>str2;
         len1=str1.length();
         len2=str2.length();
         memset(dp,,sizeof(dp));
         memset(has,,sizeof(has));
         cin>>m;
         for(j=;j<=m;j++)
         {
             cin>>a>>b;
             has[a][b]=;                    //记录对应关系~
         }
         cout<<"Case #"<<count<<": ";
         for(i=;i<=len1;i++)
             for(j=;j<=len2;j++)
             {
                 if(str1[i-]==str2[j-]||has[str2[j-]][str1[i-]]==)         //has[][]是看通过对应关系能否相等~
                     dp[i][j]=dp[i-][j-]+;
                 else dp[i][j]=maxi(dp[i-][j],dp[i][j-]);
             }

         if(dp[len1][len2]==len1)
             cout<<"happy"<<endl;
         else cout<<"unhappy"<<endl;
     }
     return ;
 }

//memory:4264KB  time:78ms

D.最少拦截系统

贪心算法：

找了段便于理解的解释就直接贴出来了。对于这个题目的测试例的解释：当8枚导弹依次飞来时，对于前三枚导弹（300，207，155），用第一套系统即可拦截，每一次更新记录，即：对第一枚导弹直接拦截，第二枚导弹来临时也用第一套系统拦截，记录改变成207，当用第一套系统拦截第三枚后记录修改为155，当第四枚导弹来时按照系统规定，第一套系统无法实现对第四枚导弹的拦截任务，因此，开第二套系统，为了使用最少系统，必须对以后的每一枚导弹贪心，即：拿这枚导弹和以前的导弹最小记录依次做比较，寻找一个和这枚导弹高度最接近的记录并用这枚导弹的高度替换原记录，最后记录数组中的个数就是最少需要的系统数。

代码：

#include<stdio.h>
#include<math.h>
int a[],b[];
int main()
{
       int n,i,j,k;
       while(scanf("%d",&n)!=EOF)
       {
             b[]=;k=;
             for(i=;i<n;i++)
             {
                   scanf("%d",&a[i]);
                   for(j=;j<=k;j++)
                   {
                          if(a[i]<b[j])
                          {
                                 b[j]=a[i];
                                 break;
                          }
                          else if(j==k)
                               {
                                     k++;
                                     b[k]=a[i];
                                     break;
                               }
                   }
              }
              printf("%d\n",k);
       }
       return ;
}

//memory：240KB   time：15ms

动态规划：

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int main()
{
    int t,a[],dp[],i,j,max;
    while(scanf("%d",&t)!=EOF)
    {
        for(i=;i<=t;i++)
            scanf("%d",&a[i]);
        memset(dp,,sizeof(dp));
        max=-;
        for(i=;i<=t;i++)
            for(j=i-;j>=;j--)
                if(a[i]>a[j] && dp[i]<dp[j]+)               //如果拦截中出现了非单调递减的高度~拦截系统就加1~
                    dp[i]=dp[j]+;
        for(i=;i<=t;i++)
            if(max<dp[i]) max=dp[i];
        printf("%d\n",max);
    }
    return ;
}

//memory：232KB  time：15ms

方法三：

通过对E题的思考，突然发现其实D题的本质与E题相同，同样可以用E题的方法一解出来~然后经过与同学的讨论......额~无论是求最长上升子序列还是最长下降子序列都可以用此方法（略微做一点变形）做出来~~~

代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;

 class Dolls
 {
 public:
     int x,id;
 }D[];

 int main()
 {
     int n;
     while(~scanf("%d",&n))
     {
         int i,minn;
         memset(D,,sizeof(D));
         for(i=;i<n;i++)
             scanf("%d",&D[i].x);
         int number=,j;
         for(i=;i<n;i++)
             if(D[i].id==)
             {
                 minn=D[i].x;
                 number++;
                 for(j=i+;j<n;j++)
                     if(D[j].x<minn && D[j].id==)
                     {
                         D[j].id=;
                         minn=D[j].x;
                     }
             }
         printf("%d\n",number);
     }
     return ;
 }

E.Nested Dolls

题意：有一堆俄罗斯套娃，把这些套娃全部套好，看最后会剩多少套娃~

方法一：

把所有套娃都按x(宽度)从大到小排好序【注：当宽度相等的时候，y(高度)小的排在前】，然后从第一个套娃开始看排在后的套娃能放进多少，能放进的都进行标记，并更新minn(能放进套娃的最大高度)；再找下一个未标记的套娃，重复操作，......直到没有未标记的套娃为止~操作了都少次，就剩下多少套娃~

代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;

 class Dolls
 {
 public:
     int x,y,id;
 }D[];

 bool comp(Dolls a,Dolls b)                //对套娃进行排序
 {
     if(a.x==b.x) return a.y<b.y;
     return a.x>b.x;
 }

 int main()
 {
     int t,n;
     scanf("%d",&t);
     while(t--)
     {
         int i,minn;
         scanf("%d",&n);
         memset(D,,sizeof(D));
         for(i=;i<n;i++)
             scanf("%d%d",&D[i].x,&D[i].y);
         sort(D,D+n,comp);
         int number=,j;
         for(i=;i<n;i++)
             if(D[i].id==)                 //找到未标记的套娃（即作为容器的最大套娃）
             {
                 minn=D[i].y;
                 number++;
                 for(j=i+;j<n;j++)
                     if(D[j].y<minn && D[j].id==)     //判断是否能够放进这个套娃
                     {
                         D[j].id=;                    //能放进进行标记
                         minn=D[j].y;                  //更新能放进套娃的最大高度
                     }
             }
         printf("%d\n",number);
     }
     return ;
 }

//memory: 464KB  time: 468ms

F.Greatest Common Increasing Subsequence

题意：看题目就知道，是求最长公共上升子序列~~~~

//题目有个略坑的地方，输出要空一行，最后一个输出又不要空.........不这样的话会PE......= =

代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 using namespace std;

 int main()
 {
     long t,n,m,a[],b[],len[],i,j,k,maxx;
     scanf("%ld",&t);
     while(t--)
     {
         scanf("%ld",&n);
         for(i=;i<=n;i++)
             scanf("%d",&a[i]);
         scanf("%ld",&m);
         for(i=;i<=m;i++)
             scanf("%ld",&b[i]);
         memset(len,,sizeof(len));
         for(i=;i<=n;i++)
         {
             k=;
             for(j=;j<=m;j++)
             {
                 if(a[i]>b[j] && len[j]>len[k])                  //len[j]代表的是b[j]处，得到的最长公共上升子序列的长度
                     k=j;                                        //len[k]代表的是在a[i]>b[j]时，所有的上升子序列中最长的一个~
                 if(a[i]==b[j])
                     len[j]=len[k]+;
             }
         }
         for(i=,maxx=;i<=m;i++)
             if(len[i]>maxx) maxx=len[i];                       //找出最长公共上升子序列的长度~~
         printf("%ld\n",maxx);
         if(t) printf("\n");
     }
     return ;
 }

//memory:228KB  time：0ms

G.吉哥系列故事――完美队形I

与F题其实很相似，代码原理上是相同的，只是略有改动~

代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 using namespace std;

 int main()
 {
     int t,n,a[],b[];
     scanf("%d",&t);
     while(t--)
     {
         int mxx,number=,i,j;
         scanf("%d",&n);
         memset(a,,sizeof(a));
         for(i=;i<n;i++)
             scanf("%d",&a[i]);
         memset(b,,sizeof(b));
         for(i=n-;i>=;i--)
         {
             mxx=;
             for(j=;j<=i;j++)
             {
                 if(a[j]<a[i])
                     mxx=mxx>b[j]?mxx:b[j];                    //mxx代表在a[j]<a[i]时最大的上升子序列的对数
                 else
                     if(a[j]==a[i])
                     b[j]=mxx+;
                     if(j<i && number<*b[j]) number=*b[j];
                 else
                     number=number>*b[j]-?number:*b[j]-;
             }
         }
         printf("%d\n",number);
     }
     return ;
 }

//memory:228KB  time:0ms