O - 胜利大逃亡(续)
Ignatius再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)……
这次魔王汲取了上次的教训，把Ignatius关在一个n*m的地牢里，并在地牢的某些地方安装了带锁的门，钥匙藏在地牢另外的某些地方。刚开始Ignatius被关在(sx,sy)的位置，离开地牢的门在(ex,ey)的位置。Ignatius每分钟只能从一个坐标走到相邻四个坐标中的其中一个。魔王每t分钟回地牢视察一次，若发现Ignatius不在原位置便把他拎回去。经过若干次的尝试，Ignatius已画出整个地牢的地图。现在请你帮他计算能否再次成功逃亡。只要在魔王下次视察之前走到出口就算离开地牢，如果魔王回来的时候刚好走到出口或还未到出口都算逃亡失败。Input
每组测试数据的第一行有三个整数n,m,t(2<=n,m<=20,t>0)。接下来的n行m列为地牢的地图，其中包括:
. 代表路
* 代表墙
@ 代表Ignatius的起始位置
^ 代表地牢的出口
A-J 代表带锁的门,对应的钥匙分别为a-j
a-j 代表钥匙，对应的门分别为A-J
每组测试数据之间有一个空行。Output
针对每组测试数据，如果可以成功逃亡，请输出需要多少分钟才能离开，如果不能则输出-1。
Sample
Inputcopy Outputcopy
运用了状压，因为要存储带每种钥匙的状态，且每种钥匙只有带与不带两种，所以用二进制存储每种状态
主要思想是
浅学一下位运算
//状压dp，位运算
#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
string mp[21];
int sx,sy;
int n,m,t;
struct node
{
int x,y,step;
int key;
};
int book[21][21][1025];//设置标记状态数组，设置三维数组是因为要分为有钥匙的状态
int dx[4][2]={-1,0,1,0,0,-1,0,1};
void bfs()
{
memset(book,0,sizeof(book));
queue<node>que;
node a;
a.x=sx;
a.y=sy;
a.step=0;
a.key=0;
book[sx][sy][0]=1;
que.push(a);
while(!que.empty()){
node b;
b=que.front();
que.pop();
for(int i=0;i<4;i++){
node num;
int tx=b.x+dx[i][0];
int ty=b.y+dx[i][1];
num.x=tx;
num.y=ty;
num.step=b.step+1;
num.key=b.key;
if(tx>=n||tx<0||ty>=m||ty<0) continue;
if(mp[tx][ty]!='*'&&book[tx][ty][num.key]==0&&num.step<t){
if(mp[num.x][num.y]=='^')
{
cout<<num.step<<endl;
return ;
}
if(mp[num.x][num.y]>='a'&&mp[num.x][num.y]<='j')
{
int tn=mp[num.x][num.y]-'a';
if((num.key&(1<<tn))==0)//如果没有这个钥匙则加入这个钥匙
num.key+=(1<<tn);
}
if(mp[num.x][num.y]>='A'&&mp[num.x][num.y]<='J')
{
int tn=mp[num.x][num.y]-'A';
if((num.key&(1<<tn))==0)//判断门是否有匹配的钥匙
continue;
}
book[num.x][num.y][num.key]=1;
que.push(num);
}
}
}
cout<<"-1"<<endl;
}
int main()
{
while(~scanf("%d%d%d",&n,&m,&t)){
for(int i=0;i<n;i++){
cin>>mp[i];
for(int j=0;j<m;j++){
if(mp[i][j]=='@'){
sx=i;
sy=j;
}
}
}
bfs();
}
}
L - DNA sequence
题目描述
21世纪是生物科技飞速发展的时代。我们都知道基因是由DNA组成的，而DNA的基本组成单位是A,C,G,T。在现代生物分子计算中，如何找到DNA之间的最长公共子序列是一个基础性问题。 但是我们的问题不是那么简单：现在我们给定了数个DNA序列，请你构造出一个最短的DNA序列，使得所有我们给定的DNA序列都是它的子序列。 例如，给定"ACGT","ATGC","CGTT","CAGT",你可以构造的一个最短序列为"ACAGTGCT"，但是需要注意的是，这并不是此问题的唯一解。输入
第一行含有一个数t，代表数据组数。 每组数据的第一行是一个数n，代表给定的DNA序列数量；接下来的n行每行一个字符串s，代表给定的n个DNA序列。 1<=n<=8，1<=|s|<=5输出
对于每一组数据，输出一行中含有一个数，代表满足条件的最短序列的长度。样例输入
1 4 ACGT ATGC CGTT CAGT样例输出
8
深度迭加搜索，为了防止一直搜索下去且我们要得到深度最小的答案，我们可以设置一个最大深度进行限制，当目前深度得不到想要的答案时，再加深最大深度，直到搜索到正确答案，同时此答案也是深度最小的答案，为了获取最短公共子序列，我们可以用深度迭加搜索。
//迭代加深搜索
#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
string s[10];
int deep;
int n;
int ans;
int Size[10];
char dna[4]={'A','C','G','T'};
void dfs(int cnt,int len[])//匹配到的深度，匹配到的每个字符串位置
{
if(cnt>deep) return;//大于给定的最大深度则递归结束
int maxlen=0;//剩下还要匹配的字符串最小所需要的深度即剩下字符串的最长长度
for(int i=0;i<n;i++){
if(maxlen<Size[i]-len[i]){
maxlen=Size[i]-len[i];
}
}
if(maxlen==0){//当所有字符串匹配完时，结束搜索
ans=cnt;
return;
}
if(maxlen+cnt>deep) return;//剪枝
for(int i=0;i<4;i++){//进行匹配
int p[10],flag=0;
for(int j=0;j<n;j++){
if(s[j][len[j]]==dna[i]){
flag=1;
p[j]=len[j]+1;
}
else p[j]=len[j];
}
if(flag==1) dfs(cnt+1,p);
if(ans!=-1) break;
}
}
int main()
{
int t;
cin>>t;
while(t--){
cin>>n;
int Maxs=0;
for(int i=0;i<n;i++){
cin>>s[i];
Size[i]=s[i].length();
if(Maxs<s[i].length()){
Maxs=s[i].length();//设定初始最大搜索深度为最长字符串的长度
}
}
int pos[10]={0};//记录每个字符串匹配到的位置
ans=-1;
deep=Maxs;
while(1){
dfs(0,pos);
if(ans!=-1) break;//若匹配成功则结束搜索
deep++;//加深最大深度
}
cout<<ans<<endl;
}
}
N - 旅行编码这么多天后，Acmer先生想好好休息一下。所以旅行是最好的选择！他决定访问n个城市（他坚持要看到所有的城市！他不介意哪个城市是他的起点，因为超人一开始可以把他带到任何城市，但只有一次），当然这里也有m条路，像往常一样收费。但是阿克默先生很容易感到无聊，以至于他不想去一个城市超过两次！而且他是如此刻薄，以至于他想尽量减少总费用！你看，他很懒惰。所以他向你寻求帮助。题意：给你一个图，从一个点到另一个点有路，需要花费。 起点是任意的，要求每个点最多走两次，把所有的点遍历完一遍，费用最小
输入
有几个测试用例，第一行是两个中间人n（1<=n<=10）和m，这意味着他需要访问n个城市，并且有m条他可以选择的道路，然后m条线跟随，每条线将包括三个中间人a，b和c（1<=a，b<=n），这意味着a和b之间有一条路，成本当然是c。的“文件”。
输出
输出他应该支付的最低费用，如果他找不到这样的路线，则输出-1。
示例输入
2 1 1 2 100 3 2 1 2 40 2 3 50 3 3 1 2 3 1 3 4 2 3 10示例输出
100 90 7
因为去一个城市可以去到两次，所以对每个城市，我们有三种状态，可以用三进制存储每种状态，也是状压。
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
const int inf=0x3f3f3f3f;
const int N=20;
int n,m,vis[N];
int three[11],dig[60000][20];
int mp[N][N],ans,dp[60000][20];
void init(){
three[0]=1;
for(int i=1;i<=10;i++)
three[i]=three[i-1]*3;
int k;
for(int i=0;i<three[10];i++){
k=i;
for(int j=0;j<10;j++){
dig[i][j]=k%3;
k/=3;
}
}
}
int main(){
int a,b,c;
init();
while(~scanf("%d%d",&n,&m)){
memset(mp,inf,sizeof(mp));
memset(dp,inf,sizeof(dp));
while(m--){
cin>>a>>b>>c;
mp[a-1][b-1]=mp[b-1][a-1]=min(mp[a-1][b-1],c);
}
for(int i=0;i<n;i++)
dp[three[i]][i]=0;
int ans=inf,flag=1;
for(int sta=0;sta<three[n];sta++){
flag=1;
for(int i=0;i<n;i++){
if(dig[sta][i]==0)flag=0;
if(dp[sta][i]==inf)continue;
for(int j=0;j<n;j++){
if(mp[i][j]==inf||dig[sta][j]==2)continue;
dp[sta+three[j]][j]=min(dp[sta+three[j]][j],dp[sta][i]+mp[i][j]);
}
}
if(!flag)continue;
for(int i=0;i<n;i++)
ans=min(ans,dp[sta][i]);
}
if(ans==inf)cout<<"-1"<<endl;
else cout<<ans<<endl;
}
}
扫一扫
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
