ACM ICPC 2018 青岛赛区部分金牌题题解(K,L,I,G)

目录：

K Airdrop

I Soldier Game

L Sub-cycle Graph

G Repair the Artwork

————————————————————

ps：楼主脑残有点严重，很容易写错别字和语言组织混乱，如果在读文章时遇到，可以在评论区里回复一下，我好改（花式骗评论）

补题地址：http://acm.zju.edu.cn/onlinejudge/showProblems.do?contestId=1&pageNumber=31

顺便好人做到底，给大家凑个11/13的题解出来。(据说A题题解某个大佬是有写的，但是我找不到，有没有好心人告诉我一下)

B：https://www.cnblogs.com/xseventh/p/9986194.html（摸鱼的队员终于把B题补掉了，dsu on tree）

C：https://blog.csdn.net/lzyws739307453/article/details/83932183 （分类讨论）

D：https://blog.csdn.net/LSD20164388/article/details/83893264(枚举+讨巧)

E：https://blog.csdn.net/Code92007/article/details/83932020（二分+贪心）

F：http://www.cnblogs.com/qq965921539/p/9905086.html (构造题)

J ：https://blog.csdn.net/Code92007/article/details/83930044（贪心）

M：傻逼签到题，递归到1时判奇偶就行了

____________________________

K Airdrop

虽然K题现场过的比较少，但实际上是一个排个序 ,按顺序枚举x0,大力数数的垃圾题，只是现场榜歪没人看而已。emmmm,根据重现的结果，可能k确实有一点难度，这里给一下提示，首先这个人啊，是优先先动y，再动x的，所以不和x=x0在同一条线上的点，只要与(x0,y0)的曼哈顿距离相同就有可能会撞。因此我们要在(x0,y0)的左右两边分别数每种曼哈顿距离出现的次数。显然左右的是可以拆开数，所以我们先把所有x0左侧曼哈顿距离相同的点的数量数完，在数右边，最后在数一下多少个点的x=x0就行，如果你有注意到题目有说所有点的初始位置是不一样的，可能会好写很多。

　　现在以数左边曼哈顿距离相同的点的数量为例，首先要注意到什么情况下曼哈顿距离相同点并不会抵消掉而是会留下一个，这里举个栗子，当有三个点对于(x0,y0)的曼哈顿距离相同时，万一有两个因为比较早相遇而挂掉，则最后一个人就能活到空投那里。解决办法也简单，注意到，他们只能在y=y0这条直线上相遇，早相遇的点，他们相遇的x也比较小，只要在从左往右枚举x0的过程中，顺便把在上个x0的相撞死的人对于的数量贡献去掉就好了。再维护一下当前有多少个曼哈顿距离只出现了1次，只出现一次的点都是能活着到空投的。

