2019 湖南多校第一场(2018~2019NCPC) 题解

解题过程

---

开场shl过B,C，然后lfw写J，J WA了以后shl写A，但是因为OJ上空间开小WA了，而不是MLE?，J加了特判过了。之后一直在检查A错哪了，直到qt发现问题改了空间，浪费许多时间，但是拿到A一血，shl和byf推出K，不会写组合数而抄了板子，  但是WA, shl想出E题拿到一血了，byf和 shl以为板子错了，让lfw重写K题

lfw重写K题的时候公式复制了之前的代码，又WA了，lfw看出I题，开始写，然后因为高精度加法时c[i]=a[i]+b[i]而不是c[i]+=a[i]+b[i]导致了没有进位，WA了，shl这段时间一直在调D，WA了2发后拿D一血，lfw最后终于发现K题公式中连续3个int级别的数字相乘，中间没有取模，会爆long long ，改了A了，最后lfw发现I题问题，但是因为spj挂了以为没有A，不过最后还是过了。

---

A Altruistic Amphibians

题目大意：有n只青蛙想从一个深度为d的井中跳出去，因此青蛙需要叠罗汉。青蛙有3个属性，体重，身高，和跳跃力。叠罗汉唯一一个限制就是每只青蛙身上的青蛙的体重之和不能超过自身的体重。青蛙的跳跃力加上身下的青蛙的身高之和如果严格大于d，青蛙就能跳出去。 n<1e5,体重之和，d<1e8；

题解：考虑使用dp dp[i]表示的是能承重w的最大高度(注意这里是承重，不是下面青蛙的总重量)。 dp前需要将青蛙按体重从大到小排序，因为重的青蛙肯定不能在轻的青蛙上面。 因此转移方程就是dp[j]=max(dp[j],h[i]+dp[w[i]+j])(for j in range[1,wi-1])；时间复杂度 O(n)

参考代码:

 #include<bits/stdc++.h>
 using namespace std;
 #define clr(a,v) memset(a,v,sizeof(a))
 typedef long long ll;
 const int maxn=1e5+;
 const int maxm=1e8+;
 struct Node{
     int l,w,h;
     operator<(Node b)const {return w>b.w;}
 } node[maxn];
 int n,d,dp[maxm],ans;

 int main()
 {
     scanf("%d%d",&n,&d);
     for(int i=;i<=n;++i)
         scanf("%d%d%d",&node[i].l,&node[i].w,&node[i].h);
     sort(node+,node++n);
     clr(dp,); ans=;
     for(int i=;i<=n;++i)
     {
         if(dp[node[i].w]+node[i].l>d) ans++;
         for(int j=node[i].w+;j<min(node[i].w*,maxm);++j)
             dp[j-node[i].w]=max(dp[j-node[i].w],dp[j]+node[i].h);
     }
     printf("%d\n",ans);
     return ;
 }

---

B Baby Bites

题目大意：给定n，和一个带有mumble的序列，mumble可以代表任意数字，问该序列可否能为从1开始的连续的序列。 题解：for循环对数字进行判断即可。 复杂度：O(n)

参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define clr(a,v) memset(a,v,sizeof(a))
 typedef long long ll;
 const int INF=0x3f3f3f3f;
 const int maxn=1e5+;
 int n,num;
 char s[maxn];
 int work(char s[])
 {
     int len=strlen(s),x=;
     for(int i=;i<len;++i) x=x*+s[i]-'';
     return x;
 }
 int main()
 {
     scanf("%d",&n);
     bool flag=false;
     for(int i=;i<=n;++i)
     {
         scanf("%s",s);
         if(s[]>='' && s[]<='')
         {
             num=work(s);
             if(num!=i) flag=true;
         }
     }
     if(flag) puts("something is fishy");
     else puts("makes sense");

     return ;
 }

---

C Code Cleanups

