【58测试】【贪心】【离散】【搜索】【LIS】【dp】

第一题 大天使之剑 大意：

　　有n个怪，每个怪的ph 为 h[i],有三种攻击方式，普通攻击：一次打一个怪一滴血；重击（消耗1魔法值）：一次打一个怪两滴血；群体攻击（消耗1魔法值）：一次打所有怪一滴血。你有无数血，m个魔法值，每攻击一次怪后，还存活的所有怪会各攻击你一滴血。问你打完所有怪你最少被打了多少滴血。

解：

　　看到这道题，首先想到的是搜索，一种一种的搜，把所有情况都搜出来找最小。在草稿纸上再列一些数据就会发现，其实是个贪心。在有魔法值的时候，尽量全用于群体攻击更划算，然后没有了就普通攻击。那重击呢？由于我的数据比较特殊，所以我判重击的条件是还剩两个偶数滴血的怪，但其实，不管它的血量是偶数还是奇数，重击都更划算。还有一些杂七杂八的减没减过sum的问题等，让我调试了一个下午。看来以后静态查错很重要，少犯小错误。代码写得丑。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define maxn 100005
 #define ll long long
 using namespace std;
 ll n,m,ph[maxn],ans,sum,cur=;
 bool jian[maxn];
 void print()
 {
     printf("%I64d",ans);
     return ;
 }
 int main()
 {
     freopen("zhijian.in","r",stdin);
     freopen("zhijian.out","w",stdout);
     cin>>n>>m;
     for (int i=;i<=n;i++)
       scanf("%d",&ph[i]);
     sort(ph+,ph++n);
     while (m)
     {
         if (n-cur+<=){//改用重击
             for (int i=cur;i<=n;i++)
              if (!jian[i]) ph[i]-=sum;
             while(m){
                 if (cur>n)     {
                     print();return ;
                 }
                 if (ph[cur]<=){
                     ans+=n-cur;
                     cur++;continue;
                 }
                 ph[cur]-=;
                 ans+=n-cur+;
                 m--;
             }
             while (cur<=n){
                 if (ph[cur]){
                     int ci=ph[cur]-;
                     ans+=(n-cur+)*ci;
                 }
                 ans+=n-cur;
                 cur++;
             }
             print();
             return ;
         }
         sum++;
         ph[cur]--;int h=cur;
         jian[cur]=true;
         ans+=n-cur+;
         while (ph[cur]<=){
             ans--;
             cur++;
             ph[cur]-=sum;
             jian[cur]=true;//判断
         }
         m--;
     }
     while (cur<=n){
         if (!jian[cur]) ph[cur]-=sum;//直接减会多减
         if (ph[cur]){
             int ci=ph[cur]-;
             ans+=(n-cur+)*ci;
         }
         ans+=n-cur;
         cur++;
     }
     printf("%I64d",ans);
     return ;
 }

第二题 保卫萝卜 大意：

　　一个很大的矩阵，起点在正中心的方格。数据有向上下左右四个方向走的记录，输出走过的方格及所围的方格数。

解：

　　有两种大体思路。一个是直接正着算面积，还有反着算走不到的点。我用的后者。但有一个问题，就是存矩阵。我把它走过的地方的最左边上面下面和右边记录下来，然后在这个包含它走的所有路的方格中从0,0开始遍历dfs，到不了的地方vis=false，即为ans++。注意要在搜索范围中再加一圈，因为可能走过的路把这个范围隔开了，就搜索不到。但这是60分的做法，100分做法要用离散化坐标的思想，先放一下。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define maxn 2005
 using namespace std;
 const int zl[][]={{,,,-},{,-,,}};
 int n,xi,yi,idx,sum,ans;
 bool mp[maxn][maxn],vis[maxn][maxn];
 int uup,don,le,ri,stx,sty;
 struct pp{
     int x,y;
 };
 pp tur[];
 char c[];
 void dfs(int xx,int yy)
 {
     for (int i=;i<=;i++)
     {
         int ki=xx+zl[][i],kj=yy+zl[][i];
         if (ki>=&&kj>=&&ki<=ri&&kj<=uup&&!vis[ki][kj]&&!mp[ki][kj])
         {
             vis[ki][kj]=true;
             sum++;dfs(ki,kj);
         }
     }
 }
 int main()
 {
     freopen("luobo.in","r",stdin);
     freopen("luobo.out","w",stdout);
     cin>>n;
     getchar();
     for (int i=;i<=n;i++)
     {
         c[i]=getchar();
         getchar();int a;
         scanf("%d",&a);
         if (c[i]=='L') {stx-=a;if (stx<le) le=stx;}
         else if (c[i]=='R'){stx+=a;if (stx>ri) ri=stx;}
         else if (c[i]=='U') {sty+=a;if (sty>uup) uup=sty;}
         else if (c[i]=='D'){sty-=a;if (sty<don) don=sty;}
         tur[++idx].x=stx;tur[idx].y=sty;
         getchar();
     }
     xi=-le+;yi=-don+;uup+=-don+;ri+=-le+;
     mp[xi][yi]=true;
     for (int i=;i<=idx;i++)
     {
         tur[i].x+=-le+;tur[i].y+=-don+;
         int a=min(xi,tur[i].x),b=max(xi,tur[i].x),ci=min(yi,tur[i].y),d=max(yi,tur[i].y);
         for (int j=a;j<=b;j++)
           for (int k=ci;k<=d;k++)
             mp[j][k]=true;
         xi=tur[i].x;yi=tur[i].y;
     }
     dfs(,);
     for (int i=;i<=ri;i++)
       for (int j=;j<=uup;j++)
         if (!vis[i][j]) ans++;
     printf("%d",ans);
     return ;
 }

第三题 打地鼠 大意：

　　（没错怎么都是游戏的名字）打地鼠，打的这个地鼠的肥胖值一定要比上一个打的大。地鼠最多出现t次，问最多能打多少地鼠。

解：

　　看起来是个简单的最长上升序列。但是有一个t次，所以直接扫描加一个循环t就可以了，是不影响的。然后LIS 的nlogn的算法才能过这道题。具体的解释我觉得这个博客讲的就很清楚。http://blog.csdn.net/shuangde800/article/details/7474903

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define maxn 100005
 using namespace std;
 int n,maxx,k,t,a[maxn],d[maxn],ans;
 int main()
 {
     freopen("dishu.in","r",stdin);
     freopen("dishu.out","w",stdout);
     cin>>k>>n>>maxx>>t;
     while (k--)
     {
         memset(d,,sizeof(d));
         int idx;ans=;
         for (int i=;i<=n;i++)
           scanf("%d",&a[i]);
         d[]=a[];ans=;
         for(int i=;i<=t;i++)
           for (int j=;j<=n;j++)
           {
               if (a[j]>d[ans]) d[++ans]=a[j];
               else {
                   int pos=lower_bound(d+,d++ans,a[j])-d;//-d not -d-1 ?
                   d[pos]=a[j];
               }
           }
           printf("%d\n",ans);
     }
     return ;
 }

好好睡一觉，明天联考加油，不要有压力。