最后的最后，在教一下怎么数量，因为对于不同的x0,y0所有点的曼哈顿距离都在变的，我们不能每次重新数所有距离出现的次数。但是对于在(x0,y0)左侧点，如果他们对于(x0,y0)曼哈顿距离相同，随着(x0,y0)右移他们还是会相同的，所以干脆直接数他们到(xm,y0)的曼哈顿距离就行了，xm为x0坐标的最大值。他们到(xm,y0)距离相同的话，则这些点到任意他们的右侧(x0,y0)距离也肯定相同。

 #include<stdio.h>

 #include<math.h>

 #include<string.h>

 #include<stdlib.h>

 #include<vector>

 #include<algorithm>

 using namespace std;

 int const maxn=2e5+;

 int x[];

 int y[];

 vector<int>e[maxn],q,que,res;

 int sum[];

 int num[];

 void clear(int n,int x0,int y0)

 {

     for(int i=;i<=n;i++)

     {

         num[abs(x0-x[i])+abs(y0-y[i])]=;

     }

 }

 int main()

 {

     int i,j,n,m,w,t,y0,xm=1e5+,k;

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d",&n,&y0);

         q.clear();

         q.push_back();

        // e[0].clear();

         for(i=;i<=n;i++)

         {

             scanf("%d%d",&x[i],&y[i]);

             e[x[i]].clear();

             e[x[i]+].clear();

            // e[x[i]-1].clear();

             q.push_back(x[i]);

             q.push_back(x[i]+);

           //  q.push_back(x[i]-1);

         }

         sort(q.begin(),q.end());

         q.erase(unique(q.begin(),q.end()),q.end());

         for(i=;i<=n;i++)

         {

             e[x[i]].push_back(y[i]);

         }

         int ans=,temp=;

         clear(n,xm,y0);

         for(int xx:q)

         {

             sum[xx]=e[xx].size();

             if(temp)

             {

                 que.clear();

                 for(int yy:e[temp])

                 {

                     k=abs(yy-y0)+abs(xm-temp);

                     num[k]++;

                     if(num[k]==)

                     {

                         ans++;

                     }

                     else

                     {

                         que.push_back(k);

                     }

                 }

                 for(int pos:que)

                 {

                     if(num[pos])

                         ans--;

                     num[pos]=;

                 }

             }

             temp=xx;

             sum[xx]+=ans;

            // printf("(%d %d)\n",xx,sum[xx]);

         }

         reverse(q.begin(),q.end());

         ans=,temp=;

         clear(n,,y0);

         res.clear();

         for(int xx:q)

         {

             if(temp)

             {

                 que.clear();

                 for(int yy:e[temp])

                 {

                     k=abs(yy-y0)+abs(-temp);

                     num[k]++;

                     if(num[k]==)

                     {

                         ans++;

                     }

                     else

                     {

                         que.push_back(k);

                     }

                 }

                 for(int pos:que)

                 {

                     if(num[pos])

                         ans--;

                     num[pos]=;

                 }

             }

             temp=xx;

             sum[xx]+=ans;

             res.push_back(sum[xx]);

             //printf("(%d %d %d)\n",xx,sum[xx],ans);

         }

         sort(res.begin(),res.end());

         printf("%d %d\n",res.front(),res.back());

     }

     return ;

 }

I Soldier Game

　　这题两种写法，一种是枚举最小值+线段树单点更新维护可行最大值。另一种是dp (神仙知道怎么写，我不知道)。这题思路还是比较复杂了，然后HDU的CSY巨巨现场一眼标算，果然神仙和凡人是不能比的。

当我问群巨怎么做时，他们只给我“枚举最小值+线段树维护可行最大值“，这几个关键字，我百思不得其解，终于想了几天后顿悟了。o(╥﹏╥)o

　　首先。我们考虑一个动态规划问题：给出a个长度为1的区间和b个长度为2区间，每个区间都有权重。从中取出若干个不相交的区间，在满足覆盖满[1,n]情况下，使得【权重最大的区间】的权重最小，要怎么做。

一个显然的想法：令dp[i]代表覆盖满[1,i]的所有方案中，权重的最大值最小为多少。然后按左端点从小到大枚举区间，进行状态转移就行了，复杂度O(a+b)。

　　然后现在我就可以得到I题的一个O(n^2)写法了，具体做法是这样的：

　　我们把n个长度为1的区间和n-1长度为2的区间按权值排序 ->枚举最小值 -> 将权值小于最小值的区间删去 ->

-> 然后对剩下的区间做dp，求出可行的【最小的最大值】,计算最大值和当前枚举的最小值之差，并更新答案。

　　上面那个做法虽然不够优越，但是已经为正确的做法已经铺好了路，因为上面涉及到一个线性dp的单点修改后在查询，套个老掉牙线段树维护dp值不就可以在log(n)的时间内查询到修改后的值了吗。

所以现在我们就有了个nlog(n)做法，核心在于怎么把dp挂到线段树上。不过说起来容易做起来难，因为你发现如果你要搬到线段树上要维护一坨东西才行，

