答疑帖：

赞助团队：UMR IT Team和洛谷大佬栖息地

赛后题解:更新了那两道练手题的题解

赛时公告,不过一些通知也可能在团队宣言里发出

如果各位发现重题，请将你认为重复的题目链接连同这次比赛的题号一起发到@洛谷万岁 的私信，可能考虑有检举奖励QAQ

下面让我们请出@Forward_Star大佬！

好吧他可能会不在，有些问题我解决吧QAQ

但他应该马上就能回来。

最后祝大家AK愉快！

部分内容出自：https://www.luogu.org/blog/user21760/xiao-man-di-dancing-line-zhi-lv-ti-xie

这次比赛也是说难不难，说简单不简单呢，看看各位大佬的得分都如何呢？

热身题：

签个到！

这道题应该算是特别水了吧。其实可以记录下当前的方向，一旦改了方向就加1即可。下面给出std，共36ms,大家应该还能注意到空间上也给的比较小，我们就不能再一味的开1000*1000的数组，可以像std一样把数组压缩为2∗10002*10002∗1000，一维记方向，一维记路线.其他如下（海星？）

  1. #include<cstdio>
  2. #include<iostream>
  3. using namespace std;
  4.     int n,m,r,ans;
  5.     char a[2][1001];
  6. int main()
  7. {
  8.     ios::sync_with_stdio<false>
  9.     scanf("%d%d",&n,&m);
  10.     r=2;
  11.     for (int i=1;i<=n;i++)
  12.     {
  13.         int row=i%2;
  14.         for (int j=1;j<=m;j++)
  15.         {
  16.             cin>>a[row][j];
  17.             if (a[row][j]=='1'&&a[(row+1)%2][j]=='1'&&r==0)
  18.             {
  19.                 r=1;
  20.                 ans++;
  21.             }
  22.             else if (a[row][j]=='1'&&a[row][j-1]=='1'&&r==1)
  23.             {
  24.                 r=0;
  25.                 ans++;
  26.             }
  27.             else if (r==2)
  28.             {
  29.                 if (a[row][j]=='1'&&a[(row+1)%2][j]=='1')
  30.                     r=1;
  31.                 else if (a[row][j]=='1'&&a[row][j-1]=='1')
  32.                     r=0;
  33.             }
  34.         }
  35.     }
  36.     printf("%d",ans);
  37.     return 0;
  38. }

二进制之谜（前体）

那么这道题如果你一看题面一定是水的不能再水的题了，但看到数据后，c++之类的选手就要注意了：高精度来作甚？

  1. #include<cstdio>
  2. #include<string>
  3. #include<algorithm>
  4. #include<iostream>
  5. using namespace std;
  6.     struct forward_star
  7.     {
  8.         int next,to;
  9.     };
  10.     long long a[501],c[10001][501];
  11.     int head[1000001];
  12.     forward_star edge[10000001];
  13.     int tot,cnt;
  14.     string s;
  15. void plu(int now)
  16. {
  17.     for (int i=1;i<=max(a[0],c[now][0]);i++)
  18.     {
  19.         c[now][i]+=a[i];
  20.         c[now][i+1]+=c[now][i]/1000000000;
  21.         c[now][i]%=1000000000;
  22.     }
  23.     c[now][0]=max(a[0],c[now][0]);
  24.     if (c[now][c[now][0]+1]!=0) c[now][0]++;
  25.     return;
  26. }
  27. void multiply()
  28. {
  29.     for (int i=a[0];i>=1;i--)
  30.     {
  31.         a[i]*=2;
  32.         a[i+1]+=a[i]/1000000000;
  33.         a[i]%=1000000000;
  34.     }
  35.     if (a[a[0]+1]!=0) a[0]++;
  36.     return;
  37. }
  38. void add(int u,int v)
  39. {
  40.     cnt++;
  41.     edge[cnt].to=v;
  42.     edge[cnt].next=head[u];
  43.     head[u]=cnt;
  44. }
  45. int main()
  46. {
  47.     while (cin>>s)
  48.     {
  49.         tot++;
  50.         for (int i=s.size()-1;i>=0;i--)
  51.             if (s[i]=='1')
  52.                 add(s.size()-i-1,tot);
  53.     }
  54.     a[0]=1;
  55.     a[1]=1;
  56.     for (int i=0;i<=10000;i++)
  57.     {
  58.         int j=head[i];
  59.         while (j!=0)
  60.         {
  61.             plu(edge[j].to);
  62.             j=edge[j].next;
  63.         }
  64.         multiply();
  65.     }
  66.     for (int i=1;i<=tot;i++)
  67.     {
  68.         for (int j=c[i][0];j>=1;j--)
  69.         {
  70.             int p=10;
  71.             while (j<c[i][0]&&c[i][j]<1000000000/p)
  72.             {
  73.                 printf("0");
  74.                 p*=10;
  75.             }
  76.             printf("%lld",c[i][j]);
  77.         }
  78.         printf("\n");
  79.     }
  80.     return 0;
  81. }

