hdnoip2017

T1：

小喵喵有 n 个小鱼干排成一列，其中第 i个小鱼干有两种属性，美味度 ai 和特殊度 bi

现在小喵喵要吃掉一些小鱼干，出于一些原因，小喵喵会吃掉连续的一段区间中的所有小鱼干。

如果吃掉了 [l,r]一段区间，那么小喵喵会获得一些满意度。

形式化地，总满意度 =(ai,l<=i<=r)×(1+bi,l<=i<=r)

由于只有小喵喵最喜欢的小鱼干的特殊度等于 11，所以 bi=1 的小鱼干数量不会超过 400个，其他的 bi=0

现在小喵喵可以选择任意一段区间（不能为空），但是有一些小鱼干的美味度是负数，吃掉所有小鱼干不一定会获得最多的满意度。所以小喵喵想知道最大能获得的总满意度是多少。

思路：

模拟+优化

首先可以想到n*n的模拟，但是复杂度过高于是我们想到：

可以在每个bi等于1的点预处理一个数组，表示这个点向左最大能延伸到多少

这样我们在枚举每个点的时候就只需要枚举在它之前有多少个bi为1的点就可以了

但是只是这样还是有问题的，如果最大值是不经过任何一个bi为1的点结果就是有问题的

所以我们需要再单独跑一遍判断

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<cstdlib>
 #include<set>
 #include<map>
 #include<vector>
 #include<stack>
 #include<queue>
 #define ll long long
 #define inf 2147383611
 #define MAXN 101010
 #define MOD
 using namespace std;
 inline ll read()
 {
     ll x=,f=;
     char ch;ch=getchar();
     while(!isdigit(ch)) {if(ch=='-') f=-;ch=getchar();}
     while(isdigit(ch)) {x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 ll n,a[MAXN],k[MAXN],cnt,sa[MAXN],b[MAXN],ans,m[MAXN],x;
 int main()
 {
     n=read();
     for(int i=;i<=n;i++) {a[i]=read();sa[i]=sa[i-]+a[i];}
     for(int i=;i<=n;i++) {x=read();b[i]=b[i-]+x;if(x) k[++cnt]=i;}
     k[]=,k[cnt+]=n+;
     //for(int i=1;i<=cnt+1;i++) cout<<i<<" "<<k[i]<<endl;
     ll tmp,_max;
     memset(m,-,sizeof(m));
     for(int i=;i<=cnt;i++)
     {
         tmp=,_max=a[k[i]];
         for(int j=k[i];j>k[i-];j--)
         {
             tmp+=a[j];
             if(tmp>=_max) {m[i]=j;_max=tmp;}
         }
     }
     //for(int i=1;i<=cnt;i++) cout<<m[i]<<endl;
     ll res;
     if(b[]) ans=sa[]*b[];
     else ans=sa[];
     for(int i=;i<=n;i++)
     {
         if(b[i]) ans=max(ans,sa[i]*b[i]);
         else ans=max(sa[i],ans);
         for(int j=b[i];j>=;j--)
         {
             ans=max(ans,(sa[i]-sa[m[j]-])*(b[i]-j+));
             //cout<<i<<" "<<j<<" "<<(sa[i]-sa[k[j]-1])*(b[i]-j+2)<<endl;
         }
     }
     for(int i=;i<=cnt+;i++)
     {
         tmp=-inf;
         for(int j=k[i-]+;j<k[i];j++)
         {
             if(tmp<&&a[j]<=) tmp=max(tmp,a[j]);
             if(tmp>=) tmp+=a[j];
             if(tmp<&&a[j]>) tmp=a[j];
             ans=max(ans,tmp);
             //cout<<i<<" "<<j<<" "<<tmp<<endl;
         }
     }
     printf("%lld",ans);
 }

T2：

绵羊送给小喵喵了 n 个小鱼干。小喵喵要把它们全部吃掉！

但是绵羊告诉小喵喵要按照某种顺序来吃。

绵羊一共说了 m 条限制，每条限制的格式为 u v，表示要先吃掉 u 号小鱼干之后才能吃 v 号小鱼干。

绵羊保证，这些条限制不会出现循环需求的情况，即一定存在某种顺序使得 n 个小鱼干都被吃掉。

绵羊还允许小喵喵不遵守其中小于等于 k 条限制。

小喵喵想知道在吃完所有的小鱼干的前提下，吃小鱼干的顺序的字典序最小是多少。

两个吃小鱼干的顺序的字典序大小比较即为：首先比较第一个吃的小鱼干，编号较小的字典序较小，若相同，则比较第二个吃的小鱼干，一直比到可以分出大小。

注意到两个顺序一定可以比较大小

思路：

几乎是裸的拓扑排序

只需要记录一下他的入度，判断它的入度是否小于k

即是否可以加到队列前面

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<cstdlib>
 #include<set>
 #include<map>
 #include<vector>
 #include<stack>
 #include<queue>
 #define ll long long
 #define inf 2147383611
 #define MAXN 152701
 #define MOD
 using namespace std;
 inline ll read()
 {
     ll x=,f=;
     char ch;ch=getchar();
     while(!isdigit(ch)) {if(ch=='-') f=-;ch=getchar();}
     while(isdigit(ch)) {x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int cnt,n,m,k,to[MAXN],first[MAXN],next[MAXN],in[MAXN];
 priority_queue <int,vector<int>,greater<int> > q;
 bool vis[MAXN],out[MAXN];
 void add(int u,int v) {in[v]++,next[++cnt]=first[u],first[u]=cnt,to[cnt]=v;}
 int main()
 {
     n=read(),m=read(),k=read();
     int a,b;
     while(m--) {a=read(),b=read();add(a,b);}
     for(int i=;i<=n;i++)
         if(in[i]<=k) {q.push(i);vis[i]=;}
     int pos,t;
     while(!q.empty())
     {
         pos=q.top();
         q.pop();
         vis[pos]=;
         if(in[pos]>k) continue;
         printf("%d ",pos);
         k-=in[pos],out[pos]=;
         for(int i=first[pos];i;i=next[i])
         {
             t=to[i];
             if(out[t]) continue;
             in[t]--;
             if(!vis[t]&&in[t]<=k) {q.push(t);vis[t]=;}
         }
     }
 }