题解：每次输入就看现在有了多少垃圾，垃圾数量达到20就进行清理 两次相邻输入之间增加的垃圾数为： 垃圾代码数量*相邻天数之差 输入结束看还有没有垃圾代码没被清理

 #include<bits/stdc++.h>
 using namespace std;
 #define clr(a,v) memset(a,v,sizeof(a))
 typedef long long ll;
 int n,d[],sum,x,ans,tmp;
 int main()
 {
     scanf("%d",&n);
     clr(d,); ans=sum=tmp=;
     for(int i=;i<=n;++i) scanf("%d",&x),d[x]++;
     for(int i=;i<=;++i)
     {
         if(d[i]) tmp++;
         sum+=tmp;
         if(sum>=) ans++,sum=,tmp=;
     }
     if(tmp) ans++;
     printf("%d\n",ans);
     return ;
 }

---

D：Delivery Delays

题意：

1000个点,5000条边的无向图,披萨店在1号店.1000份披萨订单,每个订单有下单时间,送达地点,披萨制作出来的时间.你是快递员初始在1号点,每次可以拿无穷多披萨,送完以后返回1号点继续送,送餐的时候要求按照下单顺序送达,求等待时间最长的顾客的最小等待时间.

题解:最小化最大值的问题,我们一般用二分答案再judge的套路进行. 考虑到所有的披萨都必须按照下单时间顺序送达,那么可以想象到最优的方案应该会将披萨序列分成若干小段,每一段都是从1号点出发,拿上该段所有的披萨,然后以最短路的形式,依次将披萨送达,最后回到1点. 对于最短路的处理，我们根据题目数据范围：点数n<=1000,边数m<=5000;我们可以进行n次Dijkstra求出任意两点之间的最短时间( O(n^2log(m)) ). 将序列分成若干段，我们可以考虑DP:dp[i]表示前i个订单已经送达且回到1号点的最短时间; 对于i这个点,将所有j≥i+1 && j<=k的dp[j]全部更新. 定义len(i,j) :表示从1出发,依次经过i,i+1,…,j这些点的最短路径长度.

当用dp[i]来更新dp[j]的时候我们注意到出发时间一定不能小于订单的完成时间 max{t[i+1],t[i+2],...,t[j]} ，因为必须等这些披萨都制作完成后才能出发 并且出发时间也一定不能大于最晚时间（即用ans求出的最晚时间）；min{ans+s[i+1]−len[i][i+1],...,ans+s[j]−len[i][j]} ，因为对于每个t,满足i+1≤t≤j ,必然有len(i,t)+st−s[j]≤ans,也即st≤ans−len(i,t)+s[j] s同时满足这两个条件的j才能由i进行转移. 如果最后dp[k]被更新过,那么限制M就是可行的,否则不行.

参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define clr(a,v) memset(a,v,sizeof(a))
 typedef long long ll;
 typedef pair<ll,int> pli;
 const ll INF=0x3f3f3f3f3f3f3f3fll;
 const int maxn=;
 const int maxm=;
 int n,m,k,ecnt,head[maxn];
 ll s[maxn],p[maxn],t[maxn];
 ll dis[maxn][maxn],dp[maxn];
 struct Edge{
     int v,nxt;
     ll w;
 } edge[maxm<<];

 void addedge(int u,int v,int w)
 {
     edge[ecnt].v=v;
     edge[ecnt].w=w;
     edge[ecnt].nxt=head[u];
     head[u]=ecnt++;
 }

 void dijkstra(int id,int ss)
 {
     clr(dis[id],INF); dis[id][ss]=;
     priority_queue<pli,vector<pli>,greater<pli> > pq;
     pq.push(make_pair(dis[id][ss],ss));
     while(!pq.empty())
     {
         ll tmp=pq.top().first;
         int u=pq.top().second; pq.pop();
         if(dis[id][u]<tmp) continue;
         for(int i=head[u];~i;i=edge[i].nxt)
         {
             int v=edge[i].v;
             if(dis[id][v]>dis[id][u]+edge[i].w)
             {
                 dis[id][v]=dis[id][u]+edge[i].w;
                 pq.push(make_pair(dis[id][v],v));
             }
         }
     }
 }

 bool check(ll ans)
 {
     memset(dp,INF,sizeof(dp[])*(n+));
     dp[]=;
     for(int i=;i<k;++i)
     {
         ll st=dp[i],mlst=INF,d=;
         for(int j=i+;j<=k;++j)
         {
             if(j==i+) d+=dis[][p[j]];
             else d+=dis[p[j-]][p[j]];
             st=max(st,t[j]);mlst=min(mlst,ans-d+s[j]);
             ll tt=st+d-s[j];
             if(tt<=ans && st<=mlst) dp[j]=min(dp[j],st+d+dis[p[j]][]);
             else break;
         }
     }
     return (dp[k]<INF);
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     int u,v; ll w;
     memset(head,-,sizeof(int)*(n+));ecnt=;
     for(int i=;i<=m;++i)
     {
         scanf("%d%d%lld",&u,&v,&w);
         addedge(u,v,w);addedge(v,u,w);
     }
     for(int i=;i<=n;++i) dijkstra(i,i);
     scanf("%d",&k);
     for(int i=;i<=k;++i) scanf("%lld%lld%lld",&s[i],&p[i],&t[i]);
     ll l=,r=INF,mid,ans=;
     while(l<=r)
     {
         mid=l+r>>;
         if(check(mid)) ans=mid,r=mid-;
         else l=mid+;
     }
     printf("%lld\n",ans);

     return ;
 }