不过核心思想并不复杂，只是枚举一下树上孩子合并时是否有区间跨过两个孩子就行了，合并操作的具体代码长这样

 struct Node

 {

     ///m代表中间，l代表左，r代表右

     int rl;

     int m;///只包含中间，不包含区间的左右端点

     int mr;///包含中右

     int lm;///包含左中

     int lmr;///包含左中右

     int set(int i)

     {

         rl=a[i][];

         lm=mr=-INF;

         lmr=a[i][];

         m=INF;

     }

     inline Node operator+(const Node &b)const

     {

         Node ans;

         ans.m=min(max(mr,b.lm),max(max(m,rl),b.m));

         ans.lm=min(max(lmr,b.lm),max(max(lm,rl),b.m));

         ans.mr=min(max(mr,b.lmr),max(max(m,rl),b.mr));

         ans.lmr=min(max(lmr,b.lmr),max(max(lm,rl),b.mr));

         ans.rl=b.rl;

         return ans;

     }

 };

有没有被吓到，不过努力思考一下应该还是看得懂的。

完整的AC代码如下（我删掉一个区间的方法，是把这个区间权值赋值成无穷大，这样对答案就没有贡献了，话说我居然是跑得最快的╰(*°▽°*)╯）：

 #include<stdio.h>

 #include<string.h>

 #include<algorithm>

 #include<math.h>

 using namespace std;

 typedef long long ll;

 #define N 280000

 int a[][];

 const int INF=(<<)-;

 struct Node

 {

     ///m代表中间，l代表左，r代表右

     int rl;

     int m;///只包含中间，不包含区间的左右端点

     int mr;///包含中右

     int lm;///包含左中

     int lmr;///包含左中右

     int set(int i)

     {

         rl=a[i][];

         lm=mr=-INF;

         lmr=a[i][];

         m=INF;

     }

     inline Node operator+(const Node &b)const

     {

         Node ans;

         ans.m=min(max(mr,b.lm),max(max(m,rl),b.m));

         ans.lm=min(max(lmr,b.lm),max(max(lm,rl),b.m));

         ans.mr=min(max(mr,b.lmr),max(max(m,rl),b.mr));

         ans.lmr=min(max(lmr,b.lmr),max(max(lm,rl),b.mr));

         ans.rl=b.rl;

         return ans;

     }

 };

 const int MAXN=;

 struct  Segment_tree

 {

     int size;

     Node node[MAXN];

     void update(int pos)

     {

         node[pos]=node[pos+pos]+node[pos+pos+];

     }

     void build(int n)///申请空间

     {

         size=;

         while(size<n)///计算几个刚好能套住整个区间的区间容量

             size<<=;///size=size*2

        // printf("size=%d\n",size);

     }

     void build(int n,int flag)///申请空间，并建树

     {

         build(n);

         int i;

         for(i=n; i<size; i++)

         {

             a[i][]=-INF;

             a[i][]=INF;

         }

         for(i=; i<size; i++)

         {

             node[size+i].set(i);

         }

         for(i=size-; i>; i--)

         {

             update(i);///数值从低到高更新上去

         }

     }

     void change(int x)

     {

         x+=size;

         node[x].set(x-size);

         while(x>)

         {

            // printf("[%d]\n",x);

             x>>=;

             update(x);

         }

     }

     void put()

     {

         int i=,j=,s=size*,k,len=;

         for(i=; i<=*size-; i++)

         {

             if(i==j)

             {

                 puts("");

                 j<<=;

                 s>>=;

                 for(k=; k<len*(s/-); k++)

                     printf(" ");

             }

             printf("%3d",node[i].lmr);

             for(k=; k<len*(s-); k++)

                 printf(" ");

         }

         puts("");

     }

 } tree;

 typedef pair<int,int> PI;

 PI b[];

 int cmp(const PI &x,const PI &y)

 {

     return a[x.first][x.second]<a[y.first][y.second];

 }

 int main()

 {

     int n,m,t,i;

     //freopen("1.in","r",stdin);

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d",&n);

         int top=;

         for(i=; i<n; i++)

         {

             scanf("%d",&a[i][]);

             b[top++]=make_pair(i,);

             if(i>)

             {

                 a[i-][]=a[i-][]+a[i][];

                 b[top++]=make_pair(i-,);

             }

         }

         a[n-][]=INF;

         sort(b,b+top,cmp);

         tree.build(n,);

         int j=;

         int mn;

         long long ans=INF*2LL;

         for(i=; i<top;)

         {

             mn=a[b[i].first][b[i].second];

            // printf("i=%d\n",i);

             if(tree.node[].lmr==INF)

             {

                 break;

             }

             ans=min(ans,tree.node[].lmr-(long long)mn);

             while(j<top&&a[b[j].first][b[j].second]<=mn)

             {

                 a[b[j].first][b[j].second]=INF;

                 tree.change(b[j].first);

                 j++;

             }

             i=j;

         }

         printf("%lld\n",ans);

     }

     return ;

 }

