Codeforces #290 Div. 1 简要题解

最新推荐文章于 2022-07-18 21:03:46 发布

qpswwww

最新推荐文章于 2022-07-18 21:03:46 发布

阅读量1k

点赞数

分类专栏：比赛题解 CodeForces 比赛赛题

本文链接：https://blog.csdn.net/qpswwww/article/details/46272891

版权

比赛赛题同时被 3 个专栏收录

49 篇文章 0 订阅

订阅专栏

比赛题解

42 篇文章 0 订阅

订阅专栏

CodeForces

37 篇文章 1 订阅

订阅专栏

A. Fox And Names

题目链接

http://codeforces.com/contest/512/problem/A

题目大意

给你 $n$ 个按照字典序排序的单词。要你构建一个单词表的置换(如将原来的单词里的’a’置换成’z’)，使得按照单词表置换后的所有单词满足字典序排序

思路

很裸的拓扑排序题。
因为已经确定了所有单词的字典序，于是可以确定出原文中每个字母之间的相对关系，在图中连边，做拓扑排序即可。

问题在于如何判无解。
显然如果最后拓扑排序找出的单词表置换长度并不是26，即为无解。

若原文中出现这样的情况：

ooxxxooxx…xxooTTTTT (单词A)
……
ooxxxooxx…xxoo (单词B)
(A

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXV 30
#define MAXE 21000

using namespace std;

struct edge
{
    int u,v,next;
}edges[MAXE];

int head[MAXV],nCount=0;
int inDegree[MAXV];

void AddEdge(int U,int V)
{
    inDegree[V]++;
    edges[++nCount].u=U;
    edges[nCount].v=V;
    edges[nCount].next=head[U];
    head[U]=nCount;
}

int q[MAXE*2];
char ans[MAXE];
int top=0;

bool TopoSort()
{
    int h=0,t=0;
    bool flag=false;
    for(int i=1;i<=26;i++)
        if(!inDegree[i])
        {
            q[t++]=i;
            flag=true;
            ans[++top]='a'+i-1;
        }
    if(!flag) return false;
    while(h<t)
    {
        int u=q[h++];
        for(int p=head[u];p!=-1;p=edges[p].next)
        {
            int v=edges[p].v;
            inDegree[v]--;
            if(!inDegree[v])
            {
                flag=true;
                q[t++]=v;
                ans[++top]='a'+v-1;
            }
        }
    }
    ans[++top]=0;
}

char str[110][MAXE];
bool mp[30][30];

int main()
{
    memset(head,-1,sizeof(head));
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%s",str[i]+1);
    bool flag=true; //flag=false找不到可行解
    for(int i=1;i<=n;i++)
        for(int j=1;j<i;j++)
            for(int k=1;str[j][k];k++)
            {
                if(!str[i][k])
                {
                    flag=false;
                    break;
                }
                if(str[i][k]!=str[j][k])
                {
                    if(!mp[str[j][k]-'a'+1][str[i][k]-'a'+1]) AddEdge(str[j][k]-'a'+1,str[i][k]-'a'+1);
                    mp[str[j][k]-'a'+1][str[i][k]-'a'+1]=1;
                    break;
                }
            }
    if(!flag)
    {
        printf("Impossible\n");
        return 0;
    }
    TopoSort();
    if(strlen(ans+1)!=26) printf("Impossible\n");
    else printf("%s\n",ans+1);
    return 0;
}

B. Fox And Jumping

题目链接

http://codeforces.com/contest/512/problem/B

题目大意

给你 $n$ 个数字以及每个数字的价格，要你花最少的钱买一些数字，使得买来的数字通过加减操作(每个数字可以使用多次)得到任意的数。

思路

假如我们选择的数字是 $S_1,S_2,...S_m$ ，那么如果 $\gcd (S_1,S_2,...S_m)=1$ ，则这些数字可以满足题目要求。

因为要想凑出任意大小的数字 $t$ ，我们只需要通过某种方案凑出一个数字1，然后重复 $t$ 次这样的方案就够了。设 $S_i$ 用了 $x_i$ 次加法/减法(加法的话 $x_i$ 为正，减法的话为负)。则 $S_1x_1+S_2x_2...+S_mx_m=1$ ，即

S 1 x 1 + S 2 x 2 . . . + S m x m = gcd (S 1, S 2, . . . S m) = 1

$S_1x_1+S_2x_2...+S_mx_m=\gcd (S_1,S_2,...S_m)=1$
那么我们可以用map数组

f[i][g] $f[i][g]$ 来做DP，代表DP到第

i $i$ 个数字时，得到gcd的值为

g $g$ 的最小花费，DP方程为

f [i] [g] = min {f [i] [g], f [i - 1] [g]}

$f[i][g]=\min \{ f[i][g],f[i-1][g]\}$

f [i] [gcd (g, L i)] = min {f [i] [gcd (g, L i)], f [i - 1] [g] + C i}

$f[i][\gcd(g,L_i)]=\min \{f[i][\gcd(g,L_i)],f[i-1][g]+C_i\}$

f [i] [L i] = min {f [i] [L i], C i}

$f[i][L_i]=\min \{f[i][L_i],C_i\}$

最终的答案为 $f[n][1]$ 。
注意要滚存优化，否则肯定MLE。

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <map>

#define MAXN 310

using namespace std;

int L[MAXN],C[MAXN],n;

int gcd(int a,int b)
{
    if(!b) return a;
    return gcd(b,a%b);
}

map<int,int>mp[2]; //mp[now][i]=当前gcd()值为i的集合的C值之和最小值
map<int,int>::iterator it;
int now=1,pre=0;

void update(int cur,int a,int b)
{
    if(mp[cur].count(a))
        mp[cur][a]=min(mp[cur][a],b);
    else
        mp[cur][a]=b;
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&L[i]);
    for(int i=1;i<=n;i++)
        scanf("%d",&C[i]);
    mp[pre][L[1]]=C[1];
    for(int i=2;i<=n;i++)
    {
        mp[now].clear();
        mp[now][L[i]]=C[i]; //!!!!
        for(it=mp[pre].begin();it!=mp[pre].end();it++)
        {
            int a=it->first,b=it->second;
            update(now,a,b);
            update(now,gcd(a,L[i]),b+C[i]);
        }
        swap(now,pre);
    }
    if(mp[pre].count(1)) printf("%d\n",mp[pre][1]);
    else printf("-1\n");
    return 0;
}