---

E : Explosion Exploit

题意：我方n人，血量已知，对方m人，血量已知。现在有d点伤害，一点一点扣，每次伤害对所有活着的人的概率相同。问d次伤害后对面全死的概率 题解：首先，因为每个士兵的血量最大为6，且敌我双方的士兵数均为5，因此我们考虑可以用搜索的方法去解决 因为士兵的总血量的状态比较少，因此我们可以考虑用一个12位的long long的每一位去存储每一种血量的个数。每一个12位的ll整型就唯一代表了一种状态。因此我们只需要用记忆化的形式对曾经出现过的结果记进行记录，以达到剪枝的作用。因为我们要记录的是敌军死亡的概率，因此，我们可以优先将敌军的6种血量置于12位ll的高位，这样，当我们访问到的状态值<1000000，则代表已经敌军已经已经死亡，即可直接跳出递归（又一个剪枝）。 最后只需要将相应的概率相乘并相加即为答案。

参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int n,m,d;
 int num[][];
 map<ll,double> dp;

 ll getnum()
 {
     ll ans=;
     for(int i=;i>=;--i)
     {
         for(int j=;j>=;--j) ans=ans*+num[i][j];
     }
     return ans;
 }

 double dfs(ll nm,int limit)
 {
     if(dp.count(nm)) return dp[nm];
     //if(!limit) return 0;
     if(nm<) return ;
     if(!limit) return ;
     double ans=;
     int cnt=;
     for(int i=;i<;++i)
         for(int j=;j<=;++j) cnt+=num[i][j];
     //cout<<cnt<<endl;
     for(int i=;i<;++i)
     {
         for(int j=;j<=;++j)
         {
             if(!num[i][j]) continue;
             num[i][j]--;num[i][j-]++;
             ll k=getnum();
             double res=dfs(k,limit-);
             dp[k]=res;
             num[i][j]++;num[i][j-]--;
             ans=ans+1.0*num[i][j]/cnt*res;
         }
     }
     return ans;
 }

 int main()
 {
     scanf("%d%d%d",&n,&m,&d);
     int x;
     memset(num,,sizeof(num));
     for(int i=;i<=n;++i) scanf("%d",&x),num[][x]++;
     for(int i=;i<=m;++i) scanf("%d",&x),num[][x]++;
     double ans=dfs(getnum(),d);
     printf("%.8lf\n",ans);

     return ;
 }

---

F Firing the phaser

unsolved.

---

G Game Scheduling

题目大意
有m支队伍，每支队伍有n个选手，让所有的选手和其他组的选手进行一次较量.问怎么安排可以让所有的选手在一轮
中只出现一次.且最多一轮不出现.
解题思路
本题是上述的染色算法的一个简单应用，当两个颜色之间还存在着可以染的颜色时，直接染上即可.当两条边之间不
存在可以染的颜色时，则其中一个点必然是一条cdx路径的末端点，故将那条路径翻转，释放出一种新的颜色即可