L Sub-cycle Graph

　　好吧,这是一个比较傻吊的组合数学题，但是现场的时候看错条件了，越想越复杂_(¦3」∠)_。

题意是问有多少种n个点m条边的图，是一个连通简单环图的子图。

首先因为是连通简单环图，所以母图必须只有一个简单环且连通所有结点，在断掉一些边后，必然会变成n-m条链的组合。

现在我们先来考虑一个比较简单的问题:n个结点组成一条链有多少种本质不同的方案

显然这个数列的前n项是1,1,3,12,……,n!/2。

写成Σai/(i!) x^i 的指数型生成函数的话（什么你不会指数型生成函数，那还不赶紧去学），就是

aaarticlea/jpeg;base64,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" alt="" />

则组成k条链的指数型生成函数就是

则题目想要的答案就是b_n/k!。为啥除k! ? 因为我们的答案是不考虑这k条链出现的先后顺序的。

　然后开始FFT?, 答案是NO!

上面那个多项式我们并不需要真的做多项式的幂运算。首先上面的式子可以拆成这样。

其中

可以用二项式系数直接展开。

而

是一个特殊的多项式，与这个多项式做卷积相当于对系数求前缀和。

乘k次，就相当于求k次前缀和，求k次前缀和的第m项，想必现在是个人都应该会了。

所以到此题目就做完了，算法复杂度O(m)

 #include<stdio.h>

 #include<algorithm>

 using namespace std;

 #define ll long long

 ll fac[],ifac[];

 const ll mod=1e9+,inv2=(mod+)/;

 ll C(int n,int m)

 {

     if(m>n)

         return ;

     return fac[n]*ifac[m]%mod*ifac[n-m]%mod;

 }

 int main()

 {

     int n=1e5+,m,t,i,j,k;

     ifac[]=;

     ifac[]=;

     for(i=; i<=n; i++)

     {

         ifac[i]=(mod-mod/i)*ifac[mod%i]%mod;

     }

     fac[]=;

     for(i=; i<=n; i++)

     {

         fac[i]=fac[i-]*i%mod;

         ifac[i]=ifac[i-]*ifac[i]%mod;

     }

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d",&n,&m);

         if(m>n)

         {

             puts("");

         }

         else if(m==n)

         {

             printf("%lld\n",fac[n-]*inv2%mod);

         }

         else

         {

             ll ans=,temp=;

             k=n-m;

             for(i=;i<=m;i++)

             {

               //  printf("[%d %d],%d\n",k,m-i,C(k+(m-i)-1,m-i));

                 ans+=C(k,i)*temp%mod*C(k+(m-i)-,m-i)%mod;

                 ans%=mod;

                 temp=temp*-inv2%mod;

                 if(temp<)

                     temp+=mod;

             }

             printf("%lld\n",ans%mod*fac[n]%mod*ifac[k]%mod);

         }

     }

     return ;

 }

G Repair the Artwork

问题1：

只有0和1情况方案数怎么计算？

在只有0,1的时候，可行方案数显然【可选的区间数】^m

问题2：

只有2的情况方案数怎么计算：

为了方便表示，我们约定一下记号（不然说起来会像绕口令）

