提高组刷题班 DAY 1 上午

低仿机器人
（robo，1s，64M）

题解

大模拟

代码

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int xGo[]={-,,,};
const int yGo[]={,-,,};

int n,m,map[][][];
int x,y,fOri,wOri,maxCilp,totCilp,cilp[],bigBullet,smallBullet,k,endIf,totTarget;

void IN_Map_Robot();
void OutPut(int);
int Para(char str[]);

void FortCom(char str[]);
void WheelCom(char str[]);
void EndCom(char str[]);

int main()
{
    freopen("robo.in","r",stdin);
    freopen("robo.out","w",stdout);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        IN_Map_Robot();
        while(k--)
        {
            char str[];
            cin.getline(str,);
            if(endIf) continue;
            if(str[]=='F') FortCom(str);
            if(str[]=='W') WheelCom(str);
            if(str[]=='E') EndCom(str);
        }
        if(!endIf) OutPut();
    }
    fclose(stdin);
    fclose(stdout);
    return ;
}

void IN_Map_Robot()
{
    memset(map,,sizeof(map));
    totCilp=,fOri=,wOri=,endIf=,totTarget=;

    scanf("%d%d",&n,&m);
    for(int i=;i<n;++i)
        for(int j=;j<m;++j)
            scanf("%d ",&map[i][j][]);
    scanf("%d %d %d %d %d %d\n",&x,&y,&maxCilp,&bigBullet,&smallBullet,&k);
}

void FortCom(char str[])
{
    if(str[]=='T')
    {
        int par=Para(str+);
        if(par==) fOri=(fOri+)%;
        else if(par==) fOri=(fOri+)%;
        else { OutPut(); return ; }
    }
    if(str[]=='F')
    {
        int par=Para(str+);
        if((par==&&smallBullet==)||(par==&&bigBullet==)) return;
        if(par==&&totCilp<maxCilp) cilp[++totCilp]=par,smallBullet--;
        else if(par==&&totCilp<maxCilp) cilp[++totCilp]=par,bigBullet--;
        else { OutPut(); return ; }
    }
    if(str[]=='E')
    {
        if(totCilp==) return ;
        int nx,ny;
        for(int i=;;++i)
        {
            nx=x+xGo[fOri]*i,ny=y+yGo[fOri]*i;
            if(nx<||nx>=n||ny<||ny>=m) break;
            if(map[nx][ny][]==||map[nx][ny][]==) break;
        }
        totCilp--;
        if(nx<||nx>=n||ny<||ny>=m) return ;
        if(map[nx][ny][]==) return ;
        if(cilp[totCilp+]||map[nx][ny][]) { map[nx][ny][]=; totTarget++; }
        else map[nx][ny][]=;
    }
}

void WheelCom(char str[])
{
    if(str[]=='T')
    {
        int par=Para(str+);
        if(par==) wOri=(wOri+)%;
        else if(par==) wOri=(wOri+)%;
        else { OutPut(); return ; }
    }
    else
    {
        int par=Para(str+);
        int nx=x+xGo[wOri]*par,ny=y+yGo[wOri]*par;
        if(nx<||nx>=n||ny<||ny>=m) { OutPut(); return ; }
        else
        {
            for(int i=;i<=par;++i)
            {
                nx=x+xGo[wOri]*i,ny=y+yGo[wOri]*i;
                if(map[nx][ny][]) { OutPut(); return ; }
            }
        }
        x=nx,y=ny;
    }
}

void EndCom(char str[])
{
    OutPut();
}

void OutPut(int type)
{
    endIf=;
    if(type) printf("Complete\n");
    else printf("ERROR\n");
    printf("%d %d\n",x,y);
    printf("%d\n",totTarget);
    printf("%d %d %d %d\n",fOri,wOri,bigBullet,smallBullet);
}

int Para(char str[])
{
    int i,re=;
    for(i=;;++i)
    {
        if(str[i]=='.') return ;
        if(str[i]=='\0') break;
    }
    i=;
    do
    {
        re=re*+(str[i]-'');
        i++;
    }while(str[i]!='\0');
    return re;
}

---

迷路的刺豚

DFS  搜出，路径，同样长度但是膨胀程度不一样

状压DP+BFS

f[s][i]------（+dis[i][j]）------->f[s|(1<<j)][j]

代码

#include <bits/stdc++.h>

using namespace std;

const int N=,M=,K=;
const int dx[]={,,,-};
const int dy[]={,-,,};
const char* st[]={"R","L","D","U"};

int Path[(N+M)<<],n,m,S;
int mp[N][M];

void Read_Map() {
    scanf("%d%d%d",&n,&m,&S);
    for (int i=;i<n;++i)
        for (int j=;j<m;++j) scanf("%d",&mp[i][j]);//mp=0为可行，否则为障碍
}

queue<pair<int,int> >Q;
int Path_[K+][K+][(N+M)<<],dist[K+][K+],szt[K+][K+];
int dis[K][<<K],sum[K][<<K];
pair<int,int> pre[K][<<K];

