Codeforces #290 Div. 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 個數字以及每個數字的價格，要你花最少的錢買一些數字，使得買來的數字通過加減操作(每個數字可以使用多次)得到任意的數。

思路

假如我們選擇的數字是S1,S2,...Sm ，那麼如果gcd(S1,S2,...Sm)=1 ，則這些數字可以滿足題目要求。

因爲要想湊出任意大小的數字t ，我們只需要通過某種方案湊出一個數字1，然後重複t 次這樣的方案就夠了。設Si 用了xi 次加法/減法(加法的話xi 爲正，減法的話爲負)。則S1x1+S2x2...+Smxm=1 ，即

S1x1+S2x2...+Smxm=gcd(S1,S2,...Sm)=1

那麼我們可以用map數組f[i][g] 來做DP，代表DP到第i 個數字時，得到gcd的值爲g 的最小花費，DP方程爲

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

f[i][gcd(g,Li)]=min{f[i][gcd(g,Li)],f[i−1][g]+Ci}

f[i][Li]=min{f[i][Li],Ci}

最終的答案爲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 個數字(每個數字均大於等於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;
}