2017中北大学程序设计大赛决赛题解
2017中北大学程序设计大赛决赛题解
- 列表内容
- A：2、3、5木头人
- B：Jack and Rose
- C：郭姐的数学
- D；魔力手环
- E：回收大佬之气
- F：郭姐相亲
- G：跳跃数
- H: 郭姐的老婆
- I：旺大神&郭姐
- J：无聊的一天
- K：玩数字
A：2、3、5木头人
既然求的是第一个大于等于它的数，那么二分的高效性就可以体现了。把只有2,3,5质因子的数预处理打表排序，大致推一下就知道满足的数不会超过[log2(1e18)*log3(le18)*log5(1e18)]个，每次询问二分即可。复杂度 T*log2(n)+排序复杂度
标程：
#includeB：Jack and Rose
（1）直接每次跑最小生成树，kruscal复杂度q*m*logm，过于暴力，会超时，可以想办法优化一下。（2）一开始没删边的时候直接跑一遍最小生成树，然后把这些边存入set，以后每次查询，如果删的边不在set里，那么就直接输出答案，否则，删边重新跑最小生成树。优化之后就能过题了。（3）当然本题还有更好的解法，把所有询问的边存起来进行离线处理。首先跑一边最小生成树，把最小生成树的边和询问中在最小生成树里的边存起来，假设总数为num，跑出来一个不完全的生成树，然后每次询问的时候只需要在num条边里面删掉查询边，跑最小生成树。这样缩小下规模，性能便大大提升了。复杂度q*（n+q）*log2(n+q)!
标程：
#includevoid init()
{
for(int i=0;i<1010;i++) fa[i]=i;
}
int fi(int a)
{
return a ==fa[a] ? a: fa[a]=fi(fa[a]);
}
void un(int a,int b)
{
a =fi(a);
b = fi(b);
fa[a]=b;
}
int work1(int n,int &m)
{
int ans = 0;
int num = 0;
for(int i =1; i <= m; i++)
{
if(fi(A[i].a) != fi(A[i].b))
{
A[++num].a=A[i].a;
A[num].b =A[i].b;
A[num].val = A[i].val;
if(!vis[A[i].a][A[i].b])
{
un(A[i].a,A[i].b);
}
}
}
return num;
}
int work(int n,int m,int a,int b)
{
init();
int ans = 0;
int num = 1;
for(int i =1; i <= m; i++)
{
if(fi(A[i].a) != fi(A[i].b) && (A[i].a !=a ||A[i].b != b) )
{
num++;
un(A[i].a,A[i].b);
ans = ans + A[i].val;
}
}
return num == n ? ans:-1;
}
void cal(int n,int m,int q)
{
int i,j;
memset(dp,0,sizeof dp);
memset(vis, 0, sizeof vis);
for(i=1;i<=q ;i++)
vis[B[i].a][B[i].b]=1;
Sort(m);
m = work1(n,m);
for(i=1;i<=q;i++)
{
Ans[B[i].val] =dp[B[i].a][B[i].b]==0 ? dp[B[i].a][B[i].b]=work(n,m,B[i].a,B[i].b) : dp[B[i].a][B[i].b];
}
}
int main()
{
int n,m,q;
while(scanf("%d%d",&n,&m)!=EOF)
{
int i,j,a,b,c;
init();
if(n==m &&n ==0)
break;
for(i=1;i<=m;i++)
{
scanf("%d%d%d",&A[i].a,&A[i].b,&A[i].val);
if(A[i].a > A[i].b)
swap(A[i].a,A[i].b);
}
scanf("%d",&q);
for(i=1;i<=q;i++)
{
scanf("%d%d",&B[i].a,&B[i].b);
B[i].val = i;
if(B[i].a > B[i].b)
swap(B[i].a,B[i].b);
}
cal(n,m,q);
for(i=1;i<=q;i++)
printf("%d\n",Ans[i]);
}
return 0;
} C：郭姐的数学
自己写一组数据，就能推出公式了
6/(n*(n-1)*(n-2))
标程：
#includeD；魔力手环
题面很简单，很容易推出递推式。但是k过于大，可以用矩阵快速幂优化。但是这样还是会超时，矩阵的相乘复杂度n^3，但是这个矩阵有个很有趣的性质，从第二列开始，每一列的矩阵值都是由上一列整体向右推一位得到的。这样的话如果不细心还是过不了。再看初值矩阵，除了第一列其他都是0，所以和初值矩阵有关的运算也可以从n^3优化n^2,然后就轻松过题了。。复杂度n^2*log2(k);
初值矩阵就是给的序列，递推矩阵（拿四维举例，其他同理）
1 0 0 1
1 1 0 0
0 1 1 0
0 0 1 1
标程：
#includeE：回收大佬之气
图论简单题，先更新好大佬之气，完后记忆化搜索跑最短路,不断更新题意要求的最优的路径就好了。这个题的一个坑点是卡vector，你是因为这个卡TLE卡到怀疑人生的么？复杂度n+nlogn+min(n^3,100000*n),bfs+最短路+更新路径（复杂度主要在更新路径）
标程1（记录路径最后比较的方法，更快）
#include0; // 初始都未用过该点
if(dist[i] < inf)
prev[i].push_back(v);
}
dist[v] = 0;
s[v] = 1;
for(int i=2; i<=n; ++i)
{
int tmp = inf;
int u = v;
// 找出当前未使用的点j的dist[j]最小值
for(int j=0; jif((!s[j]) && dist[j]// u保存当前邻接点中距离最小的点的号码
tmp = dist[j];
}
s[u] = 1; // 表示u点已存入S集合中
// 更新dist
for(int j=0; jif((!s[j]) && c[u][j]int newdist = dist[u] + c[u][j];
if(newdist <= dist[j])
{
if (newdist < dist[j]) {
prev[j].clear();
dist[j] = newdist;
}
prev[j].push_back(u);
}
}
}
}
int pcnt = 0;
void searchPath(vector<int> *prev, int v, int u, int sta[], int len) {
if (u == v) {
pcnt++;
pa[pcnt].push_back(S);
return ;
}
sta[len] = u;
for (int i = 0 ; i < prev[u].size(); ++i ) {
if (i > 0) {
for (int j = len - 1 ; j >= 0 ; --j) {
pa[pcnt].push_back(sta[j]);
}
}
searchPath(prev, v, prev[u][i], sta, len + 1);
pa[pcnt].push_back(u);
}
}
int main() {
cnt = 0;
memset(head, -1, sizeof(head));
for (int i=0; imemset(map, inf, sizeof(map));
memset(vis, 0, sizeof(vis));
scanf("%d%d%d%d%d%d", &N, &M, &L, &K, &S, &T);
for (int i=0; iscanf("%d", &p[i]);
for (int i=0; iint u, v, c;
scanf("%d%d%d", &u, &v, &c);
if (map[u][v] != inf)
cout<<"map"<map[u][v]=map[v][u]=c;
}
bfs(S);
Dijkstra(N, S, dis, path, map);
int sta[maxn];
pcnt = 0;
pa[pcnt].push_back(S);
searchPath(path, S, T, sta, 0);
int ans = 0, res=inf, pos=-1;
for (int i=1; i<=pcnt; i++){
int asum = 0, rsum = 0;
for (int j=0; jint nn = 0;
if (pa[i].size()%2 == 0)
nn = (int)pa[i].size()/2;
else
nn = (int)pa[i].size()/2+1;
for (int j=nn; jif (asum > ans) {
ans = asum;
res = rsum;
pos = i;
}
else if (asum == ans && rsum < res){
ans = asum;
res = rsum;
pos = i;
}
}
if (dis[T] >= inf)
puts("-1");
else {
printf("%d %d %d %d\n", pcnt, dis[T], ans, res);
for (int i=0; iif (i == 0)
printf("%d", pa[pos][i]);
else
printf("->%d", pa[pos][i]);
printf("\n");
}
return 0;
} 标程2：（直接记忆化搜索来更新路径，慢一点，但可以过题）
#includescanf("%d",&gas[i]);
while(m--){scanf("%d%d%d",&a,&b,&c);add(a,b,c);add(b,a,c);};
}
void min_road()
{
memset(dis,INF,sizeof(dis));dis[s]=0;
priority_queuevector,greater
>q;q.push(P(0,s));
while(!q.empty())
{
P p=q.top();q.pop();int v=p.second;if(dis[v]continue;for(int i=head[v];i!=-1;i=edge[i].next)
{node e=edge[i];if(dis[e.b]>dis[v]+e.c){dis[e.b]=dis[v]+e.c;q.push(P(dis[e.b],e.b));}}
}
}
void bfs()
{
queueq;q.push(P(s,1));
while(!q.empty())
{
P p=q.front();q.pop();if(l<=p.second)break;int v=p.first;
for(int i=head[v];i!=-1;i=edge[i].next)
{node e=edge[i];if(!vis[e.b]){vis[e.b]=1;gas[e.b]+=ceil(gas[e.b]*(l-p.second)*1.0/l);q.push(P(e.b,p.second+1));}}
}
}
void dfs(int u,int sum,int gass)
{
if(u==s)
{
if(gass%k>Gas){Sum++;Gas=gass%k;for(int i=0;iint summ=0;for(int i=0;i2;i++){summ+=gas[v2[i]];}Gasbehind=summ;return;}
else if(gass%k==Gas){Sum++;int summ=0;for(int i=0;i2;i++){summ+=gas[v2[i]];}
if(summfor(int i=0;ireturn;}}
else{Sum++;return;}
}
for(int i=head[u];i!=-1;i=edge[i].next)
{
node e=edge[i];if(!vis[e.b]&&(dis[e.b]+e.c+sum==Dis)){v2[cnt2++]=e.b;vis[e.b]=1;dfs(e.b,sum+e.c,(gass+gas[e.b])%k);vis[e.b]=0;
cnt2--;}
}
}
int main()
{
init();gas[s]*=2;bfs();min_road();Dis=dis[t];
if(Dis>=INF){printf("-1\n");return 0;}
Gas=Sum=0;Gasbehind=INF;
memset(vis,0,sizeof(vis));vis[t]=1;v2[cnt2++]=t;dfs(t,0,gas[t]);
printf("%d %d %d %d\n",Sum,Dis,Gas,Gasbehind);
for(int i=cnt1-1;i>=1;i--){printf("%d->",v1[i]);}printf("%d\n",t);
return 0;
}
F：郭姐相亲
模拟题，注意细节和优化。
标程：
#includevectorvec;
int main()
{
int k;scanf("%s",str+1);scanf("%d",&k);
int len=strlen(str+1);int cnt1=0,cnt2=0;
for(int i=1;i<=len;i++)
{
if(str[i]>='a'&&str[i]<='z')node[cnt1++].id=str[i];
else node2[cnt2++].id=str[i];
}
sort(node,node+cnt1,cmp); sort(node2,node2+cnt2,cmp);
int len2=len,tmp1=0,tmp2=0,t=1;
int flag=0,flag2=0,flag3=0;
while(len2>1)
{
int step=(k)%len2;
if(step==0)step=len2;int sum=0;
for(int i=t;step;i++)
{
sum++;
if(sum>50)break;//循环节
if(i>len)i=1;
if(!vis[str[i]]){step--;t=i;}
}
vis[str[t]]=1;
if(str[t]>='A'&&str[t]<='Z')
{
while(tmp1if(tmp1>=cnt1)break;
if(tmp11;flag=1;len2-=2;
vec.push_back(P(str[t],node[tmp1++].id));
}
}
if(str[t]>='a'&&str[t]<='z')
{
while(tmp2if(tmp2>=cnt2)break;
if(tmp21;flag=1;len2-=2;
vec.push_back(P(str[t],node2[tmp2++].id));
}
}
sum=0;
for(int i=t+1;;i++)
{
sum++;
if(sum>50)break;//循环节
if(i>len)i=1;
if(!vis[str[i]]){t=i;break;}
}
}
if(!flag){printf("-1\n");}
else
{
for(int i=0;iprintf("%c%c%c",vec[i].first,vec[i].second,i+1==vec.size()?'\n':' ');
}
return 0;
}
G：跳跃数
数位DP。按照题意的条件，记忆化搜索即可。
#includeH: 郭姐的老婆
简单推一推公式 n^2-2,注意开long long;
#includeI：旺大神&郭姐
贪心+优先队列。思想就是到了一个地方如果还有兴趣，那就把这个点存入堆，否则，就取堆顶元素，直到兴趣为正为止。复杂度n*log2(n)
#includeJ：无聊的一天
模拟建树，记录每个点的父亲，儿子和深度即可，只要深度相同，就说明他们是兄弟。
复杂度m*log2(n);
#includeint x;
scanf("%d", &x);
if (i == 0)
p[0].c = x, A[x] = 0;
else
add(x, 0, N), A[x] = N-1;
}
for (int i=0; iint x, y;
scanf("%d%d", &x, &y);
x = A[x], y=A[y];
if (p[x].h == p[y].h)
puts("brother");
else if (p[x].p == y)
puts("son");
else if (p[y].p == x)
puts("father");
else
puts("no connection");
}
return 0;
} K：玩数字
DP一定会超时，需要贪心。贪心的策略就是先选一个最小值，然后把这个最小值缩点。怎么缩呢？举个例子，-4 -5 -4；三个数，先取-5，然后把这个点变成-4+（-4）-（-5），然后把这个点-3放进去，再一次如果取到了-3，就相当于取了-8，即-4+（-4），相当于就是取了两边没取中间，是不是恍然大悟，感到巧妙至极啊？然后注意处理边界就好了。如果是边界上的点，直接把旁边的数也删了就好了，想想为什么！还有就是删数的时候注意细节，这道题就解决了！
#includeint> P;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
struct node1
{
ll a;
int l,r;
}node[100010];
sets;
void Delete(int now)
{
int l=node[now].l;
int r=node[now].r;
node[l].r=r;
node[r].l=l;
s.erase(s.find(P(node[now].a,now)));
}
int main()
{
int n,k;
while(scanf("%d",&n)!=EOF)
{
s.clear();ll ans=0,x;
for(int i=1;i<=n;i++)
{
scanf("%lld",&x);
s.insert(P(x,i));
node[i].a=x;node[i].l=i-1;node[i].r=i+1;
}
scanf("%d",&k);
while(k)
{
int id=s.begin()->second;
ans+=s.begin()->first;k--;s.erase(s.begin());
if(node[id].l<1)
{
int tmp=node[id].r;
if(tmp<=n)
{
s.erase(s.find(P(node[tmp].a,tmp)));
if(node[tmp].r<=n)
node[node[tmp].r].l=-1;
}
}
else if(node[id].r>n)
{
int tmp=node[id].l;
if(tmp>0)
{
s.erase(s.find(P(node[tmp].a,tmp)));
if(node[tmp].l>0)
node[node[tmp].l].r=n+1;
}
}
else
{
int tmp1=node[id].l,tmp2=node[id].r;
Delete(tmp1),Delete(tmp2);
node[id].a=node[tmp1].a+node[tmp2].a-node[id].a;
s.insert(P(node[id].a,id));
}
}
printf("%lld\n",ans);
}
return 0;
}