如果一个位置上的2被当做1用(即一定不覆盖这个位置)我们把用×表示这个2，
如果一个位置上的2被当做0用(即这个位置可能被覆盖，也可能没有被覆盖)我们把用O表示这个2。
如果一个位置上的2一定被覆盖用Θ表示，
{??……？} 表示每个2满足??……？约束情况下的方案数。

现在我们来推导一下只有两个2时方案数怎么计算

则我们要求的答案{ΘΘ}，随便容斥一下就可展开成如下形式：

aaarticlea/jpeg;base64,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" alt="" />

（注：如果你实在看不懂，我再解释一下，{OΘ}可以拆成第一个位置【一定被被覆盖】和【一定不被覆盖】两种情况，所以就有了{OΘ}={ΘΘ}+{×Θ} =>{ΘΘ}={OΘ}-{×Θ}. 接着同理对剩下的Θ，用相同的方式展开掉就行了。}

这样就转化为只有01的形式，然后用问题的1方式就能计算了，到这问题就解决了吗？然而还有一些计算上的细节问题要解决。

　　所以我们继续尝试计算{ΘΘΘ}，来说明这个问题

经过一番费力的展开，你会得到{ΘΘΘ}={OOO} - {OO×} - {O×O} + {O××} - {×OO} + {×O×} + {××O} -{×××} .

你观察一下就会发现，实际上发现，其实就是

其中r(A1,A2,A3) 为A1,A2,A3中x的个数。说白就是类似多项式(1+(-x))^m 的展开形式。

在这里我们有两个重要的结论：

结论一：答案一定能表示如下形式(因为任意一个{A1,A2,A3}肯定是x^m 形式)。

结论二：暴力枚举情况，要枚举2^n种可能，所以暴力是不可行的

问题3：在只有2的情况下，怎么在多项式时间里计算n个2的方案数？

　　根据问题2的结论1，对dp初步方案是用dp[i][j],代表{i个Θ}中 j^m的系数。然后答案就是Σdp[i][j]* j^m，

然后来考虑一下转移：{i个Θ}={(i-1个Θ) +O}-{i-1个Θ) +×}。

你自行思考一下就会发现，这个{ (i-1个Θ) +×} 不就是等于{i-1个Θ} 吗？因为这个尾巴上的×，对可选区间数莫有虾米贡献，(因为x是不能选的，挂不挂在尾巴上没差)。

而这个(i-1个Θ) +O} 好像不太能转化成和{i-1个Θ}有关形式，因为每种情况的可选区间数，都可以额外增加【最后一个O贡献的可选区间的数】=【右端点为n的可选区间的数量】=【i - 上一个1的位置】。但是这个上一个1的位置，对于不同情况是不一样的。(例如{OO}=3^m 而再加个O话，{OOO}=(3+3)^m ,而对于{O×}=1^m,再加个O，{O×O}=(1+1)^m,)

　　因此我还需要对dp状态加个维度，我们用dp[i][j][k]代表{i个Θ}展开中，最后一个×出现的位置为j的方案中 k^m的系数。然后答案就是Σdp[i][j][k]* k^m，

现在我在来考虑一下dp方程这么转移。我们要加上{(i-1个Θ) +O}的方案数，减掉{i-1个Θ) +×}的方案数，所以有：

当尾巴加O不改变最后一个1位置，但是改变可选区间数：

　　　　for(j=0,j<i;j++)

当尾巴加x时，所有转移到这个状态的,【最后一个1的位置】都要改成i：

到此转移就完成了，然后你会发现，这个算法是n^4。但是常数很小，然后题目有1000组数据，其中包含50组大数据_(¦3」∠)_，写挫就可能惨遭卡常。

顺便给个样例，100个2 ,m=1e9 的方案数mod 1e9+7 的结果是388544367。

问题四在0,1,2三种数字都考虑的情况，状态该怎么转移？。

其实0,1转移方法和上面类似的，