void Put_Path(int *Path,int &len,int begin,int end) {
    for (int i=;i<dist[begin][end];++i)
        Path[len++]=Path_[begin][end][i];
}

bool CoordValid(int x,int y) {
    return x>= && x<n && y>= && y<m;
}

bool CoordValid(int x,int y,int size) {
    for (int i=-size;i<=size;++i)
        for (int j=-size;j<=size;++j)
            if (!CoordValid(x+i,y+j) || mp[x+i][y+j]==) return ;
    return ;
}

int Size(int x,int y) {
    for (int i=S;i>=;--i) if (CoordValid(x,y,i)) return i;
    return -;
}

int pree[N][M],diss[N][M],sz[N][M];
void FindPath(int *ax,int *ay,int count) {
    for (int i=;i<count;++i) {
         Q.push(make_pair(ax[i],ay[i]));
        memset(pree,,sizeof(pree));
        memset(diss,0x7f,sizeof(diss));
        memset(sz,,sizeof(sz));
        diss[ax[i]][ay[i]]=;
        while (!Q.empty()) {
            pair<int,int> u=Q.front(); Q.pop();
            for (int i=;i<;++i) {
                int tx=u.first+dx[i],ty=u.second+dy[i],s=Size(tx,ty);
                if (s!=- && (diss[tx][ty]>diss[u.first][u.second]+ || (diss[tx][ty]==diss[u.first][u.second]+ && sz[u.first][u.second]+s>sz[tx][ty]))) {
                    diss[tx][ty]=diss[u.first][u.second]+;
                    pree[tx][ty]=i;
                    sz[tx][ty]=sz[u.first][u.second]+s;
                    Q.push(make_pair(tx,ty));
                }
            }
        }
        for (int j=;j<count;++j) {
            dist[i][j]=diss[ax[j]][ay[j]];
            szt[i][j]=sz[ax[j]][ay[j]];
//            int len=0,nowx=ax[j],nowy=ay[j];
//            while (nowx!=ax[i] || nowy!=ay[i]) {
//                Path_[i][j][len++]=pree[nowx][nowy];
//                int px=nowx-dx[pree[nowx][nowy]],py=nowy-dy[pree[nowx][nowy]];
//                nowx=px; nowy=py;
//            }
//            reverse(Path_[i][j],Path_[i][j]+len);
        }
    }
}

void Planning(int now_x,int now_y,int *aim_x,int *aim_y,int count_aim,int *Path,int &len) {
    aim_x[count_aim]=now_x; aim_y[count_aim]=now_y;
    FindPath(aim_x,aim_y,count_aim+);
    int Mx=<<count_aim;
    for (int i=;i<=count_aim;++i)
        for (int j=;j<Mx;++j)
            pre[i][j]=make_pair(-,-),dis[i][j]=<<;
    for (int i=;i<count_aim;++i) dis[i][(Mx-)^(<<i)]=,sum[i][(Mx-)^(<<i)]=;
    for (int i=;i<count_aim;++i)
        for (int j=Mx-;j>=;--j)
            for (int k=;k<count_aim;++k) if (i!=k && !((j>>k)&) && (dis[i][j]>dis[k][j^(<<i)]+dist[i][k] || ( dis[i][j]==dis[k][j^(<<i)]+dist[i][k] && sum[i][j]<sum[k][j^(<<i)]+szt[i][k] ) )) {
                dis[i][j]=dis[k][j^(<<i)]+dist[i][k];
                sum[i][j]=sum[k][j^(<<i)]+szt[i][k];
                pre[i][j]=make_pair(k,j^(<<i));
            } 

    int mn=,v=; len=;
    for (int i=;i<count_aim;++i) if (dis[i][v]+dist[count_aim][i]<dis[mn][v]+dist[count_aim][mn] || (dis[i][v]+dist[count_aim][i]==dis[mn][v]+dist[count_aim][mn] && sum[i][v]+szt[count_aim][i]>sum[mn][v]+szt[count_aim][mn])) mn=i;
    printf("%d %d\n",dis[mn][v]+dist[count_aim][mn],sum[mn][v]+Size(now_x,now_y)+szt[count_aim][mn]);
/*
    for (int i=1;i<count_aim;++i) if (dis[i][v]+dist[count_aim][i]<dis[mn][v]+dist[count_aim][mn]) mn=i;
    Put_Path(Path,len,count_aim,mn);
    while (pre[mn][v].first!=-1) {
        pair<int,int> u=pre[mn][v];
        Put_Path(Path,len,mn,u.first);
        mn=u.first; v=u.second;
    }
*/
}

