HZOJ 20190819 NOIP模拟26题解

考试过程：

照例开题，然后觉得三道题都挺难，比昨天难多了（flag×1），T1 dp？T2 数据结构？ T3 dp？事实证明我是sb然后决定先搞T2，但是，woc，这题在说什么啊，我怎么看不懂题啊，连样例都手模不出来，完了凉了，然后又看了一个半小时的题，还是没看懂心态爆炸，然后匆匆打了T1T3暴力，还自我感觉良好，觉得这么难的题，拿个150pts左右应该rank10没啥问题叭，然后出分，T1T2A了一片，然后我还暴力挂分，然后在第二机房成功倒数。

反思：

还是思考的太少啊，对题目的难度评估出现很大偏差，考试时还有时走思，这布星啊，这状态真tm差

题解：

T1 嚎叫响彻在贪婪的厂房：

其实很简单，用STL可以过掉（map或set都行，主要作用还是判重），比较显然的贪心，就是能不断就不断，感性理解一下即可，证明也挺简单的叭我就不证了我才不会说是我不会证呢考场上想到这个了，但是还是sb的打了dp，真zz啊，改了STL就能过啊。STL这些东西还是要学的啊很好用的啊

 #include<bits/stdc++.h>
 using namespace std;
 const int N=1e5+;
 map<int,int> mp;
 int a[N];
 int gcd(int a,int b){return b?gcd(b,a%b):a;}
 int main(){
     int n;
     scanf("%d",&n);
     for(int i=;i<=n;++i) scanf("%d",&a[i]);
     int ans=;int l=;
     while(l<=n){
         int r=l+;
         int k=abs(a[r]-a[l]);
         mp[a[l]]=;
         while((r<=n)&&(gcd(abs(a[r]-a[l]),k)!=)&&(mp.count(a[r])==)){
             mp[a[r]]=;
             r++;
             k=gcd(abs(a[r]-a[l]),k);
         }
         r--;l=r+;ans++;mp.clear();
     }
     printf("%d",ans);
 }

T1

T2 主仆见证了 Hobo 的离别：

考试时根本没看懂题，浪费一个半小时，然后就成功爆零滚粗，思博出题人语文比我还差啊艹

实际上这题只要，建边跑个dfs序，然后判一下k==1建双向边即可。实际上因为数据水直接在线dfs理论复杂度$O(n^2)$就可以水过于是旁边zkt大佬就hack别人AC代码hack了一下午233

 #include<bits/stdc++.h>
 using namespace std;
 const int N=;
 int first[N],nex[N<<],to[N<<],tot,fr[N];
 int fa[N];
 int judge;
 void add(int a,int b){
     to[++tot]=b,nex[tot]=first[a],first[a]=tot;fr[tot]=a;
 }
 void dfs(int x,int fa,const int tar){//cout<<x<<" "<<endl;
     if(x==tar) {judge=;return ;}
     for(int i=first[x];i;i=nex[i]){
         int y=to[i];
         if(y==fa) continue;

         dfs(y,x,tar);
     }
 }
 int main(){
     int n,m;
     scanf("%d%d",&n,&m);
     int qsum=;
     for(int i=;i<=m;++i){
         int opt;
         scanf("%d",&opt);
         if(opt==){
             int op,kk;n++;
             scanf("%d%d",&op,&kk);
             for(int j=;j<=kk;++j){//cout<<id<<endl;
                 int x;
                 scanf("%d",&x);
                 if(kk==){
                     fa[n]=x,fa[x]=n;
                     add(n,x);add(x,n);
                     break;
                 }
                 if(op)  {add(x,n);fa[x]=n;}
                 else    {add(n,x);fa[n]=x;}
             }
         }
         else{
             judge=;
             int a,b;
             scanf("%d%d",&a,&b);
             dfs(a,,b);//cout<<"M"<<endl;
             printf("%d\n",judge);
         }
     }
 }

T2

T3 征途堆积出友情的永恒：

其实是比较有难度的题，但是50pts暴力和30pts骗分很好打，我明明打对了骗分还是没分啊艹

正解是堆优化dp，首先考虑暴力转移式子$f[i]=min（f[j]+max（sum[i]-sum[j],b[j]））$

我们注意到对于固定的$j$,$f[j]-sum[j]$和$f[j]+b[j]$是固定不变的，所以考虑从这两个量入手，因为我们每次只要最小的，所以用两个堆分别维护一下就好了，具体实现方法是，首先要把两个堆中不满足距离小于k的点pop掉，然后把第一个堆中小于第二个堆顶$+sum[i]$ 的点pop掉并加入第二个堆中，直到符合条件为止，再把不满足距离小于k的点pop掉，最后在更新f数组即可

感觉优化dp的题做起来还是很无力啊

看博客看到的whs dalao的dp优化总结还是挺好的，就放过来了

总结：

1.对于这种dp优化，若dp式子中出现变量很少而定量很多，就要考虑到维护定量;

2.而对于dp式子中有max（），min（）之类的，说明主动决策决定被动决策;所以考虑维护两个决策中较容易维护的一方;然后让另一方成为被动;若遇到维护的值不再偏向于己方;

那就把这种状态pop掉，转换成另一方;让这种状态继续合法;对答案做贡献;

3.注意2中max的决策单调性;例如这个题中max有单调性，就可以无后效性的转化;

原文

 #include<bits/stdc++.h>
 #define int long long
 using namespace std;
 const int N=;
 const int INF=1e9+;
 int a[N],b[N],sum[N],dp[N],n,k;
 int f[N];
 struct node{
   int id,val;
   bool operator < (const node a) const{
       return val>a.val;
   }
 };
 priority_queue<node>q1,q2;
 int min(int a,int b){return a<b?a:b;}
 int max(int a,int b){return a>b?a:b;}
 void work_2(){
   memset(f,0x3f,sizeof(f));f[]=;
   //q1.push(dp[1]);q2.push(dp[1]+b[1]);
   //q1.push((node){0,0}),q2.push((node){0,0});
   //q1.push((node){0,INF}),q2.push((node){0,INF});
   for(int i=;i<=n;++i){
           q1.push((node){i-,f[i-]+b[i-]});
           //q2.push((node){i-1,f[i-1]-sum[i-1]});
           while(q1.size()){
               int x=q1.top().id;
               if(x>=i-k) break;
               q1.pop();
           }//cout<<"L"<<endl;
           while(q2.size()){
               int h=q2.top().id;
               if(h>=i-k) break;
               q2.pop();
           }
           while(q1.size()){
               int y=q1.top().val;
               int x=q1.top().id;
               if(y>f[x]-sum[x]+sum[i]) break;
               q1.pop();
               q2.push((node){x,f[x]-sum[x]});
           }//cout<<"M"<<endl;
           while(q1.size()){
               int x=q1.top().id;
               if(x>=i-k) break;
               q1.pop();
           }//cout<<"K"<<endl;
           while(q2.size()){
               int h=q2.top().id;
               if(h>=i-k) break;
               q2.pop();
           }
           if(q1.size()) f[i]=min(f[i],q1.top().val);
           if(q2.size()) f[i]=min(q2.top().val+sum[i],f[i]);
           //f[i]=min(q1.top().val,q2.top().val+sum[i]);
           //cout<<f[i]<<endl;
       }
   cout<<f[n]<<endl;
 }
 signed main(){
   scanf("%lld%lld",&n,&k);
   for(int i=;i<=n;++i) {scanf("%lld",&a[i]);sum[i]=sum[i-]+a[i];}
   for(int i=;i<n;++i) {scanf("%lld",&b[i]);}
   work_2();
 }

T3