codeforces 792A-D

先刷前四题，剩下的有空补。

792A New Bus Route

题意：给出x 轴上的n 个点，问两个点之间的最短距离是多少，有多少个最短距离。

思路：排序后遍历。

代码：

#include<stdio.h>
#include<algorithm>
using namespace std;
#define N 200005
int w[N];
int main(){
  int n;
  while(~scanf("%d", &n)){
    for(int i=0; i<n; i++){
      scanf("%d", &w[i]);
    }
    sort(w, w+n);
    int mint=w[1]-w[0], co=1;
    for(int i=2; i<n; i++){
      if(w[i]-w[i-1]<mint){
        mint=w[i]-w[i-1];
        co=1;
      }
      else if(w[i]-w[i-1]==mint) co++;
    }
    printf("%d %d\n", mint, co);
  }
  return 0;
}

792B Counting-out Rhyme

题意：1-n n个数围成一圈，初始位置为1，有m 个操作，每个操作给一个整数x，表示前进x 步后删去当前位置的数，再前进一步，输出每次操作删除的数

思路：模拟，用pos表示当前位置，循环m 次。注意得到x 后先取余当前剩余数量。

代码：

#include<stdio.h>

int main(){
  int n, m, x;
  while(~scanf("%d%d", &n, &m)){
    bool vis[110]={0}, flag=false;
    int pos=0, num=n;
    while(m--){
      scanf("%d", &x);
      x=x%num;
      while(x--){
        do
        {
          pos++;
          pos%=n;
        }while(vis[pos]==1);
      }
      if(flag) printf(" ");
      flag=true;
      printf("%d", pos+1);
      vis[pos]=1;
      do
      {
        pos++;
        pos%=n;
      }while(vis[pos]==1);
      num--;
    }
    printf("\n");
  }
  return 0;
}

792C Divide by Three

题意：给一个数，问最少删除多少位后可以被3 整除。

思路：

　　有一个大数取余要先理解。用sum 保存所有位和取余3 的结果。

　　如果sum==0，不需要删除；

　　如果sum==1，有可能删除一位1（取余后），有可能删除两位2；

　　如果sum==2，有可能删除一位2，有可能删除两位1。 

　　写一个函数del（char *s, int k）表示从s 里删除一个数字k 并且去除前导0。接着几个if、else判断一下就可以了。

代码：

#include<stdio.h>
#include<string.h>
void del(char *s, int k){
  int ls=strlen(s), i;
  for(i=ls-1; i>=0; i--){
    if((s[i]-'0')%3==k) break;
  }
  if(i==-1) return ;
  for(int j=i; j<ls; j++) s[j]=s[j+1];
  if(s[0]==0){
    s[0]='-';
    s[1]='1';
    s[2]=0;
    return ;
  }
  for(i=0; s[i]; i++){
    if(s[i]!='0') break;
  }
  if(s[i]==0) s[0]='0', s[1]=0;
  else{
    for(int j=i; j<ls; j++){
      s[j-i]=s[j];
    }
  }
}
char s[100005], ts[100005];
int main(){
  while(~scanf("%s", s)){
    int sum=0;
    for(int i=0; s[i]; i++){
      sum+=s[i]-'0';
      sum%=3;
    }
    if(sum==0) printf("%s\n", s);
    else{
      int n1=0, n2=0;
      for(int i=0; s[i]; i++){
        if((s[i]-'0')%3==1) n1++;
        else if((s[i]-'0')%3==2) n2++;
      }
      if(sum==1){
        if(n2<2){
          del(s, 1);
          printf("%s\n", s);
        }
        else if(n1==0){
          del(s, 2);
          del(s, 2);
          printf("%s\n", s);
        }
        else{
          strcpy(ts, s);
          int ls1, ls2;
          del(ts, 1);
          ls1=strlen(ts);
          del(s, 2);
          del(s, 2);
          ls2=strlen(s);
          if(ls1>ls2) printf("%s\n", ts);
          else printf("%s\n", s);
        }
      }
      else{
        if(n2==0){
          del(s, 1);
          del(s, 1);
          printf("%s\n", s);
        }
        else if(n1<2){
          del(s, 2);
          printf("%s\n", s);
        }
        else{
          strcpy(ts, s);
          int ls1, ls2;
          del(ts, 1);
          del(ts, 1);
          ls1=strlen(ts);
          del(s, 2);
          ls2=strlen(s);
          if(ls1>ls2) printf("%s\n", ts);
          else printf("%s\n", s);
        }
      }
    }
  }
  return 0;
}

792D Paths in a Complete Binary Tree

题意：给一个n ，一个m ，n 表示有n 个结点的完整二叉树，m 表示m 个询问，每次询问给出初始结点编号和移动序列，问移动后的结点编号。（树结点编码依据中序遍历）

思路：

　　预处理+模拟。

　　可以先通过一个dfs找到初始位置的层数，这个dfs里面同时求出初始位置到根的路径（用于判断当前位置是父结点的左孩子或右孩子）。

　　接着根据初始位置的层数，先预处理一下移动序列，把不合理的操作去掉。（简化后续操作难度）

　　接着模拟当前位置变化即可。分三种情况处理即可（重点的子树结点数量可以通过当前层数求出）

代码：

#include<stdio.h>
#define LL long long

int getNum(LL n){
  int ret=0;
  while(n){
    n>>=1;
    ret++;
  }
  return ret;
}

int dfs(LL l, LL r, LL p, bool *ss, int &ssp, int ceng){  // 确定初始位置的行
  LL mid=(l+r)/2;
  if(mid==p) return ceng;
  else if(mid>p){
    ss[ceng]=0;
    ssp=ceng;
    return dfs(l, mid-1, p, ss, ssp, ceng+1);
  }
  else{
    ss[ceng]=1;
    ssp=ceng;
    return dfs(mid+1, r, p, ss, ssp, ceng+1);
  }
}

void init(char *s, int rp, int num){
  int j=0;
  for(int i=0; s[i]; i++){
    if(s[i]=='L' || s[i]=='R'){
      if(rp==num);
      else{
        rp++;
        s[j++]=s[i];
      }
    }
    else{
      if(rp==1);
      else{
        rp--;
        s[j++]=s[i];
      }
    }
  }
  s[j]=0;
}

LL dp[100];
LL solve(char *s, bool *ss, int ssp, LL p, int rp, int num){
  if(s[0]==0) return p;
  if(s[0]=='L'){
    LL ln=dp[num-rp]-1;
    p=p-ln+(ln-1)/2;
    rp++;
    ss[++ssp]=0;
  }
  else if(s[0]=='R'){
    LL rn=dp[num-rp]-1;
    p=p+1+(rn-1)/2;
    rp++;
    ss[++ssp]=1;
  }
  else{
    if(ss[ssp]==0){
      LL rn=dp[num-rp]-1;
      p=p+1+rn;
    }
    else{
      LL ln=dp[num-rp]-1;
      p=p-1-ln;
    }
    ssp--;
    rp--;
  }

  return solve(s+1, ss, ssp, p, rp, num);
}

char s[100005];
bool ss[100];
int main(){
  dp[0]=1;
  for(int i=1; dp[i-1]<=1e18; i++){
    dp[i]=dp[i-1]*2;
  }
  LL n, p;
  int m;
  while(~scanf("%I64d%d", &n, &m)){
    int num = getNum(n);
    while(m--){
      scanf("%I64d%s", &p, s);
      int ssp=1;
      int rp = dfs(1, n, p, ss, ssp, 1);
      init(s, rp, num);

      printf("%I64d\n", solve(s, ss, ssp, p, rp, num));
    }
  }
  return 0;
}