C. Fox And Dinner

题目链接

http://codeforces.com/contest/512/problem/C

题目大意

给你 n <script type="math/tex" id="MathJax-Element-19">n</script>个数字(每个数字均大于等于2)，每个数字大小要你将他们排成若干个环，使得每个环上任意两个相邻的数字之和为质数，并且每个环的大小大于等于3，构造一组可行解。

思路

由于每个数字均大于等于2，因此相邻两个数字要想和为质数，则和必须得是奇数(无法构成质数2)，肯定就是一个奇数+一个偶数，那么我们可以构造一个类似于二分图的最大流模型，限制每个奇数点只能和两个偶数点链接，每个偶数点也只能和两个奇数点链接，那么让源点S和每个奇数点连容量为2的边，每个偶数点和原点T连容量为2的边，若奇数点i和偶数点j的和为奇数，就从点i向j连容量为1的边，然后在这个图上跑最大流，若最大流流量为n，则表明有解，我们只需要将源点和汇点无视掉，在其他点里找出每个联通块，每个联通块就代表了一个环。

注意找联通块时不仅要标记点是否访问过，也要标记边是否访问过，根据当前的边是正向边还是反向边进行特判来判断当前的边是否是满流的。

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXV 500
#define MAXE 201000
#define INF 0x3f3f3f3f

using namespace std;

int S,T,n;

struct edge
{
    int u,v,cap,next;
}edges[MAXE];

int head[MAXV],nCount=1;

void AddEdge(int U,int V,int C)
{
    edges[++nCount].u=U;
    edges[nCount].v=V;
    edges[nCount].cap=C;
    edges[nCount].next=head[U];
    head[U]=nCount;
}