比赛题目：

T1

题意：给出一个长度为nnn字符环，求回文串长度为lll的回文中心个数。

Solution 0

我们可以有信仰！输出0，期望得分10；输出nnn，期望得分10。

Solution 1

我们可以暴力！枚举所有子串，期望得分30；

Solution 2

枚举所有回文中心，根据处理环的方式不同（开环枚举断点或补成字符串），时间复杂度也有不同，期望得分50～80（为了照顾不会Manacher的同学）；

Solution 3

把读入的串复制两次分别粘贴在原串前后，这样便和环等价，直接跑一遍Manacher，时间复杂度为O(n)O(n)O(n)，期望得分100分。

不懂Manacher？百度有啊

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<algorithm>
  4. using namespace std;
  5.     int n,l,cnt;
  6.     int str[10000001];
  7.     char t[10000001];
  8.     char s[10000001];
  9. int main()
  10. {
  11.     scanf("%d%d",&n,&l);
  12.     for (int i=1;i<=n;i++)
  13.     {
  14.         t[i]=getchar();
  15.         while (t[i]<'A'||t[i]>'Z')
  16.             t[i]=getchar();
  17.     }
  18.     for (int j=1;j<=3;j++)
  19.         for (int i=1;i<=n;i++)
  20.         {
  21.             s[++cnt]='0';
  22.             s[++cnt]=t[i];
  23.         }
  24.     s[++cnt]='0';
  25.     int r=0;
  26.     int now=0;
  27.     int ans=0;
  28.     for (int i=1;i<=cnt;i++)
  29.     {
  30.         if (i<=r)
  31.             str[i]=min(r-i+1,str[now*2-i]);
  32.         while (i+str[i]<=cnt&&i-str[i]>0&&s[i+str[i]]==s[i-str[i]]) str[i]++;
  33.         if (str[i]+i-1>r)
  34.         {
  35.             r=str[i]+i-1;
  36.             now=i;
  37.         }
  38.         if (str[i]-1>=l&&i>=2*n+1&&i<=cnt-2*n&&s[i]!='0')
  39.             ans++;
  40.     }
  41.     printf("%d",ans);
  42.     return 0;
  43. }

T2

题意：给出数列an+1=(an−nk+2)k+n+1a_{n+1}=(\sqrt[k]{a_n-n}+2)^k+n+1an+1​=(kan​−n​+2)k+n+1，求最小kkk使得an≡b(moda_n \equiv b(modan​≡b(mod m)m)m)。

Solution 0

我们可以有信仰！输出0，期望得分10；输出INF，期望得分20.

Solution 1

我们可以暴力！直接枚举kkk递推ana_nan​，期望得分30；

Solution 2

发现通项公式an=2(n−1)+na_n=2(n-1)+nan​=2(n−1)+n再枚举kkk，期望得分60；

找出通项公式的方法：

1、打表；

2、移项得：an+1−(n+1)=(an−nk+2)ka_{n+1}-(n+1)=(\sqrt[k]{a_n-n}+2)^kan+1​−(n+1)=(kan​−n​+2)k；