参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef  pair<int,int> pii;
 const int sz=*;
 int match[sz][sz];
 bool vis[sz];
 bool col[sz];
 int n,m;
 int get_block(int x)
 {
     memset(col,,sizeof(col));
     for(int i=;i<n*m;i++) col[match[x][i]]=;
     for(int i=;i<n*m;i++) if(!col[i]) return i;
     return n*m;
 }
 int check_conflict(int x,int loc)
 {
     for(int i=;i<n*m;i++) if(match[x][i]==loc) return i;
     return n*m;
 }
 void recol(int x, int y)
 {
     int pre_match=get_block(y);
     int conflict=check_conflict(x,pre_match);
     memset(vis,,sizeof(vis));
     vis[y] = ;
     vector<pii> match_line;
     match_line.push_back(pii(y,pre_match));
     while (conflict!=n*m && !vis[conflict]) {
         vis[conflict] = ;
         y=conflict;
         pre_match = get_block(y);
         match_line.push_back(pii(y,pre_match));
         conflict = check_conflict(x, pre_match);
     }
     if (conflict==n*m) {
         for(auto t:match_line) {
             match[x][t.first] = t.second;
             match[t.first][x] = t.second;
         }
     } else {
         int pre_match_x = get_block(x);
         int conflict_x=check_conflict(conflict,pre_match_x);
         match[x][conflict] = pre_match_x;
         match[conflict][x] = pre_match_x;
         while (conflict_x!=n*m) {
             int temp= check_conflict(conflict_x,pre_match);
             match[conflict][conflict_x] = pre_match;
             match[conflict_x][conflict] = pre_match;
             conflict=conflict_x;
             conflict_x=temp;
             swap(pre_match_x,pre_match);
         }
         recol(x,match_line[].first);
     }
 }
 int main()
 {
      scanf("%d%d",&n,&m);
     for(int i=;i<n*m;i++)
     {
         for(int j=;j<n*m;j++)
         {
             if(i/n!=j/n&&!match[i][j])
                 recol(i,j);
         }
     }
     int tot=n*(m-)*n*m/;
     for(int k=;tot;k++)
     {
         for(int i=;i<n*m;i++)
         {
             for(int j=i+;j<n*m;j++)
             {
                 if(match[i][j]==k)
                 {
                     tot--;
                     printf("%c%d-%c%d ",'A'+i/n,i%n+,'A'+j/n,j%n+);
                 }
             }
         }
         cout<<endl;
     }
 }

---

H House Lawn

参考代码：

 #include<bits/stdc++.h>
 #define db double
 #define ll long long
 using namespace std;
 const int maxn=1e6+,inf=1e9;
 char str[];
 struct node
 {
     char s[];
     int id,p;
     bool operator<(const node&t)const{return p==t.p? id<t.id:p<t.p;}
 }a[];
 void gao(int cur,int &pri,int &c,int &t,int &r)
 {
     int n=strlen(str),i=;
     pri=c=t=r=;
     while(str[i]!=',')i++;
     i++;
     while(str[i]!=',')
     pri=pri*+str[i++]-'';i++;
     while(str[i]!=',')
     c=c*+str[i++]-'';i++;
     while(str[i]!=',')
     t=t*+str[i++]-'';i++;
     while(i<n)
     r=r*+str[i++]-'';
 }
 int main()
 {
     int e,m,pri,c,t,r,v,n=,cnt=;
     cin>>e>>m;
     getchar();
     for(int i=;i<=m;i++)
     {
         gets(str);
         gao(i,pri,c,t,r);
         v=n/(t+r)*t*c;
         if(v<e)
         {
             int tmp=n%(t+r);
             db v1=(db(e)-v)/c,v2=tmp-v1;
             if(v1<=(db)t)
             if(v1*r<=v2*t)v=e;
         }
         if(v>=e)
         {
             a[++cnt].p=pri; a[cnt].id=i;
             int len=strlen(str),j=;
             while(str[j]!=',')
             a[cnt].s[j]=str[j],j++;
             a[cnt].s[j]='\0';
         }
     }
     sort(a+,a++cnt);
     if(cnt==)puts("no such mower");
     else
     {
         int i=;
         while()
         {
             printf("%s\n",a[i++].s);
             if(i>cnt||a[i].p>a[i-].p)break;
         }
     }
     return ;
 }

