四川省第七届大学生程序设计竞赛-决赛 部分题解

四川省第七届大学生程序设计竞赛-决赛 

 大队长拉一场个人赛训练手速思维个人能力，昨天赵sir要求集训室早上7点半签到，于是比赛就设置成了7点半开始，集训室小伙伴们匆匆从宿舍赶来，全场被我开的D题带歪榜？雾。。https://cn.vjudge.net/contest/198467#rank

全场也就过了三道题，其他的一道读不懂，一道读错题，智商-500.

A - Easy Math

 

 这道题可以多种解应该，犹豫了一下结果一血被春哥学姐抢走。。
题意：中文题不再赘述。

1−−√+a2−−√+⋯+an−−√ is
a integer？
 一个数开方要么无限循环小数，所以不可能加成整数，于是直接判断每个数是否是平方数即可。

while(~scanf("%d",&n))
{
double sum=0;
int flag=0;
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
ll x=sqrt(a[i]*1.0);
if(x*x!=a[i]) flag=1;
}
if(!flag) puts("Yes");
else puts("No");
}

B - Carries

 

 题意和前天晚上某想飞挑战赛的一个题极像，于是读错题了。

赛后补题：给你n个数，求所有的（i,j,i<j）a[i]+a[j]的进位数之和。

关于进位，我们可以拆开算每一位的贡献，也就是个位数进位的情况，2位数相加进位，3位数相加进位......

枚举位数，然后每个数取余得到相应的位数，然后每个数找到对应的所需进位的数的差值以上有多少个统计即可，注意答案数据范围。int n;
while(~scanf("%d",&n))
{
ll ans=0;
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
ll k=1;
for(int j=1;j<=9;j++)
{
k*=10;
for(int i=1;i<=n;i++) b[i]=a[i]%k;
sort(b+1,b+n+1);
for(int i=1;i<=n;i++) ans+=n-(lower_bound(b+i+1,b+n+1,k-b[i])-b-1);//从i开始避免了重复计算的问题
}
printf("%lld\n",ans);
}

C - Censor

 

 题意：给出一个敏感词，然后一个文本串，删除文本串中的敏感词汇，重复删除操作，输出最后的文本串。

注意串长5e6，一般要求O(len)的思路。开始以为省赛数据水，于是string瞎搞了一波，成功TLE然后全场扔一边了。

正解可以kmp，也可以前缀hash栈模拟，用模拟栈统计可能最终存在的字符，再用一个数组计算前缀hash值，如果栈顶的前lenA个字符的hash值等于A串的hash值，直接删除这些字符，复杂度O(len)。const int N=5e6+10;
ul base=27;
char s1
,s2
,tmp
;
ul p
,ha
;
void init()
{
p[0]=1;
for(int i=1; i<N; i++) p[i]=p[i-1]*base;
}
int main()
{
init();
while(~scanf("%s%s",s1,s2))
{
int len1=strlen(s1);
int len2=strlen(s2);
if(len1>len2) printf("%s",s2);
else
{
ul has=0;
ha[0]=0;
int top=0;
for(int i=0; i<len1; i++) has=has*base+(s1[i]-'a')+1;
for(int i=0; i<len2; i++)
{
tmp[top++]=s2[i];
ha[top]=ha[top-1]*base+(s2[i]-'a')+1;
if(top>=len1&&ha[top]-ha[top-len1]*p[len1]==has) top-=len1;
}
for(int i=0;i<top;i++) printf("%c",tmp[i]);
}
puts("");
}
return 0;
}

D - Vertex Cover

 

这道题可能是人品好吧，开场19min AC，结果成功带歪榜，导致全场最高三题的佳绩。

题意：n个点，m条无向边的图，选最少的点将点所连接的边涂色，求最少的点使得所有边都涂上色。

典型最小点覆盖，但这个模型并不是二分图，所以这个解决这个问题呢，于是开场不敢写，后来想着用hungary()试试，跑出来结果发现，对于普通无向图，求二分匹配，每条边都可能被计算两次，所以用跑出来的结果加一再除以2就是原图的最小点覆盖了。int n,m,g

;
int linked
,used
;
bool dfs(int u)
{
for(int i=1;i<=n;i++)
if(!used[i]&&g[u][i])
{
used[i]=1;
if(linked[i]==-1||dfs(linked[i]))
{
linked[i]=u;
return true;
}
}
return false;
}
void hun()
{
int ans=0;
memset(linked,-1,sizeof(linked));
for(int i=1;i<=n;i++)
{
memset(used,0,sizeof(used));
if(dfs(i)) ans++;
}
pd((ans+1)/2);
}
int main()
{
// scanf("%d",&t);
while(~scanf("%d%d",&n,&m))
{
memset(g,0,sizeof(g));
int u,v;
for(int i=1;i<=m;i++)
{
scanf("%d%d",&u,&v);
g[u][v]=g[v][u]=1;
}
hun();
}
return 0;
}