两边开kkk次方：an+1−(n+1)k=an−nk+2\sqrt[k]{a_{n+1}-(n+1)}=\sqrt[k]{a_n-n}+2kan+1​−(n+1)​=kan​−n​+2；

3、我们发现什么？！令tn=an−nt_n=a_n-ntn​=an​−n，则{tn}\left\{t_n\right\}{tn​}是等差数列！

算出t1=a1−1=0t_1=a_1-1=0t1​=a1​−1=0，那么tn=2(n−1)t_n=2(n-1)tn​=2(n−1)，则an−n=2(n−1)a_n-n=2(n-1)an​−n=2(n−1)，则an=2(n−1)+na_n=2(n-1)+nan​=2(n−1)+n。

这样，通项公式就找出来了。

Solution 3

扩展BSGS+快速乘即可。

  1. #include<cstdio>
  2. #include<cmath>
  3. #include<map>
  4. using namespace std;
  5.     long long n,m,b;
  6.     map<long long,long long>mp;
  7. inline long long multi(long long x,long long y,long long mod) //快速乘
  8. {
  9.     long long tmp=(x*y-(long long)(((long double)x*y+0.5)/mod)*mod);
  10.     if (tmp<0) return tmp+mod; else return tmp;
  11. }
  12. inline long long gcd(long long a,long long b)
  13. {
  14.     while (a%b)
  15.     {
  16.         long long k=a%b;
  17.         a=b;
  18.         b=k;
  19.     }
  20.     return b;
  21. }
  22. long long quickpower(long long a,int b)
  23. {
  24.     long long t=1;
  25.     while (b>0)
  26.     {
  27.         if ((b&1)==1) t=multi(t,a,m);
  28.         if (b>1) a=multi(a,a,m);
  29.         b=b>>1;
  30.     }
  31.     return t;
  32. }
  33. int main()
  34. {
  35.     mp.clear();
  36.     scanf("%lld%lld%lld",&n,&m,&b);
  37.     b=((b-n)%m+m)%m;
  38.     long long first=((multi(2,n,m)-1)%m+m)%m;
  39.     long long tmp=1;
  40.     long long ans=0;
  41.     while (true)
  42.     {
  43.     	long long d=gcd(first,m);
  44.     	if (d==1) break;
  45.     	if (b%d)
  46.     	{
  47.     		printf("INF");
  48.     		return 0;
  49.     	}
  50.     	b/=d;
  51.     	m/=d;
  52.     	ans++;
  53.     	tmp=multi(tmp,first/d,m);
  54.     	if (tmp==b)
  55.     	{
  56.     		printf("%lld",ans);
  57.     		return 0;
  58.     	}
  59.     }
  60.     long long now=b;
  61.     mp[now]=0;
  62.     int mm=ceil(sqrt(double(m)));
  63.     for (int i=1;i<=mm;i++) //预处理哈希表
  64.     {
  65.         now=multi(now,first,m);
  66.         mp[now]=i;
  67.     }
  68.     now=tmp;
  69.     long long q=quickpower(first,mm);
  70.     for (int i=1;i<=mm;i++)
  71.     {
  72.         now=multi(now,q,m);
  73.         if (mp[now])
  74.         {
  75.             printf("%lld",(((long long)(i)*(long long)(mm)-mp[now]+ans)%m+m)%m);
  76.             return 0;
  77.         }
  78.     }
  79.     printf("INF");
  80.     return 0;
  81. }

理论上，本题因为mmm不是质数不能用BSGS，但是由于数据很水，裸BSGS也能拿80。

T3

题意略。

Solution 0

我们可以有信仰！输出0，期望得分0。

Solution 1

我们可以暴力！枚举所有组合状态，期望得分30。

Solution 2

建图跑费用流。

将所有0视为源点，所有1视为汇点，当然这样是跑不了网络流的，所以我们设置超级源点与超级汇点分别与所有源点和所有汇点相连，由于每个0和1只能用一次，这些边的费用为0，容量为1。