void add(int U,int V,int C)
{
    AddEdge(U,V,C);
    AddEdge(V,U,0);
}

int q[MAXE*2];
int layer[MAXV];

bool CountLayer()
{
    memset(layer,-1,sizeof(layer));
    int h=0,t=1;
    q[h]=S;
    layer[S]=1;
    while(h<t)
    {
        int u=q[h++];
        for(int p=head[u];p!=-1;p=edges[p].next)
        {
            int v=edges[p].v;
            if(layer[v]==-1&&edges[p].cap)
            {
                layer[v]=layer[u]+1;
                q[t++]=v;
            }
        }
    }
    return layer[T]!=-1;
}

int DFS(int u,int flow)
{
    int used=0;
    if(u==T) return flow;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(layer[v]==layer[u]+1&&edges[p].cap)
        {
            int tmp=DFS(v,min(edges[p].cap,flow-used));
            edges[p].cap-=tmp;
            edges[p^1].cap+=tmp;
            used+=tmp;
            if(used==flow) break;
        }
    }
    if(!used) layer[u]=-1; //!!!!!
    return used;
}

int Dinic()
{
    int maxflow=0;
    while(CountLayer())
        maxflow+=DFS(S,INF);
    return maxflow;
}

bool isPrime[21000];

void getPrime()
{
    memset(isPrime,true,sizeof(isPrime));
    isPrime[1]=false;
    isPrime[2]=true;
    for(int i=2;i<21000;i++)
    {
        if(!isPrime[i]) continue;
        for(int j=i+i;j<21000;j+=i)
            isPrime[j]=false;
    }
}

int a[MAXV];
bool vis[MAXV];
int sol[MAXV][MAXV];

void DFS2(int id,int u,int fa)
{
    vis[u]=true;
    sol[id][++sol[id][0]]=u;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(v==fa) continue;
        if(v==S||v==T) continue;
        if(vis[v]) continue;
        if(a[u]%2)
        {
            if(!edges[p].cap)
            {
                edges[p].cap++;
                DFS2(id,v,u);
            }
        }
        if(!(a[u]%2))
        {
            if(edges[p].cap)
            {
                edges[p].cap--;
                DFS2(id,v,u);
            }
        }
        //DFS2(id,v,u);
        //break;
    }
}

int main()
{
    getPrime();
    memset(head,-1,sizeof(head));
    S=MAXV-2,T=MAXV-1;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)
    {
        if(a[i]%2)
            add(S,i,2);
        else
            add(i,T,2);
    }
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
        {
            //if(i==1&&j==2)
            //    printf("dd\n");
            int x,y;
            //x是奇数点，y是偶数点
            if(a[i]%2&&(!(a[j]%2)))
            {
                x=i;
                y=j;
            }
            else if((!(a[i]%2))&&a[j]%2)
            {
                x=j;
                y=i;
            }
            else continue;
            if(isPrime[a[x]+a[y]])
                add(x,y,1);
        }
    int maxflow=Dinic(),top=0;
    if(maxflow==n)
    {
        for(int i=1;i<=n;i++)
        {
            if(!vis[i])
            {
                top++;
                DFS2(top,i,-1);
            }
        }
        printf("%d\n",top);
        for(int i=1;i<=top;i++)
        {
            printf("%d",sol[i][0]);
            for(int j=1;j<=sol[i][0];j++)
                printf(" %d",sol[i][j]);
            printf("\n");
        }
    }
    else printf("Impossible\n");
    return 0;
}

qpswwww

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces #290 Div. 1 简要题解

A. Fox And Names题目链接http://codeforces.com/contest/512/problem/A题目大意给你nn个按照字典序排序的单词。要你构建一个单词表的置换(如将原来的单词里的’a’置换成’z’)，使得按照单词表置换后的所有单词满足字典序排序思路很裸的拓扑排序题。因为已经确定了所有单词的字典序，于是可以确定出原文中每个字母之间的相对关系，在图中连边，做拓扑排序即
复制链接

扫一扫