---

I Intergalactic Bidding

题目大意：总共有 n 个人，每个人有一个权值，给你一个 S，然后问你这 n 个人能否恰好凑齐 S，如果能请输出所选人的名字。注意：这 n 个人的权值如果按照从大到小排序，那么前一个数一定大于等于后者的两倍。 思路：由于这 n 个人之间的权值有两倍关系，因此我们可以把这 n 个人从大到小排序，然后用 S 依次去减，最后判断 S 是否减为 0。我们可以通过二进制来进行证明这个解法的准确性，因为第 k 大一定比第 k+1 大大两倍第 k+1 大一定比第 k+2 大大两倍第 k+3 大……因此后面的数相加永远也无法构成进位，因此，这样的取法是合理的。由于数据量比较大，因此本题需要采用大数。

参考代码：

 #include<bits/stdc++.h>
 #define maxl 2010
 using namespace std;

 int n,anslen;
 struct node
 {
     string nam;
     int val[maxl];
 }a[maxl];
 int s[maxl],sum[maxl],tmp[maxl];
 char ch[maxl];
 string ans[maxl];

 inline void getval(int a[])
 {
     int len=strlen(ch+);
     a[]=len;
     for(int i=;i<=len;i++)
         a[i]=ch[len-i+]-'';
 }

 inline bool cmp(const node &a,const node &b)
 {
     if(a.val[]>b.val[])
         return true;
     if(a.val[]<b.val[])
         return false;
     for(int i=a.val[];i>=;i--)
     {
         if(a.val[i]>b.val[i])
             return true;
         if(a.val[i]<b.val[i])
             return false;
     }
     return false;
 }

 inline void prework()
 {
     scanf("%d",&n);
     scanf("%s",ch+);
     getval(s);
     for(int i=;i<=n;i++)
     {
         cin>>a[i].nam;
         scanf("%s",ch+);
         getval(a[i].val);
     }
     sort(a+,a++n,cmp);
 }

 inline void add(int a[],int b[],int c[])
 {
     int len=max(b[],c[]);
     for(int i=;i<=len;i++)
     {
         a[i]+=b[i]+c[i];
         if(a[i]>=)
             a[i]-=,a[i+]+=;
     }
     if(a[len+]>)
         len++;
     a[]=len;
 }

 inline bool nomore(int a[],int b[])
 {
     if(a[]<b[])
         return true;
     if(a[]>b[])
         return false;
     for(int i=a[];i>=;i--)
     {
         if(a[i]<b[i])
             return true;
         if(a[i]>b[i])
             return false;
     }
     return true;
 }

 inline bool eq(int a[],int b[])
 {
     if(a[]!=b[])
         return false;
     for(int i=;i<=a[];i++)
     if(a[i]!=b[i])
         return false;
     return true;
 }

 inline void mainwork()
 {
     for(int i=;i<=n;i++)
     {
         memset(tmp,,sizeof(tmp));
         add(tmp,sum,a[i].val);
         if(nomore(tmp,s))
         {
             memset(sum,,sizeof(sum));
             for(int j=;j<=tmp[];j++)
                 sum[j]=tmp[j];
             ans[++anslen]=a[i].nam;
         }
     }
     if(!eq(sum,s))
         anslen=;
 }

 inline void print()
 {
     printf("%d\n",anslen);
     if(anslen!=)
     {
         for(int i=;i<=anslen;i++)
             cout<<ans[i]<<endl;
     }
 }

 int main()
 {
     prework();
     mainwork();
     print();
     return ;
 }

---

J jumbled String