E - Rectangle

 

 这个题倒是不难，很快发现计算方法了，但手残打错了一个地方，debug了半天，成功丧失一血。

题意：给你n*m的方格，求周长不超过k的矩形有多少个。

思路：假如我们选取的举行是a*b的，且2*(a+b)<=k。那么选a的方案数有n-a+1种的，然后算出b的取值范围：min(m,k/2-a)，同理对于b，方案数m-b+1，且构成一个等差数列，然后统计一波。 int n,m,k;
while(~scanf("%d%d%d",&n,&m,&k))
{
if(n>m) swap(n,m);
ll ans=0;
k/=2;
for(int i=1; i<=n; i++)
{
ll nn=n-i+1;
ll mm=k-i;
mm=min(mm,ll(m));
if(mm>0) ans+=(2*m-mm+1)*mm/2*nn;
}
printf("%lld\n",ans);
}

I - Travel

 

全场卡了2个小时的一个题，其他的题也不会，但这个题倒是挺适合我也激发了我的兴趣。

题意：给你n个点，m条无向边，长度为a，其补图也为无向边，长度为b，n=1e5，求1到n的最短路。

很容易想到如果1和n直接由a相连，那么答案即：min(a,k*b)，即在补图中找一条最短路。

如果不相连：ans=min(b,k*a)，在正向图中找一条路径。

情况二很好考虑，直接dij+priority_queue<>,或者spfa()。

但情况一：由于补图边很多，所以建图求最短路是不可行的，对于这种问题也很容易想到用搜索去寻找路径，所以怎么搜索方式适合复杂度呢？

实话说，不会，赛后看题解，发现很多方法，都很神奇，这里引用：http://blog.csdn.net/lvshubao1314/article/details/48848319

 两个set瞎搞，保证每个点最多入队一次。const int N=1e5+10;
int head
,tot,n,m,a,b;
struct Edge
{
int to,next;
ll w;
} e[N*30];
int vis
;
ll d
;
ll ans;
void init()
{
tot=0;
memset(vis,0,sizeof(vis));
memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
e[tot].to=v,e[tot].next=head[u],e[tot].w=a;
head[u]=tot++;
e[tot].to=u,e[tot].next=head[v],e[tot].w=a;
head[v]=tot++;
}
struct node
{
int to;
ll w;
friend bool operator<(node a,node b)
{
return a.w>b.w;
}
};
priority_queue<node>q;
void dij()
{
while(!q.empty()) q.pop();
for(int i=1; i<=n; i++) d[i]=(i==1)?0:INF;
q.push(node {1,d[1]});
while(!q.empty())
{
node tmp=q.top();
q.pop();
int u=tmp.to;
if(vis[u]) continue;
vis[u]=1;
for(int i=head[u]; i+1; i=e[i].next)
{
int v=e[i].to;
ll w=e[i].w;
if(d[v]>d[u]+w)
{
d[v]=d[u]+w;
if(!vis[v]) q.push(node{v,d[v]});
}
}
}
ans=min(ll(b),d
);
printf("%lld\n",ans);
}
void solve()//直接相连
{
d
=INF;
d[1]=0;
set<int>s1,s2;
while(!q.empty()) q.pop();
for(int i=2; i<=n; i++) s1.insert(i);
q.push(node{1,d[1]});
while(!q.empty())
{
node tmp=q.top();
q.pop();
int u=tmp.to;
for(int i=head[u]; i+1; i=e[i].next)
{
int v=e[i].to;
if(s1.count(v)==0) continue;
s1.erase(v);
s2.insert(v);
}
for(set<int>::iterator it=s1.begin(); it!=s1.end(); it++)
{
d[*it]=d[u]+1;
q.push(node{*it,d[*it]});
}
s1.swap(s2);
s2.clear();
}
printf("%lld\n",min(ll(a),d
*b));
}
int main()
{
int u,v;
while(~scanf("%d%d%d%d",&n,&m,&a,&b))
{
ans=INF;
init();
for(int i=1; i<=m; i++)
{
scanf("%d%d",&u,&v);
if((u==1&&v==n)||(u==n&&v==1)) ans=min(ans,ll(a));
add(u,v,a);
}
if(ans==INF) dij();//不相连
else solve();
}
return 0;
}

J - Right turn

 

看不懂题，不知所云，赛后发现是sb题。

直接引用一下别人博客吧：http://blog.csdn.net/a664607530/article/details/70815288