Wannafly Union#1

题目链接：http://vjudge.net/contest/142053#overview

A.题意：有一个3*n的隧道，人和车轮流走，人先向右走一步，然后选在是在原地不动还是上下移动一格，之后车开始往左移两格，问人是否能走到隧道尽头

　思路：车是不会上下动的，那么我们按照相对来算就行，也就是人相当于往右走一步，然后选择不动还是上下移动一格，然后往右走两步。bfs处理把能走到的点加入到队列

bfs和dp其实思路是一样的，都是从左到右递推过去的

 #include <stdio.h>
 #include <iostream>
 #include <algorithm>
 #include <string.h>
 #include <stdlib.h>
 #include <queue>
 using namespace std;
 char G[][];
 bool flag[][];
 int n;
 bool vis;
 struct node{
     int x,y;
 };
 bool judge(int x,int y){
     return G[x][y]=='.';
 }
 bool ok(node &temp){
         if(judge(temp.x,temp.y)){
                 if(judge(temp.x,temp.y+)){
                     if(temp.y+==n) vis=true;
                 }
                 if(judge(temp.x,temp.y+)&&judge(temp.x,temp.y+)){
                     if(temp.y+==n||temp.y+==n) vis=true;
                 }
                 if(judge(temp.x,temp.y+)&&judge(temp.x,temp.y+)){
                     temp.y+=;
                     if(!flag[temp.x][temp.y]){
                         return true;
                     }
                 }
             }
             return false;
 }
 bool bfs(int posx,int posy){
     memset(flag,false,sizeof(flag));
     queue<node> q;
     vis=false;
     while(!q.empty()) q.pop();
     node e;
     e.x=posx,e.y=posy;
     q.push(e);
     flag[e.x][e.y]=true;
     while(!q.empty()){
         node tmp=q.front();
         q.pop();
         if(tmp.y==n) return true;
         else {
             node temp,tmpup,tmpdown;
             temp=tmp;
             temp.y=tmp.y+;
             if(!judge(temp.x,temp.y)) continue;
             if(temp.y==n) return true;
             tmpup=temp,tmpup.x+=;
             tmpdown=temp,tmpdown.x-=;
             if(ok(temp)){
                 q.push(temp);
                 flag[temp.x][temp.y]=true;
             }
             if(ok(tmpup)){
                 q.push(tmpup);
                 flag[tmpup.x][tmpup.y]=true;
             }
             if(ok(tmpdown)){
                 q.push(tmpdown);
                 flag[tmpdown.x][tmpdown.y]=true;
             }
             if(vis) return true;
         }
     }
     return false;
 }
 void solve(int T){
     int k;
     scanf("%d %d",&n,&k);
     int x,y;
     for(int i=;i<=;i++){
         for(int j=;j<=n;j++){
             scanf(" %c",&G[i][j]);
             if(G[i][j]=='s') {
                 x=i,y=j;
             }
         }
     }
     if(bfs(x,y)){
         printf("YES\n");
     }
     else
         printf("NO\n");
     return ;
 }
 int main(){
     int T;
     while(scanf("%d",&T)!=EOF){
         for(int i=;i<=T;i++) solve(i);
     }
 }

B.题意：有一个字符串，看能不能在字符串的任意位置插入一个字符串使得这个字符串是回文串

　思路：水题，暴力插入

 #include <stdio.h>
 #include <iostream>
 #include <algorithm>
 #include <string.h>
 using namespace std;
 char str[];
 char tmp[];
 bool judge(int len){
     for(int i=;i<=len;i++){
         if(tmp[i]!=tmp[len-i]){
             return false;
         }
     }
     return true;
 }
 void solve(){
     int len=strlen(str);
         for(int i=;i<=len;i++){
             for(int j=;j<;j++){
                 tmp[i]='a'+j;
                 for(int k=;k<i;k++) tmp[k]=str[k];
                 for(int k=i+;k<=len;k++) tmp[k]=str[k-];
                 if(judge(len)){
                     for(int k=;k<=len;k++){
                         printf("%c",tmp[k]);
                     }
                     printf("\n");
                         return ;
                 }
             }
         }
         printf("NA\n");
         return ;
 }
 int main(){
     while(scanf("%s",str)!=EOF){
         solve();
     }
     return ;
 }

D.题意：有一个n*n的棋盘，白棋在(1,1)，黑棋(1,n)，其余的地方都是绿棋子，棋子的走法和国际象棋里面的皇后一样，白棋和黑棋走的路上必须吃子

　　　　当某个棋子不能吃子或者被对手吃了就算输了，输出谁输，如果白棋赢输出白棋走的第一步，l和c都尽量小
思路：如果棋盘是奇数的话，白棋先手，黑棋走白棋的镜像，这样的话相当于当白棋走到中间时，黑棋总能把它吃掉。
如果棋盘是偶数的话，白棋先手走(1,2)这样相当于把棋盘变成奇数并且黑棋先手了，那样黑棋必输，而白棋总能通过先走(1,2)来赢

 #include <stdio.h>
 int main(){
     int n;
     while(scanf("%d",&n)!=EOF){
         if(n&)printf("black\n");
         else {
             printf("white\n1 2\n");
         }
     }
     return ;
 }

F：题意：有很多个约束条件，输出满足约束条件的任意一个数