题目大意：给你四个数 a，b，c，d，要你构造一个 01 串 s 满足以下条件：1.  有 a 种方案使得从 s 中任取两个字符，保持相对顺序恰好为 00；2.  有 b 种方案使得从 s 中任取两个字符，保持相对顺序恰好为 01；3.  有 c 种方案使得从 s 中任取两个字符，保持相对顺序恰好为 10；4.  有 d 种方案使得从 s 中任取两个字符，保持相对顺序恰好为 11；思路：由于是任取两个，因此我们可以考虑组合数，由 C(n,2)=a,C(m,2)=d 我们可以解出 0 的个的个数 m，注意需要单独处理 a(d)=0 的情况，因为当 a(d)=0 且(b != 0 || c != 0）时我们可以发要有一个 0 和 1。容易发现当 n * m != b + c 时是无法构造的，证明：我们先将所有的 1 放到最左边，0 放边，然后我们前移一个 0，当这个 0 没穿过一个 1 时 10 个数减少一个，01 个数增加一

 #include<bits/stdc++.h>
 #define maxl 1000010

 long long a,b,c,d,x,y,ans,n;
 bool flag;
 char ch[maxl];

 inline long long find(long long sum)
 {
     long long l=,r=*sum,mid;
     while(l+<r)
     {
         mid=(l+r)>>;
         if(mid*(mid-)/<=sum)
             l=mid;
         else
             r=mid;
     }
     if(l*(l-)/==sum)
         return l;
     else if(r*(r-)/==sum)
         return r;
     else
     {
         flag=false;
         return ;
     }
 }

 inline void prework()
 {
     flag=true;
     scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
     if(a== && b== && c== && d==)
     {
         x=;y=;return;
     }
     if(a== && d== && (b+c)>)
     {
         x=;y=;return;
     }
     if(a== && d>)
     {
         y=find(d);
         if(b+c>)
             x=;
         else
             x=;
         return;
     }
     if(a> && d==)
     {
         x=find(a);
         if(b+c>)
             y=;
         else
             y=;
         return;
     }
     x=find(a);
     y=find(d);
 }

 inline void mainwork()
 {
     n=x+y;
     if((a+b+c+d)!=n*(n-)/) flag=false;
     if(!flag) return;
     long long cnt0=x,cnt1=y,sumb=,sumc=;
     for(int i=;i<=n;i++)
     if(sumb+cnt1<=b)
     {
         ch[i]='';
         cnt0--;
         sumb+=cnt1;
     }
     else
     {
         ch[i]='';
         cnt1--;
         sumc+=cnt0;
     }
     if(sumb!=b && sumc!=c)
         flag=false;
 }

 inline void print()
 {
     if(!flag)
         puts("impossible");
     else
     {
         for(int i=;i<=n;i++)
             printf("%c",ch[i]);
     }
 }

 int main()
 {
     prework();
     mainwork();
     print();
     return ;
 }

---

K King's color

 #include<bits/stdc++.h>
 using namespace std;
 #define int long long

 const int mod=1e9+;
 const int maxn=;

 int n,k;
 long long ck[maxn],jc[maxn],inv[maxn];

 long long qp(long long a,long long b)
 {
     long long ans=,cnt=a;
     while(b)
     {
         if(b&)
             ans=ans*cnt%mod;
         cnt=cnt*cnt%mod;
         b>>=;
     }
     return ans;
 }
 void get_ck()
 {
     jc[]=;
     for(int i=;i<maxn;i++)
         jc[i]=jc[i-]*i%mod;
     inv[maxn-]=qp(jc[maxn-],mod-);
     for(int i=maxn-;i>=;i--)
         inv[i]=inv[i+]*(i+)%mod;
     ck[]=;
     long long fz=,fm=;
     for(int i=;i<=k;i++)
     {
         fz=fz*(k-i+)%mod;
         ck[i]=fz*inv[i]%mod;
     }
 }
 long long solve(int n,int k)
 {
     long long ans=;
     long long flag=;
     for(int i=k;i>=;i--,flag=-flag)
     {
         ans=((ans+(1ll*flag*ck[i]*i%mod)*qp(i-,n-)%mod)%mod+mod)%mod;
     }
     return ans;
 }
 int32_t main()
 {
     //freopen("K.in","r",stdin);
     //freopen("K.out","w",stdout);
     int x;
     scanf("%lld%lld",&n,&k);
     get_ck();
     for(int i=;i<n;i++) scanf("%lld",&x);
     printf("%lld\n",solve(n,k));
     return ;
 }

%lfw