所以遇到1，因为{(i-1个Θ) +1}={(i-1个Θ) } ，所以连动都不要动，但是注意需要记这个1的位置，因为在计算右端点为n的可选区间的数量会用到。
而遇到0时，所有情况下k那个维度都要加上【i - 上一个1的位置】偏移量，所以要讨论一下这个1是从2变来，还是真正的1。
然后遇到2，转移是和问题三一样的，只不过也要注意一下，计算偏移量时的这个1是从2变来，还是真正的1就行了

最后，你发现这个毒瘤题还会有爆内存的风险，需要优化掉一维的空间。而且可能还要和卡常斗智斗勇。

所以再仔细观察一下，你发现这两种转移其实就是两种简单的操作：一种是数组下标偏移，一种是求j那维的前缀和。

因此当个二维数组写的时候：遇到1,不做任何操作。遇到0时只累加偏移量。遇到2，枚举j求个前缀和，求玩在计算2带来的偏移量。

最后在计算答案的时候，把偏移量代入就行了

AC代码如下：

 #include<cstdio>

 #include<algorithm>

 #include<string.h>

 #include<vector>

 using namespace std;

 #define ll long long

 const int mod=1e9+;

 inline int max(const int &x,const int &y)

 {

     return x>y?x:y;

 }

 int dp[][];

 int d[];

 int xx[];

 int a[];

 ll temp[];

 inline ll quickpow(ll a, ll n)

 {

     ll ans=;

     while(n)

     {

         if(n&)

             ans=ans*a%mod;

         n>>=;

         a=a*a%mod;

     }

     return ans;

 }

 int main()

 {

     int n,m,t,r,i,mx;

     scanf("%d",&t);

     while(t--)

     {

         scanf("%d%d",&n,&m);

         r=;

         mx=;

         a[]=;

         for(i=; i<=n; i++)

         {

             scanf("%d",&a[i]);

             if(a[i]==)

             {

                 r=i;

             }

             mx+=i-r;

         }

         for(i=; i<=n; i++)

             memset(dp[i],,sizeof(dp[i][])*(mx+));

         memset(xx,,sizeof(xx));

         memset(d,,sizeof(d));

         dp[][]=;///注意啥都不选也有一种方案。

         r=;

         mx=;

         for(i=; i<=n; i++)

         {

             if(a[i]==)///1的时候屁事都不干

             {

                 r=i;

             }

             else

             {

                 if(a[i]==)///0的时候累加偏移量

                 {

                     for(int j=; j<i; j++)

                     {

                         xx[j]+=i-max(j,r);

                     }

                 }

                 else if(a[i]==)

                 {

                     for(int j=; j<i; j++)

                     {

                         if(a[j]==)

                         {

                             mx=d[j];

                             d[i]=max(d[i],mx+xx[j]);///d[i]是可能有值的系数的宽度。

                             for(register int k=xx[j]; k<=mx+xx[j]; k++)///这里注意一下j带有的偏移量，所以不能直接 dp[i][k]-=dp[j][k]，而是应该dp[i][k]-=dp[j][k-xx[j]];，

                             {

                                 dp[i][k]-=dp[j][k-xx[j]];

                                 if(dp[i][k]<)

                                     dp[i][k]+=mod;

                             }

                         }

                     }

                     for(int j=; j<i; j++)///把2当0时累加偏移量。注意这个for是不能和上一个for交换位置，如果写个三维数组的，再改成二维数组就会知道为什么。

                     {

                         xx[j]+=i-max(j,r);

                     }

                 }

             }

         }

         long long ans=;

         mx=;

         for(i=; i<=n; i++)

         {

             mx=max(mx,d[i]+xx[i]);

         }

         for(i=; i<=mx; i++)///预处理一下所有数的次幂。

         {

             temp[i]=quickpow(i,m);

         }

         for(int i=; i<=n; i++)

         {

             if(a[i]==)

             {

                 for(int j=; j<=d[i]; j++)

                 {

                     ans+=dp[i][j]*temp[j+xx[i]]%mod;

                     ans%=mod;

                 }

             }

         }

         if(ans<)

             ans+=mod;

         printf("%lld\n",ans);

     }

     return ;

 }

青岛现场赛G题(zoj上2650ms,2696kb)