之后处理二进制数，将每一个0与其后面的1连一条费用为两者位数差的绝对值且容量为1的边。

这样建图就完成了，跑一遍费用流即可。

但这里有个问题：如何保证它们不交叉？

其实显然可以发现，同样的几个数，不管对应关系交叉还是不交叉，总启发系数是相等的，这样我们就无需另外特殊处理了。

时间复杂度在O(n3)O(n^3)O(n3)~O(n4)O(n^4)O(n4)之间，期望得分100分。

  1. #include<cstdio>
  2. #include<iostream>
  3. #include<cstring>
  4. using namespace std;
  5.     int n,first;
  6.     char c[501];
  7.     int w[502][502];
  8.     bool f[502][502];
  9.     int stack[502];
  10.     int dist[502];
  11.     int pre[502];
  12.     bool vis[502];
  13. int check()
  14. {
  15.     int top=1;
  16.     stack[1]=0;
  17.     for (int i=1;i<=n+1;i++)
  18.         dist[i]=-2147483647;
  19.     dist[0]=0;
  20.     memset(vis,false,sizeof(vis));
  21.     vis[0]=true;
  22.     while (top>0)
  23.     {
  24.         int now=stack[top];
  25.         top--;
  26.         vis[now]=false;
  27.         for (int i=0;i<=n+1;i++)
  28.             if (f[now][i]&&dist[now]+w[now][i]>dist[i])
  29.             {
  30.                 dist[i]=dist[now]+w[now][i];
  31.                 pre[i]=now;
  32.                 if (!vis[i])
  33.                 {
  34.                     vis[i]=true;
  35.                     stack[++top]=i;
  36.                 }
  37.             }
  38.     }
  39.     return dist[n+1];
  40. }
  41. int main()
  42. {
  43.     scanf("%d",&n);
  44.     for (int i=1;i<=n;i++)
  45.     {
  46.         char s;
  47.         s=getchar();
  48.         while (s!='0'&&s!='1') s=getchar();
  49.         c[i]=s;
  50.     }
  51.     for (int i=1;i<=n;i++)
  52.     {
  53.         if (c[i]=='0')
  54.         {
  55.             w[0][i]=0;
  56.             w[i][0]=0;
  57.             f[0][i]=1;
  58.             f[i][0]=0;
  59.         }
  60.         else
  61.         {
  62.             w[i][n+1]=0;
  63.             w[n+1][i]=0;
  64.             f[i][n+1]=1;
  65.             f[n+1][i]=0;
  66.         }
  67.         for (int j=i+1;j<=n;j++)
  68.             if (c[i]=='0'&&c[j]=='1')
  69.             {
  70.                 w[i][j]=j-i;
  71.                 w[j][i]=-(j-i);
  72.                 f[i][j]=1;
  73.                 f[j][i]=0;
  74.             }
  75.     }
  76.     int ans=0;
  77.     bool find=false;
  78.     while (!find)
  79.     {
  80.         int del=check();
  81.         if (del==-2147483647)
  82.             find=true;
  83.         else
  84.         {
  85.             ans+=del;
  86.             int t=n+1;
  87.             while (t!=0)
  88.             {
  89.                 f[t][pre[t]]=!f[t][pre[t]];
  90.                 f[pre[t]][t]=!f[pre[t]][t];
  91.                 t=pre[t];
  92.             }
  93.         }
  94.     }
  95.     printf("%d",ans);
  96.     return 0;
  97. }

T4

题意较为复杂，详见题面。

本题操作较多，前面的测试点基本上都分别对应一个操作，因此我们逐个测试点分析。

111：没什么好说的……

222：最暴力的方法也能过，也没什么好说的。

444：这个也很简单，直接跑一遍最长路即可，当然裸dijkstradijkstradijkstra是过不了的，需要加堆优化；

由于出题人的数据生成器比较水，生成个数据都要几分钟，所以很良心地没有卡spfaspfaspfa。

333：这一测试点边权为0，那就省去了最长路了；

如何判断图的连通性？顺着去枚举并每次判断连通性，显然会超时；

