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
题目大意
给你
思路
假如我们选择的数字是 S1,S2,...Sm ,那么如果 gcd(S1,S2,...Sm)=1 ,则这些数字可以满足题目要求。
因为要想凑出任意大小的数字
t
,我们只需要通过某种方案凑出一个数字1,然后重复
那么我们可以用map数组 f[i][g] 来做DP,代表DP到第 i 个数字时,得到gcd的值为
最终的答案为
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;
}