Codeforces Round #290 (Div. 2)

Codeforces Round #290 (Div. 2)

 

C题：给你n个字符串要求你重新排列小写字母的字典序，要求使给的字符串按字典序从小到大排列。

 

思路：很容易想到相邻两串找到第一个不相同的建边，然后跑拓扑序就好啦。

 

#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pii pair<int,int>
#define read(x) scanf("%d",&x)
#define sread(x) scanf("%s",x)
#define dread(x) scanf("%lf",&x)
#define lread(x) scanf("%lld",&x)
using namespace std;

typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const int N=2000+7;
const int M=12;

char s[105][105];
int len[105],topo[30],n,tot;
int vis[30];

vector<int> edge[30];

bool dfs(int u)
{
    vis[u]=-1;
    for(int v:edge[u])
    {
        if(vis[v]==-1)
            return false;
        if(vis[v]==0 && !dfs(v))
            return false;
    }
    topo[tot--]=u;
    vis[u]=1;
    return true;
}
bool topo_sort()
{
    tot=25;
    for(int i=0;i<26;i++)
        if(!vis[i] && !dfs(i))
            return false;
    return true;
}
int main()
{
    read(n);
    for(int i=1;i<=n;i++)
        sread(s[i]+1),len[i]=strlen(s[i]+1);

    for(int i=1;i<n;i++)
    {
        bool flag=false;
        for(int j=1;j<=len[i] && j<=len[i+1];j++)
        {
            if(s[i][j]!=s[i+1][j])
            {
                edge[s[i][j]-'a'].push_back(s[i+1][j]-'a');
                flag=true;
                break;
            }
        }
        if(!flag && len[i]>len[i+1])
        {
            puts("Impossible");
            return 0;
        }
    }
    if(!topo_sort())
        puts("Impossible");
    else
    {
        for(int i=0;i<26;i++)
            printf("%c",topo[i]+'a');
        puts("");
    }
    return 0;
}
/*
*/

 

D题：有n个距离，选择一个距离都有一个花费，当你选择一条距离x的时候，你就能向左或者向右跳x格，问你最少花费多少就能

跳到数轴上任意位置。

 

思路：题目可以转化为要你选出一些距离，这些距离的gcd为1，最小花费为多少。 然后用map dp就行了。 dp[ i ]表示gcd为 i 时的最小花费。

#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define ll long long
#define pll pair<ll,ll>
#define pil pair<int,ll>
#define pli pair<ll,int>
#define pii pair<int,int>
#define read(x) scanf("%d",&x)
#define sread(x) scanf("%s",x)
#define dread(x) scanf("%lf",&x)
#define lread(x) scanf("%lld",&x)
using namespace std;

const int N=300+7;
const int M=2e6+7;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const int mod=1e9+7;

int n;
pii a[N];
map<int,int> dp;
int main()
{
    read(n);
    for(int i=1;i<=n;i++)
        read(a[i].fi);

    for(int i=1;i<=n;i++)
        read(a[i].se);

    dp[0]=0;
    map<int,int> :: iterator it;
    for(int i=1;i<=n;i++)
    {
        int x=a[i].fi;
        int c=a[i].se;
        for(it=dp.begin(); it!=dp.end(); it++)
        {
            int y=it->first;
            int d=__gcd(x,y);
            int tmp=it->second+c;
            if(dp[d] && dp[d]<tmp)
                continue;
            dp[d]=tmp;
        }
    }
    if(!dp[1])
        puts("-1");
    else
        printf("%d\n",dp[1]);
    return 0;
}
/*
*/

 

E题：让你把n个数安排到任意个圆桌上，要求相邻的两个数加起来是素数。

 

思路：最大流，因为没有1，所以只有奇数和偶数相邻时才能为素数。 然后我们从原点向奇数建权值为2的边，偶数向

汇点建权值为2的边，然后加起来是素数的对应的奇数偶数之间建一条权值为1的边，跑最大流，看最大流是不是n。

#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pii pair<int,int>
#define read(x) scanf("%d",&x)
#define sread(x) scanf("%s",x)
#define dread(x) scanf("%lf",&x)
#define lread(x) scanf("%lld",&x)
using namespace std;

typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const int N=200+7;
const int M=12;

int n,S,T,tot,cnt,a[N],head[N],level[N];
bool vis[N];

vector<int> vec[N],ans[N];

struct edge
{
    int f,t,v,nx;
}e[N*N];

void add(int f,int t,int v)
{
    e[tot].f=f; e[tot].t=t; e[tot].v=v;
    e[tot].nx=head[f]; head[f]=tot++;

    e[tot].f=t; e[tot].t=f; e[tot].v=0;
    e[tot].nx=head[t]; head[t]=tot++;
}

bool bfs()
{
    memset(level,0,sizeof(level));
    queue<int> Q;
    Q.push(S); level[S]=1;

    while(!Q.empty())
    {
        int u=Q.front(); Q.pop();
        if(u==T)
            return true;

        for(int i=head[u];~i;i=e[i].nx)
        {
            int v=e[i].t;
            if(level[v] || !e[i].v)
                continue;

            level[v]=level[u]+1;
            Q.push(v);
        }

    }
    return false;
}

int dfs(int u,int p)
{
    if(u==T)
        return p;
    int ret=0;
    for(int i=head[u];~i;i=e[i].nx)
    {
        int v=e[i].t;
        if(level[v]!=level[u]+1 || !e[i].v)
            continue;
        int f=dfs(v,min(p-ret,e[i].v));
        ret+=f;
        e[i].v-=f;
        e[i^1].v+=f;
        if(ret==p)
            break;
    }
    if(!ret)
        level[u]=0;
    return ret;
}

int Dinic()
{
    int ans=0;
    while(bfs())
        ans+=dfs(S,inf);
    return ans;
}

void cal(int u,int op)
{
    vis[u]=true;
    ans[op].push_back(u);
    for(int v:vec[u])
        if(!vis[v])
            cal(v,op);
}

bool is_prime(int x)
{
    for(int i=2;i*i<=x;i++)
        if(x%i==0)
            return false;
    return true;
}

int main()
{
    memset(head,-1,sizeof(head));
    read(n);
    for(int i=1;i<=n;i++)
        read(a[i]);

    S=0,T=n+1;

    for(int i=1;i<=n;i++)
    {
        if(a[i]&1)
            add(S,i,2);
        else
            add(i,T,2);
    }

    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(a[i]&1 && is_prime(a[i]+a[j]))
                add(i,j,1);

    int ret=Dinic();

    if(ret!=n)
        puts("Impossible");
    else
    {
        for(int i=0;i<tot;i++)
        {
            if(e[i].f==S || e[i].t==S || e[i].f==T || e[i].t==T)
                continue;

            if(a[e[i].f]%2==1 && e[i].v==0)
            {
                vec[e[i].f].push_back(e[i].t);
                vec[e[i].t].push_back(e[i].f);
            }
        }
        for(int i=1;i<=n;i++)
            if(!vis[i])
                cal(i,cnt++);
        printf("%d\n",cnt);
        for(int i=0;i<cnt;i++)
        {
            printf("%d ",ans[i].size());
            for(int j:ans[i])
                printf("%d ",j);
            puts("");
        }
    }
    return 0;
}
/*
*/