这里标程用了笨办法：分块二分；由于删除的边不超过1000条，最多只会把操作分成1000个部分，每一部分操作都是添加边，显然有单调性！

顺着枚举每一部分的操作，在处理每个部分时二分判断连通性，可以减少判断的次数，优化操作时间。

至于删除操作，我用了树状数组+二分，树状数组存前缀和，即它是第几条边，然后二分它在原数组的标号即可。

5−65-65−6：经过上面一番分析大家大概也有整体思路了：先分块二分判连通性，再求最长路。

这里无消失的边，那么省去了分块与删除操作，其它与上面方法一样。

7−87-87−8：这里也是非常简单的，由于删除边对生成连通图没有贡献，所以操作同444。

9−109-109−10：其实就是测试点333+测试点444，用333的方法判断连通性后求个最长路即可。

可见，本题中其实大部分分都可以水的，而要AC，解决测试点333是关键。

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5.     struct newdata
  6.     {
  7.         int tm,type,u,v,w,k;
  8.     };
  9.     struct forward_star
  10.     {
  11.         int next,to,w;
  12.     };
  13.     int n,m,t,cnt,tot;
  14.     forward_star edge[1100001];
  15.     newdata work[100001];
  16.     int head[100001];
  17.     int heap[100001];
  18.     int que[100001];
  19.     int ref[100001];
  20.     int tree[1100001];
  21.     int dist[100001];
  22.     bool usable[1100001];
  23.     bool vis[100001];
  24. void add(int u,int v,int w)
  25. {
  26.     cnt++;
  27.     edge[cnt].to=v;
  28.     edge[cnt].w=w;
  29.     edge[cnt].next=head[u];
  30.     head[u]=cnt;
  31. }
  32. void adjust_up(int now)
  33. {
  34.     if (now>1&&dist[heap[now]]>dist[heap[now/2]])
  35.     {
  36.         ref[heap[now]]=now/2;
  37.         ref[heap[now/2]]=now;
  38.         swap(heap[now],heap[now/2]);
  39.         adjust_up(now/2);
  40.     }
  41. }
  42. void adjust_down(int now)
  43. {
  44.     if (now*2+1<=tot)
  45.     {
  46.         int k;
  47.         if (dist[heap[now*2+1]]>dist[heap[now*2]]) k=now*2+1; else k=now*2;
  48.         if (dist[heap[k]]>dist[heap[now]])
  49.         {
  50.             ref[heap[k]]=now;
  51.             ref[heap[now]]=k;
  52.             swap(heap[k],heap[now]);
  53.             adjust_down(k);
  54.         }
  55.     }
  56.     else if (now*2<=tot)
  57.     {
  58.         if (dist[heap[now*2]]>dist[heap[now]])
  59.         {
  60.             ref[heap[now]]=now*2;
  61.             ref[heap[now*2]]=now;
  62.             swap(heap[now],heap[now*2]);
  63.             adjust_down(now*2);
  64.         }
  65.     }
  66. }
  67. void addheap(int now)
  68. {
  69.     heap[++tot]=now;
  70.     ref[now]=tot;
  71.     adjust_up(tot);
  72. }
  73. void pushheap()
  74. {
  75.     heap[1]=heap[tot];
  76.     ref[heap[1]]=1;
  77.     tot--;
  78.     adjust_down(1);
  79. }
  80. void dijkstra_heap(int u)
  81. {
  82.     memset(vis,false,sizeof(vis));
  83.     memset(dist,255,sizeof(dist));
  84.     dist[u]=0;
  85.     vis[u]=true;
  86.     addheap(u);
  87.     while (tot!=0)
  88.     {
  89.         int now=heap[1];
  90.         pushheap();
  91.         int i=head[now];
  92.         while (i!=0)
  93.         {
  94.             if (usable[i]&&i<=cnt)
  95.                 if (dist[now]+edge[i].w>dist[edge[i].to])
  96.                 {
  97.                     dist[edge[i].to]=dist[now]+edge[i].w;
  98.                     if (!vis[edge[i].to])
  99.                     {
  100.                         vis[edge[i].to]=true;
  101.                         addheap(edge[i].to);
  102.                     } else adjust_up(ref[edge[i].to]);
  103.                 }
  104.             i=edge[i].next;
  105.         }
  106.     }
  107. }
  108. bool cmp(newdata i,newdata j)
  109. {
  110.     return i.tm<j.tm;
  111. }
  112. bool check(int u,int v)
  113. {
  114.     memset(vis,false,sizeof(vis));
  115.     int top=1;
  116.     que[top]=u;
  117.     vis[u]=true;
  118.     while (top>0)
  119.     {
  120.         int now=que[top];
  121.         top--;
  122.         int i=head[now];
  123.         while (i!=0)
  124.         {
  125.             if (i<=cnt&&usable[i])
  126.                 if (!vis[edge[i].to])
  127.                 {
  128.                     if (edge[i].to==v) return true;
  129.                     vis[edge[i].to]=true;
  130.                     que[++top]=edge[i].to;
  131.                 }
  132.             i=edge[i].next;
  133.         }
  134.     }
  135.     return false;
  136. }
  137. void adjust(int now)
  138. {
  139.     int i=now;
  140.     while (i>0)
  141.     {
  142.         i-=i&i;
  143.         tree[now]+=tree[i];
  144.     }
  145.     tree[now]++;
  146. }
  147. int sum(int now)
  148. {
  149.     int tot=0;
  150.     int i=now;
  151.     while (i>0)
  152.     {
  153.         tot+=tree[i];
  154.         i-=i&i;
  155.     }
  156.     return tot;
  157. }
  158. int solve(int now)
  159. {
  160.     int l=1;
  161.     int r=cnt;
  162.     while (l<r)
  163.     {
  164.         int mid=(l+r)>>1;
  165.         if (sum(mid)<now)
  166.             l=mid+1;
  167.         else r=mid-1;
  168.     }
  169.     tree[l]--;
  170.     return l;
  171. }
  172. int main()
  173. {
  174.     scanf("%d%d",&n,&m);
  175.     for (int i=1;i<=m;i++)
  176.     {
  177.         int u,v,w;
  178.         scanf("%d%d%d",&u,&v,&w);
  179.         add(u,v,w);
  180.         adjust(i);
  181.     }
  182.     memset(usable,true,sizeof(usable));
  183.     scanf("%d",&t);
  184.     if (t==0)
  185.     {
  186.         dijkstra_heap(1);
  187.         if (dist[n]==-1)
  188.             printf("Continue from the last checkpoint");
  189.         else
  190.         {
  191.             printf("0\n");
  192.             printf("%d",dist[n]);
  193.         }
  194.         return 0;
  195.     }
  196.     else
  197.     {
  198.         bool occur=false;
  199.         bool disappear=false;
  200.         for (int i=1;i<=t;i++)
  201.         {
  202.             scanf("%d%d",&work[i].tm,&work[i].type);
  203.             if (work[i].type==0)
  204.             {
  205.                 scanf("%d%d%d",&work[i].u,&work[i].v,&work[i].w);
  206.                 occur=true;
  207.             }
  208.             else
  209.             {
  210.                 scanf("%d",&work[i].k);
  211.                 disappear=true;
  212.             }
  213.         }
  214.         if (disappear&&!occur)
  215.         {
  216.             dijkstra_heap(1);
  217.             if (dist[n]==-1)
  218.                 printf("Continue from the last checkpoint");
  219.             else
  220.             {
  221.                 printf("0\n");
  222.                 printf("%d",dist[n]);
  223.             }
  224.             return 0;
  225.         }
  226.         sort(work+1,work+t+1,cmp);
  227.         if (check(1,n))
  228.         {
  229.             printf("0\n");
  230.             dijkstra_heap(1);
  231.             printf("%d",dist[n]);
  232.             return 0;
  233.         }
  234.         int l=1;
  235.         for (int i=1;i<=t;i++)
  236.             if (work[i].type==1)
  237.             {
  238.                 int r=i-1;
  239.                 if (l>=r)
  240.                 {
  241.                     usable[solve(work[i].k)]=false;
  242.                     l=i+1;
  243.                     continue;
  244.                 }
  245.                 int cnt_first=cnt;
  246.                 int l_first=l;
  247.                 for (int j=l;j<=r;j++)
  248.                 {
  249.                     add(work[j].u,work[j].v,work[j].w);
  250.                     adjust(cnt);
  251.                 }
  252.                 while (l<r-1)
  253.                 {
  254.                     int mid=(l+r)>>1;
  255.                     cnt=cnt_first+mid-l_first+1;
  256.                     if (check(1,n))
  257.                         r=mid;
  258.                     else l=mid;
  259.                 }
  260.                 cnt=cnt_first+l-l_first+1;
  261.                 if (check(1,n))
  262.                 {
  263.                     printf("%d\n",work[l].tm);
  264.                     dijkstra_heap(1);
  265.                     printf("%d",dist[n]);
  266.                     return 0;
  267.                 }
  268.                 cnt=cnt_first+r-l_first+1;
  269.                 if (check(1,n))
  270.                 {
  271.                     printf("%d\n",work[r].tm);
  272.                     dijkstra_heap(1);
  273.                     printf("%d",dist[n]);
  274.                     return 0;
  275.                 }
  276.                 cnt=cnt_first+i-l_first+1;
  277.                 usable[solve(work[i].k)]=false;
  278.                 l=i+1;
  279.             }
  280.         int r=t;
  281.         int cnt_first=cnt;
  282.         int l_first=l;
  283.         for (int j=l;j<=r;j++)
  284.         {
  285.             add(work[j].u,work[j].v,work[j].w);
  286.             adjust(cnt);
  287.         }
  288.         while (l<r-1)
  289.         {
  290.             int mid=(l+r)>>1;
  291.             cnt=cnt_first+mid-l_first+1;
  292.             if (check(1,n))
  293.                 r=mid;
  294.             else l=mid;
  295.         }
  296.         cnt=cnt_first+l-l_first+1;
  297.         if (check(1,n))
  298.         {
  299.             printf("%d\n",work[l].tm);
  300.             dijkstra_heap(1);
  301.             printf("%d",dist[n]);
  302.             return 0;
  303.         }
  304.         cnt=cnt_first+r-l_first+1;
  305.         if (check(1,n))
  306.         {
  307.             printf("%d\n",work[r].tm);
  308.             dijkstra_heap(1);
  309.             printf("%d",dist[n]);
  310.             return 0;
  311.         }
  312.         printf("Continue from the last checkpoint");
  313.         return 0;
  314.     }
  315.     return 0;
  316. }