int main() {
    freopen("expand.in","r",stdin);
    freopen("expand.out","w",stdout);
    Read_Map();
    int now_x,now_y,aim_x[K],aim_y[K],count_aim;
    scanf("%d%d%d",&now_x,&now_y,&count_aim);
    for (int i=;i<count_aim;++i) scanf("%d%d",&aim_x[i],&aim_y[i]);
    int len=;
    Planning(now_x,now_y,aim_x,aim_y,count_aim,Path,len);
//    for (int i=0;i<len;++i)
//        printf("%s",st[Path[i]]);
    putchar('\n');
    fclose(stdin);
    fclose(stdout);
    return ;
} 

/*
input:
4 6 3
1 1 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 4 1
3 0 

output:
7 5
*/

---

生日(birthday.cpp/1s/256M)

样例输入：

样例输出

Yes
Yes
Yes
Yes
No

题解

（图右半边是折半搜索）

解释一哈：

因为区间内的每个小盆友都可以有选或者不选两种情况，所以一共有2^len 种

所以该区间的子集种类数：有2^len 种

子集和的范围：0~v*len

2^len 种子集本应该是与v*len一一映射的

但是当2^len > v*len 时，

集合的取值一定会有重复的，所以此时一定有解

解得 len>=14

∴len<14时要折半搜索

因为之前处理过 len<=7 的情况

那么有重复的怎么办？？？

其实不影响

比如序列     1   1   3   2

所选集合有重叠，但是他们相等，那么去掉重复的之后也是相等的

代码

# include <iostream>
# include <cstdio>
# include <cstring>
# include <cstdlib>
using namespace std;
const int V = 1e3 + ;
const int N = 1e5 + ;
int read()
{
    int ans = ,f = ;
    char i = getchar();
    while(i < '' || i > ''){if(i == '-')f = -;i = getchar();}
    while(i >= '' && i <= ''){ans = ans *  + i - '';i = getchar();}
    return ans * f;
}
int n,m,v,mid,ol,x,y,d;
int data[V][],a[N],stack[N],cnt;
int sum[N << ],lazy[N << ];
bool flag[N];
void down(int rt){
    lazy[rt << ] += lazy[rt];
    lazy[rt <<  | ] += lazy[rt];
    lazy[rt] = ;
}
void push(int &ans,int &r){
    int j = ;
    while(j >= ){
        if(r >= ( << j)){
           ans = data[ans][j];
           r -= ( << j);
           if(r == )return;
        }
        j--;
    }
}
void updata(int L,int R,int l,int r,int rt){
    if(L <= l && r <= R){
        lazy[rt]++;
        return;
    }
    if(lazy[rt])down(rt);
    int mid = (l + r) >> ;
    if(L <= mid)updata(L,R,l,mid,rt << );
    if(R >  mid)updata(L,R,mid + ,r,rt <<  | );
    return;
}
void Query(int L,int l,int r,int rt){
    if(l == r){
        push(a[L],lazy[rt]);
        return;
    }
    if(lazy[rt])down(rt);
    int mid = (l + r) >> ;
    if(L <= mid)Query(L,l,mid,rt << );
    else Query(L,mid + ,r,rt <<  | );
    return;
}
void init(){
    for(int i = ;i < v;i++){
        data[i][] = (i * i % v) * i % v;
    }
    for(int j = ;j <= ;j++){
        for(int i = ;i < v;i++){
           data[i][j] = data[data[i][j - ]][j - ];
        }
    }
}
void dfsl(int u,int dis,bool k){
    if(ol)return;
    if(u == mid + ){
        if(k){
            if(!dis){
                ol = true;
            }else if(dis >=  && !flag[dis]){flag[dis] = true;stack[++cnt] = dis;}
        }
        return;
    }
    dfsl(u + ,dis,k);
    dfsl(u + ,dis + a[u] + ,true);
    dfsl(u + ,dis - a[u] - ,true);
    return;
}
void dfsr(int u,int dis,bool k){
    if(ol)return;
    if(u == y + ){
        if(k){
            if(!dis){
                ol = true;
            }else if(dis >=  && flag[dis]){
                ol = true;
            }
        }
        return;
    }
    dfsr(u + ,dis,k);
    dfsr(u + ,dis + a[u] + ,true);
    dfsr(u + ,dis - a[u] - ,true);
    return;
}
int main(){
     freopen("birthday.in","r",stdin);
     freopen("birthday.out","w",stdout);
  n = read(),m = read(),v = read();
  for(int i = ;i <= n;i++)a[i] = read();
  init();
  for(int i = ;i <= m;i++){
      d = read(),x = read(),y = read();
      if(d == ){
          updata(x,y,,n,);
      }else {
          if(y - x >= ){
              puts("Yes");
          }else {
            for(int j = x;j <= y;j++){
                Query(j,,n,);
            }
            mid = (x + y) >> ;
            ol = false;cnt = ;
            dfsl(x,,false);
            dfsr(mid + ,,false);
            for(int i = ;i <= cnt;i++){
                flag[stack[i]] = false;
            }
            if(ol)puts("Yes");else puts("No");
         }
      }
  }
  fclose(stdin);
  fclose(stdout);
  return ;
}