文章目录
空间bfs
题意
zjm被困在一个三维的空间中,现在要寻找最短路径逃生！
空间由立方体单位构成。
zjm每次向上下前后左右移动一个单位需要一分钟，且zjm不能对角线移动。
空间的四周封闭。zjm的目标是走到空间的出口。
是否存在逃出生天的可能性？如果存在，则需要多少时间？
输入
输入第一行是一个数表示空间的数量。
每个空间的描述的第一行为L，R和C（皆不超过30）。
L表示空间的高度，R和C分别表示每层空间的行与列的大小。
随后L层，每层R行，每行C个字符。
每个字符表示空间的一个单元。’#‘表示不可通过单元，’.‘表示空白单元。
zjm的起始位置在’S’，出口为’E’。每层空间后都有一个空行。
L，R和C均为0时输入结束。
输出
每个空间对应一行输出。
如果可以逃生，则输出如下
Escaped in x minute(s).
x为最短脱离时间。
如果无法逃生，则输出如下
Trapped!
样例输入
3 4 5
S….
.###.
.##…
###.#
##.##
##…
#.###
####E
1 3 3
S##
#E#
0 0 0
样例输出
Escaped in 11 minute(s).
Trapped!
思路
L，R和C分别对应一个空间体的高 行 列，进行分割，每一个是一个小方格（x,y,z），然后再空间上进行bfs搜索，注意：偏移量分为上下左右前后六个方向。
总结
该题是空间上的迷宫问题，在空间上运用bfs即可。
代码
#include<queue>
#include<iostream>
#include<cstring>
using namespace std;
int dx[]={0,0,0,0,1,-1};//偏移量
int dy[]={0,0,1,-1,0,0};
int dz[]={1,-1,0,0,0,0};
bool vis[40][40][40];int dis[40][40][40];
int sx,sy,sz,tx,ty,tz;int L,R,C;bool flag;
struct point
{
int x,y,z;
};
void bfs()
{ queue<point>q; vis[sx][sy][sz]=1;
point p;p.x=sx;p.y=sy;p.z=sz;q.push(p);memset(dis,0,sizeof(dis));
while(!q.empty())
{ point now=q.front();q.pop();
if(now.x==tx&&now.y==ty&&now.z==tz) //特判是否到达出口
{ cout<<"Escaped in "<<dis[tx][ty][tz]<<" "<<"minute(s)."<<endl;flag=1;
return;
}
for(int i=0;i<6;i++)//循环扩展
{
int x=now.x+dx[i];int y=now.y+dy[i];int z=now.z+dz[i];
if(vis[x][y][z]==0&&x>=0&&x<R&&y>=0&&y<C&&z>=0&&z<L)
{ point pp;pp.x=x;pp.y=y;pp.z=z;
q.push(pp);vis[x][y][z]=1;dis[x][y][z]=dis[now.x][now.y][now.z]+1;
}
}
}
}
int main()
{
//freopen("in.txt","r",stdin);
while(1)
{
cin>>L>>R>>C;
if(!L&&!R&&!C)
break;flag=0;
memset(vis,0,sizeof(vis));
for(int k=0;k<L;k++)
{
for(int i=0;i<R;i++)
{
for(int j=0;j<C;j++)
{
char num;cin>>num;
if(num=='#')
vis[i][j][k]=1;
else
{
vis[i][j][k]=0;
if(num=='S')
sx=i,sy=j,sz=k;
else if(num=='E') tx=i,ty=j,tz=k;
}
}
}
}
bfs();
if(!flag)cout<<"Trapped!"<<endl;
}
return 0;
}
最长括号匹配
题意
We give the following inductive definition of a “regular brackets” sequence:
the empty sequence is a regular brackets sequence,
if s is a regular brackets sequence, then (s) and [s] are regular brackets sequences, and
if a and b are regular brackets sequences, then ab is a regular brackets sequence.
no other sequence is a regular brackets sequence
For instance, all of the following character sequences are regular brackets sequences:
(), [], (()), ()[], ()[()]
while the following character sequences are not:
(, ], )(, ([)], ([(]
Given a brackets sequence of characters a1a2 … an, your goal is to find the length of the longest regular brackets sequence that is a subsequence of s. That is, you wish to find the largest m such that for indices i1, i2, …, im where 1 ≤ i1 < i2 < … < im ≤ n, ai1ai2 … aim is a regular brackets sequence.
Given the initial sequence ([([]])], the longest regular brackets subsequence is [([])].
输入
The input test file will contain multiple test cases. Each input test case consists of a single line containing only the characters (, ), [, and ]; each input test will have length between 1 and 100, inclusive. The end-of-file is marked by a line containing the word “end” and should not be processed.
输出
For each input case, the program should print the length of the longest possible regular brackets subsequence on a single line.
样例输入
((()))
()()()
([]])
)[)(
([][][)
end
样例输出
6
6
4
0
6
思路
利用dp，小集合->大集合
状态定义：f[i][j]表示区间[i,j]的最大合法序列长度
分析 一个合法的括号序列
• 1. 空序列合法
• 2. S合法，那么(S)和[S]合法
• 3. 假设A和B合法，那么AB合法
转移过程如下：
if((str[i]=='('&&str[j]==')')||(str[i]=='['&&str[j]==']'))
f[i][j]=f[i+1][j-1]+2;
for(int k=i;k<j;k++)
f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]);
总结
这属于括号匹配问题，主要分清楚几种情况：
若S形如[S’]或(S’) ,
若S形如[S’或(S’ 或S’]或S’)，
代码
#include<iostream>
#include<cstring>
#include<string>
#define inf 200
using namespace std;
int main()
{
int f[150][150];
while(1)
{ string str;getline(cin,str);
if(str=="end") break;
int n=str.size();
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
{
if(i>=j) f[i][j]=0;
else f[i][j]=-inf;
}
for(int len=2;len<=n;len++)
{
for(int i=0,j=len-1;j<n;i++,j++)
{
if((str[i]=='('&&str[j]==')')||(str[i]=='['&&str[j]==']'))
f[i][j]=f[i+1][j-1]+2;
for(int k=i;k<j;k++)
f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]);
}
}cout<<f[0][n-1]<<endl;
}return 0;
}
最大m子段和–东东扫楼
题意
东东每个学期都会去寝室接受扫楼的任务，并清点每个寝室的人数。
每个寝室里面有ai个人(1<=i<=n)。从第i到第j个宿舍一共有sum(i,j)=a[i]+…+a[j]个人
这让宿管阿姨非常开心，并且让东东扫楼m次，每一次数第i到第j个宿舍sum(i,j)
问题是要找到sum(i1, j1) + … + sum(im,jm)的最大值。且ix <= iy <=jx和ix <= jy <=jx的情况是不被允许的。也就是说m段都不能相交。
注：1 ≤ i ≤ n ≤ 1e6 , -32768 ≤ ai ≤ 32767 人数可以为负数。。。。(1<=n<=1000000)
输入
输入m，输入n。后面跟着输入n个ai 处理到 EOF
输出
输出最大和
样例输入
1 3 1 2 3
2 6 -1 4 -2 3 -2 3
样例输出
6
8
思路
该题同理：f[j][i]如上所述，对于新加入的元素，有两种情况：1）加到上一次的最后一段。
2）独立成段。
转移方程：f[j][i]=max(f[j−1][i]+a[i],max{f[k][i−1]}+a[i]) （1<=k<=j-1)
注意一点，这里的空间报表了，所以对空间进行优化，可以考虑滚动数组：
可以发现，转移方程中的j这一维总是从上一次的j-1转移，而i不变，而且f[j - 1][k]也只需要上一次的最大值即可，那么就可以使用滚动数组进行如下优化：
1. 去掉i这一维， 并把i这一维提到外循环->保证j-1到j都是i这一维。 数组只需要f[N]
2.用npmax[j - 1]来表示max{f[k][i−1]}(1<=k<=j-1)， 每次内循环（j）更新， 以供下一个外循环（i）使用。
总结
对于形如“求将x，分成y份的最值”问题，通常采用dp都为 f[j][i]，表示将前j个元素分成i份的最值。
反思
注意数据范围
代码
#include<cstdio>
#include<algorithm>
#include<cstring>
#define inf 100000000
using namespace std;
long long f[1000010];
long long npmax[1000010];
int a[1000010];
int main()
{
int m,n;
while(~scanf("%d%d",&m,&n))
{
for(int i = 1; i <= n; i++)
scanf("%d",&a[i]);
memset(f,0,sizeof(f));
memset(npmax,0,sizeof(npmax));long long np;
for(int i = 1; i <= m; i++)//分为i段
{ np=-inf;
for(int j = i; j <= n; j++)//第j个数字
{
f[j] = max(f[j-1]+a[j],npmax[j-1]+a[j]);
npmax[j-1]=np;
np=max(np,f[j]);
}
}
printf("%ld\n",np);
}
return 0;
}
状态压缩-分配作业时间
题意
马上假期就要结束了，zjm还有 n 个作业，完成某个作业需要一定的时间，而且每个作业有一个截止时间，若超过截止时间，一天就要扣一分。
zjm想知道如何安排做作业，使得扣的分数最少。
Tips: 如果开始做某个作业，就必须把这个作业做完了，才能做下一个作业。
输入
有多组测试数据。第一行一个整数表示测试数据的组数
第一行一个整数 n(1<=n<=15)
接下来n行，每行一个字符串(长度不超过100) S 表示任务的名称和两个整数 D 和 C，分别表示任务的截止时间和完成任务需要的天数。
这 n 个任务是按照字符串的字典序从小到大给出。
输出
每组测试数据，输出最少扣的分数，并输出完成作业的方案，如果有多个方案，输出字典序最小的一个
样例输入
2
3
Computer 3 3
English 20 1
Math 3 2
3
Computer 3 3
English 6 3
Math 6 3
样例输出
2
Computer
Math
English
3
Computer
English
Math
思路
数据范围非常小（1 ≤ 𝑛 ≤ 15）
• 考虑状态压缩
• 令 S 表示当前完成的作业集合
状态定义
• f[S] 表示完成 S 作业集合后被扣的最少分数
转移方程
• sum = S 作业集合对应的总时间
• f[S|(1<<x)] = f[S] + tmp（作业 x 被扣的分数）
• c[x] = 作业 x 完成所需时间
• d[x] = 作业 x 的 DDL
• tmp = max ( sum + c[x] – d[x], 0 )
如何保证字典序最小
• 首先对作业按字典序排序
• 状态 S 越小则其对应的字典序越小
• 因此 S 从小到大枚举，x 从小到大枚举即可保证字典序
最小
如何输出方案
• 对每个状态 S 记录 pre[S] 表示其对应的最后一个作业
• pre[S] 递归输出
总结
• DP 主要难点之一在于状态的表示
• 尤其对于某些题目来说，状态尤其复杂，如果使用先前的多维数组
来表示，将会导致数组维度非常大，可操作性非常低
• 因此我们考虑使用一些编码技术，比如二进制编码，用一个数字来表示一个状态，实现状态压缩的目的
• 在动态规划中，使用特定编码技术来压缩状态即为状压 DP
代码
#include<iostream>
#include<vector>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#define inf 1000000
using namespace std;
int f[100000];pair<int,int> np[50000];
int n;
struct zuoye
{
string name;
int c;int d;
bool operator<(const zuoye a)
{
return name<a.name;
}
};
vector<zuoye>q;
int solve(int s,int sum)
{
if(s==0) return f[s]=0;
if(f[s]!=inf)return f[s];int k=s;
for(int j=0;j<n;j++)
{
if(s&(1<<j))
{
int temp=max(sum-q[n-1-j].d,0);
f[s^(1<<j)]=solve(s^(1<<j),sum-q[n-1-j].c);
if(f[s]>f[s^(1<<j)]+temp)
{
f[s]=f[s^(1<<j)]+temp;k=j;
}
}
}np[s]=make_pair(s^(1<<k),n-1-k);
return f[s];
}
void print(int s)
{ if(np[s].first==0)
{
cout<<q[np[s].second].name<<endl;return;
}
print(np[s].first);
cout<<q[np[s].second].name<<endl;
}
int main()
{ int num;cin>>num;
while(num--)
{ while(q.size())q.pop_back();
memset(np,0,sizeof(np));
cin>>n;int sum=0;
for(int i=1;i<=n;i++)
{
zuoye p;cin>>p.name>>p.d>>p.c;q.push_back(p);sum=sum+p.c;
}sort(q.begin(),q.end());
for(int i=0;i<pow(2,n);i++)
f[i]=inf;
cout<<solve(pow(2,n)-1,sum)<<endl;
print(pow(2,n)-1);
}return 0;
}
797
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