小埋的Dancing Line之旅:比赛题解&热身题题解的更多相关文章

  1. Dancing Line、网易蜗牛读书——创新性分析

    Dancing Line——视听效果极佳的解压游戏 介绍:跳舞的线是由猎豹移动公司和BoomBitInc制作的一款游戏,发行于2016年12月12日. 游戏规则:跟着音乐的节奏点击屏幕,完成转向,躲避 ...

  2. 我的微信小程序入门踩坑之旅

    前言 更好的阅读体验请:我的微信小程序入门踩坑之旅 小程序出来也有一段日子了,刚出来时也留意了一下.不过赶上生病,加上公司里也有别的事,主要是自己犯懒,就一直没做.这星期一,赶紧趁着这股热乎劲,也不是 ...

  3. 干物妹小埋 （离散化 + 线段树 + DP）

    链接:https://ac.nowcoder.com/acm/contest/992/B来源:牛客网 题目描述 在之前很火的一个动漫<干物妹小埋>中,大家对小埋打游戏喝可乐的印象十分的深刻 ...

  4. 吉首大学2019年程序设计竞赛（重现赛） B 干物妹小埋

    链接:https://ac.nowcoder.com/acm/contest/992/B来源:牛客网 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32768K,其他语言65536K ...

  5. 清橙A1206.小Z的袜子 && CF 86D（莫队两题）

    清橙A1206.小Z的袜子 && CF 86D(莫队两题) 在网上看了一些别人写的关于莫队算法的介绍,我认为,莫队与其说是一种算法,不如说是一种思想,他通过先分块再排序来优化离线查询问 ...

  6. 微信小程序t填坑之旅一（接入）

    一.小程序简介 小程序是什么? 首先"程序"这两个字我们不陌生.看看你手机上的各个软件,那就是程序.平时的程序是直接跑在我们原生的操作系统上面的.小程序是间接跑在原生系统上的.因为 ...

  7. 【费用流】loj#545. 「LibreOJ β Round #7」小埋与游乐场

    好像现在看来这个缩点的思路挺清晰啊 题目描述 有两个非负整数组成的可重集合 $A$ 和 $B$. 现在你可以对 $A$ 中至多 $k$ 个元素进行操作.操作方法为:设你准备操作且未被操作过的 $A$ ...

  8. 微信小程序开发踩坑之旅

    项目之始: 一.搭建新项目时出现了 page[pages/XXX/XXX] not found.May be caused by :1. Forgot to add page route in app ...

  9. hdu---（4515）小Q系列故事——世界上最遥远的距离（模拟题）

    小Q系列故事——世界上最遥远的距离 Time Limit: 500/200 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)T ...

