有一个如图所示的圆环，初始时指针指在a处。给定一个字符串，问最少转动圆环多少次，才可以得到这个字符串
样例输入：
一串字符串
zeus
样例输出:
一个数字，即转动圆环的次数
18
很简单的一个模拟题，从头到尾将整个字符串处理一遍，计算从上个位置到本字符位置最少需要的转动次数（顺时针/逆时针）并将次数加入到ans,中 并将pos更新为当前位置
为了操作的简单，我将 a ~ z 对应为 0 ~ 25 ,更为直观
这道题可能也算是个贪心题（胡诌）,不过两次操作并不会相互影响，故每次只需要取当前最优的操作（即每次取转动次数最少的方案，加到一起也是最优的）
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
using namespace std;
int f(char c)
{
return c-'a';
}
int main()
{
string s;
cin>>s;
int pos=0,ans=0;
for(int i=0;i<s.length();i++)
{
int x=f(s[i]);
int now=min((x-pos+26)%26,(pos-x+26)%26);
ans+=now;
pos=x;
}
cout<<ans<<endl;
system("pause");
return 0;
}
一共有n([1,100000])天，每天会有一个数字ai([1,10000]),必须通过以下两种方式使得每天的数字正好等于ai:
①在某一天加2
②在某一天加一，同时为下一天加一
两种方式每天都可以无限次使用
PS：最后一天不能为下一天加一 否则就不能满足条件，输出"NO"
满足条件则输出"YES"
样例输入：
第一个一个数字n 第二行n个数字ai
3
1 0 3
样例输出:
满足条件则输出YES 不满足则输出NO
NO
1.乍一看很麻烦，但其实每一天都只能影响到他的后一天 故我们只需要顺序处理，记录一下是否为下一天增加了 1 就好，不需要其他的标记
2.对于ai 我们可以将ai对2取模后处理，因为 操作①可以将所有偶数转化为0，而操作②可以将所有奇数转化为1(当然还有一些其他的处理)
1.每次读入一个数，判断ai的奇偶与上一天有没有给今天增加了1（这个1是必须增加的）
2. 所有情况如下表所示
| 0 | 奇数 | 偶数 | |
|---|---|---|---|
| 没增加1 | √ | √(为下一天增加1) | √（下一天不加1） |
| 增加了1 | × | √(下一天不加1) | √（下一天增加1） |
3.最后再判断是否剩下了1
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#define MAXN 100010
using namespace std;
int n;
int a[MAXN];
int main()
{
cin>>n;
int juan=0,x,ok=1;
for(int i=1;i<=n;i++)
{
cin>>x;
if(juan==0)
{
if(x%2==0) continue;
if(x%2==1) {juan=1;continue;}
}
else if(juan==1)
{
if(x==0) {ok=0;break;}
if(x%2==0) {juan=1;continue;}
if(x%2==1) {juan=0;continue;}
}
}
if(juan==1||ok==0) cout<<"NO"<<endl;
else cout<<"YES"<<endl;
system("pause");
return 0;
}
宇宙射线会在无限的二维平面上传播(可以看做一个二维网格图)，初始方向默认向上。宇宙射线会在发射出一段距离后分裂,向该方向的左右45° 方向分裂出两条宇宙射线，同时威力不变!宇宙射线会分裂n次,每次分裂后会在分裂方向前进a个单位长度。计算共有多少个位置会被打击。
样例输入：
第一行一个数字n 表示分裂的次数
第二行n个数字 第i个数表示第i次分裂的射线要沿原来方向走的步数(1<=ai<=5)
4
4 2 3 2
样例输出:
所有被打击的位置的总和
39
1.模拟的时候 一开始以为是个大模拟（或者说搜索）但是每次分裂成两个，即2^30实在遭不住，于是想找一下有没有规律 不过只看出了具有对称性 不知道怎么实现 于是写了个裸的BFS进行模拟，最后得到了40分的部分分
2.补题时，经过道友指点，发现确实可以通过对称性进行优化 但是BFS不好实现，于是采用了DFS递归加回溯的方法 只递归向右的一个方向 并在回溯的时候将对应其他方向的区域都复制一遍 下面讲一下核心的对称思想
假设 P点（x0,y0） i点 （x1,y1）
对于这两种情况(对称轴平行于y/x轴) 对称点的坐标相对容易求出，分别为 (2x0-x1,y1)和(x1,2y0-y1)
而对于对称轴平行于 y=x / y=-x的两种情况，可以根据垂直平分线、直线间斜率的关系进行求解，属于简单的解析几何问题，最终 i’的坐标分别是 (x0+y1-y0,y0+x1-x0) 和 (x0+y0-y1,x0+y0-x1)
1.如果只是单纯的BFS/DFS,会由于状态的指数增长而超时，这时我们需要通过本题的特点发现他的对称性,利用其对称性只考虑其中的一条扩展路径，从而优化时间复杂度
2.此外，为了去除重复的地点，可以利用 set容器进行自动去重 很方便
首先是40分裸搜代码
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
int n,ans;
int map[5001][5001];
int a[1010];
struct node
{
int x,y,dx,dy;
int num;
};
int main()
{
cin>>n;
queue<node> q;
int sx=2500,sy=2500;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<=a[1];i++)
{
ans++;
map[sx][sy+i]=1;
}
node node1,node2;
node1.x=sx;node1.y=sy+a[1];node1.dx=-1;node1.dy=1;node1.num=2;
node2.x=sx;node2.y=sy+a[1];node2.dx=1;node2.dy=1;node2.num=2;
q.push(node1);q.push(node2);
while(!q.empty())
{
node now=q.front();q.pop();
int xx=now.dx,yy=now.dy;
int tx,ty;
for(int i=1;i<=a[now.num];i++)
{
tx=now.x+i*now.dx;
ty=now.y+i*now.dy;
if(map[tx][ty]==0) {map[tx][ty]=1;ans++;}
}
if(now.num==n) continue;//如果这是最后一次分裂 就不用再分裂了
node next1,next2;
next1.x=tx;next1.y=ty;next1.num=now.num+1;
next2.x=tx;next2.y=ty;next2.num=now.num+1;
//这里我憨憨的写了一个8个if的状态转移
if(xx==0&&yy==1) {next1.dx=-1;next1.dy=1;next2.dx=1;next2.dy=1;}
if(xx==1&&yy==1) {next1.dx=0;next1.dy=1;next2.dx=1;next2.dy=0;}
if(xx==1&&yy==0) {next1.dx=1;next1.dy=1;next2.dx=1;next2.dy=-1;}
if(xx==1&&yy==-1) {next1.dx=0;next1.dy=-1;next2.dx=1;next2.dy=0;}
if(xx==0&&yy==-1) {next1.dx=1;next1.dy=-1;next2.dx=-1;next2.dy=-1;}
if(xx==-1&&yy==-1) {next1.dx=0;next1.dy=-1;next2.dx=-1;next2.dy=0;}
if(xx==-1&&yy==0) {next1.dx=-1;next1.dy=-1;next2.dx=-1;next2.dy=1;}
if(xx==-1&&yy==1) {next1.dx=-1;next1.dy=0;next2.dx=0;next2.dy=1;}
q.push(next1);q.push(next2);
}
printf("%d\n",ans);
system("pause");
return 0;
}
然后是满分代码
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<set>
using namespace std;
int n,ans;
int a[1010];
int xx[]={0,1,1,1,0,-1,-1,-1};
int yy[]={1,1,0,-1,-1,-1,0,1};
struct node
{
int x,y;
bool operator < (const node& P) const
{
if(x!=P.x) return x<P.x;
else return y < P.y;
}
};
set <node> s;
void f(node p,int step,int state)
{
if(step==n+1) return;//边界条件
node nxt;
nxt.x=p.x+xx[state]*a[step];
nxt.y=p.y+yy[state]*a[step];
f(nxt,step+1,(state+1)%8);//先一直想右递归 扩充完所有分裂
//回溯 先对称复制下一层的 即 把与nxt点在同一层分裂上的所有点给对称复制出来
set <node> t;
for(auto &i:s){//C++ 11 的auto真香
//关于与y轴平行的对称轴对称
if((xx[state]==0&&yy[state]==1)||(xx[state]==0&&yy[state]==-1)) t.insert({2*p.x-i.x,i.y});
//关于与y=x平行的对称轴对称
else if((xx[state]==1&&yy[state]==1)||(xx[state]==-1&&yy[state]==-1)) t.insert({p.x+i.y-p.y,p.y+i.x-p.x});
//关于与x轴平行的对称轴对称
else if((xx[state]==1&&yy[state]==0)||(xx[state]==-1&&yy[state]==0)) t.insert({i.x,2*p.y-i.y});
//关于与y=-x平行的对称轴对称
else if((xx[state]==1&&yy[state]==-1)||(xx[state]==-1&&yy[state]==1) ) t.insert({p.x+p.y-i.y,p.y-i.x+p.x});
}
s.insert(t.begin(),t.end());
// 加入p射线感染的区域
for(int i=1;i<=a[step];i++) s.insert({p.x+i*xx[state],p.y+i*yy[state]});
}
int main()
{
cin>>n;
queue<node> q;
for(int i=1;i<=n;i++) cin>>a[i];
node start;start.x=0;start.y=0;
f(start,1,0);
printf("%d\n",s.size());
system("pause");
return 0;
}