思路：设一个l，r表示上界和下界，不断夹就行，矛盾就不行(代码有点丑QwQ)

 #include <stdio.h>
 #include <iostream>
 #include <algorithm>
 #include <string.h>
 using namespace std;
 char str[];
 int num;
 char type[];
 void solve(int T){
     int l=-2e9;
     int r=2e9;
     bool flag=true;
     while(T--){
             scanf("%s%d%s",str,&num,type);
             if(type[]=='N'){
                 if(str[]=='>'){
                     if(str[]=='='){
                         if(num-<l){
                             flag=false;
                             continue;
                         }
                         r=min(r,num-);
                     }
                     else {
                         if(num<l) {
                         flag=false;
                             continue;
                         }
                         r=min(r,num);
                     }
                 }
                 if(str[]=='<'){
                     if(str[]=='='){
                         if(num+>r){
                             flag=false;
                             continue;
                         }
                         l=max(l,num+);
                     }
                     else {
                         if(num>r){
                             flag=false;
                             continue;
                         }
                         l=max(num,l);
                     }
                 }
             }
             else {
             if(str[]=='>'){
                 if(str[]=='='){
                     if(num>r){
                         flag=false;
                             continue;
                     }
                     l=max(l,num);
                 }
                 else {
                     if(num+>r){
                         flag=false;
                             continue;
                     }
                     l=max(num+,l);
                 }
             }
             if(str[]=='<'){
                 if(str[]=='='){
                     if(num<l) {
                         flag=false;
                             continue;
                     }
                     r=min(r,num);
                 }
                 else {
                     if(num-<l){
                         flag=false;
                             continue;
                     }
                     r=min(r,num-);
                 }
             }
         }
         }
     if(!flag){
         printf("Impossible\n");
         return ;
     }
         for(int i=l;i<=r;i++){
             printf("%d\n",i);
             return ;
         }

 }
 int main(){
     int T;
     while(scanf("%d",&T)!=EOF){
         solve(T);
     }
 }

E题填坑来了

题意：有一个ｎ＊ｎ的方格，里面有ｍ个棋子，每个棋子有自身的属性值p,现在有这样一个集合，集合内的棋子要满足都在一条斜线上，并且距离（斜线上的距离）要满足一个条件，dis(i,j)>=pi^2+pj^2+C（C为常数）

思路：假设xi>xj,那么dis(i,j)=xi-xj+1 xi-xj+1>=pi^2+pj^2+C ---> xi-pi^2>=xj+pj^2+C-1　假设左边为A[i],右边为B[i],这样每个点都有属性ai,bi,把每条斜线按照ｘ的升序排列，然后用类似nlogn求ＬＩＳ的方法求出每条斜线上最多，我设a=x-p^p b=x+p^p+c-1，那么肯定B[i]>A[i],也就是如果你在序列中找到了这个点插入的位置，就可以直接插入，因为B[i]不可能在前面

能在集合里面加几个点假设xi>xj>xk 那么dis(i,k)=dis(i,j)+dis(j,k)-1>=pi^2+2*pj^2+pk^2+2*C-1>pi^2+pk^2+C　也就是只要相邻的满足条件，那么这个点肯定跟整个集合里面的满足条件

 #include <stdio.h>
 #include <iostream>
 #include <cstring>
 #include <algorithm>
 #include <set>
 #include <vector>
 using namespace std;
 const int maxn=1e5+;
 int n,m,C;
 struct node{
     long long  x,y,p;
     node(){};
     long long a,b;
     node(int x_,int y_,int p_):x(x_),y(y_),p(p_){
         a=x-p*p,b=x+p*p+C-;
     }
 };
 vector<node> G1[*maxn];
 vector<node> G2[*maxn];
 set<int> s1;
 set<int> s2;
 set<int> ::iterator it;
 int siznum;
 bool cmp(const node&tmp1,const node&tmp2){
     return tmp1.x<tmp2.x;
 }
 int ans=;
 long long q[maxn];
 void cal(vector<node> G[*maxn],set<int> s){
     for(it=s.begin();it!=s.end();it++){
         int num=*it;
         int cnt=;
         sort(G[num].begin(),G[num].end(),cmp);
         for(int i=;i<G[num].size();i++){
             int pos=upper_bound(q,q+cnt,G[num][i].a)-q;
             if(pos==cnt){
                 q[cnt++]=G[num][i].b;
             }
             else {
                 if(q[pos]>G[num][i].b){
                     q[pos]=G[num][i].b;
                 }
             }
         }
         ans=max(ans,cnt);
     }
 }
 node point[maxn];
 long long num[maxn<<];
 void solve(){
     ans=;
     scanf("%d %d %d",&n,&m,&C);
     for(int i=;i<(*maxn);i++) G1[i].clear(),G2[i].clear();
     s1.clear(),s2.clear();
     long long  x,y,p;
     for(int i=;i<=m;i++){
         scanf("%lld %lld %lld",&x,&y,&p);
         point[i]=node(x,y,p);
         s1.insert(x+y);
         s2.insert(y-x+maxn);
         G1[x+y].push_back(point[i]);
         G2[y-x+maxn].push_back(point[i]);
     }
     cal(G1,s1);
     cal(G2,s2);
     printf("%d\n",ans);
 }
 int main(){
     int T;
     freopen("bishops.in","r",stdin);
     scanf("%d",&T);
     while(T--){
         solve();
     }
 }

C题放弃QAQ

非常感激大佬们挂题讲题QAQ