随机推荐

  1. EF CodeFirst数据迁移与防数据库删除

    1 开启migrations功能 enable-migrations -force 2 添加迁移版本 add-migration 名称后缀 我们每次修改实体后,都应该使用这个add-migration ...

  2. mac下实现代码远程同步

    近期将办公电脑从windows换成了mac,以前一直用windows,在windows下面将代码同步到远程的开发机,zend studio有一些内置的工具,但mac下的zend stduio没有了这个 ...

  3. 为QNetworkAccessManager添加超时提醒（自己记录一段时间里的下载字节数，用定时器去定期检测，从而判断是否超时）

    在做更新,在测试异常的时候,在下载过程中,发现如果直接系统禁用了网络,会报错误,可以捕获.但是如果是第三方软件限制程序联网,问题来了. 程序会一直在那里等待,没有异常,也不发送QNetworkAcce ...

  4. foreach() 中用指针指向数组元素，循环结束后最好销毁指针

    之前发过一次微博,今天又遇到这个问题,并且再次犯错,于是决定再加深一下. 就举php.net里的一个例子吧 $a = array('abe','ben','cam'); foreach ($a as ...

  5. 搭建基于.NetFrameWork的私有nuget服务端及打包项目发布上传

    一.私有Nuget服务端搭建 1.创建一个.NetFramework web项目 2.在nuget管理中 安装 nuget.server包 3.安装完成后修改web.config里面的 apikey ...

  6. 05-MySQL的完整性约束

    1.整体说明(1)讨论重点内容    not null 与default    unique:表中该值唯一,不能有重复值    primary    auto_increment    foreign ...

  7. sqlserver 表值函数与标量值函数

    除了在我们常用的程序开发中要用到函数外,在sql语句中也常用到函数,不论哪种,思想都没有变,都是为了封装,可复用. 创建的方法和整体结构都大体相同,都少不了函数名,函数的形参,返回值等这些. 一.表值 ...

  8. spring_three

    转账案例 坐标: ; } } 创建增强类Logger.java /** * 用于记录日志的工具类,它里面提供了公共的代码 */ @Component("logger") @Aspe ...

  9. 深入V8引擎-AST(2)

    先声明一下,这种长系列的大块头博客只能保证尽可能的深入到每一行源码,有些代码我不乐意深究就写个注释说明一下作用.另外,由于本地整理的比较好,博客就随心写了. 整个Compile过程目前只看到asmjs ...

  10. win10安装docker

    配置首先需要Hyper-v和容器,这样就可以运行Linux的镜像了 如果是win10home版或者是其他版本就需要安装visulbox了, 然后去官网https://www.docker.com/pr ...