HDU-1251-统计难题(Trie树)(BST)(AVL)

• 字典树解法（Trie树）

  Accepted

  1251

  156MS

  45400K

  949 B

  C++

  #include"iostream"
  #include"cstdlib"
  #include"cstring"
  #include"cstdio"
  using namespace std;
  struct tree {
      int cnt;
      tree* Next[];
  } *root;
  tree* init() {
      tree* t = (tree*) malloc(sizeof(tree));
      memset(t -> Next, NULL, sizeof(t -> Next));
      t -> cnt = ;
      return t;
  }
  void in(char* s) {
      tree* now = root;
      for(int i = ; s[i]; i++) {
          int j = s[i] - 'a';
          if(! now -> Next[j])
          now -> Next[j] = init();
          now = now -> Next[j];
          now -> cnt++;
      }
  }
  void out(char* s) {
      tree* now = root;
      for(int i = ; s[i]; i++) {
          int j = s[i] - 'a';
          if(!now -> Next[j]) {
              puts("");
              return;
          }
          now = now -> Next[j];
      }
      printf("%d\n", now -> cnt);
  }
  char s[];
  int main() {
      root = init();
      while(gets(s) && s[])
          in(s);
      while(gets(s))
          out(s);
      return ;
  }

• 二叉搜索树解法（BST）

  Accepted

  1251

  358MS

  18864K

  1443B

  G++

  #include "bits/stdc++.h"
  using namespace std;
  typedef long long LL;
  const int INF = 0x3f3f3f3f;
  struct BST {
      char key[];
      int value;
      BST* lson;
      BST* rson;
  }*root;
  char s[];
  BST* init() {
      BST* point = (BST*)malloc(sizeof(BST));
      strcpy(point->key, s);
      point->value = ;
      point->lson = point->rson = NULL;
      return point;
  }
  void insert() {
      BST* father = NULL;
      BST* now = root;
      int cmp;
      while (now != NULL) {
          cmp = strcmp(now->key, s);
          if (cmp == ) {
              now->value++;
              return;
          } else if (cmp == -) {
              father = now;
              now = now->rson;
          } else {
              father = now;
              now = now->lson;
          }
      }
      if (father == NULL) {
          root = init();
      } else if (cmp == -) {
          father->rson = init();
      } else {
          father->lson = init();
      }
  }
  int query() {
      BST* now = root;
      while (now != NULL) {
          int cmp = strcmp(now->key, s);
          if (cmp == ) {
              return now->value;
          } else if (cmp == -) {
              now = now->rson;
          } else {
              now = now->lson;
          }
      }
      return ;
  }
  int main() {
      while (gets(s) && s[]) {
          int len = strlen(s);
          while (len != ) {
              s[len--] = '\0';
              insert();
          }
      }
      while (~scanf("%s", &s)) {
          printf("%d\n", query());
      }
      return ;
  }

• 平衡二叉搜索树解法（AVL）
  

  Accepted

  1251

  343MS

  24648K

  3885B

  G++

  #include "bits/stdc++.h"
  using namespace std;
  typedef long long LL;
  const int INF = 0x3f3f3f3f;
  struct AVL {
      char key[];
      int value;
      int height;
      AVL* father;
      AVL* lson;
      AVL* rson;
  }*root;
  AVL* fafa;
  AVL* fa;
  AVL* me;
  char key[];
  AVL* init(AVL* fa) {
      AVL* point = (AVL*)malloc(sizeof(AVL));
      strcpy(point->key, key);
      point->value = ;
      point->father = fa;
      point->height = ;
      point->lson = point->rson = NULL;
      return point;
  }
  void updateHeight(AVL* point) {
      int lheight = point->lson == NULL ?  : point->lson->height;
      int rheight = point->rson == NULL ?  : point->rson->height;
      point->height = max(lheight, rheight) + ;
      if (point->father != NULL) {
          updateHeight(point->father);
      }
  }
  bool unbalance(AVL* point) {
      me = point;
      fa = point->father;
      fafa = fa->father;
      if (fafa == NULL) {
          return false;
      }
      int lheight = fafa->lson == NULL ?  : fafa->lson->height;
      int rheight = fafa->rson == NULL ?  : fafa->rson->height;
      if (abs(lheight    - rheight) > ) {
          return true;
      }
      return unbalance(fa);
  }
  void leftRotate(AVL* fa, AVL* me) {
      AVL* fafa = fa->father;
      me->father = fafa;
      if (fafa != NULL) {
          if (fafa->lson == fa) {
              fafa->lson = me;
          } else {
              fafa->rson = me;
          }
      }
      fa->rson = me->lson;
      if (me->lson != NULL) {
          me->lson->father = fa;
      }
      fa->father = me;
      me->lson = fa;
      updateHeight(fa);
  }
  void rightRotate(AVL* fa, AVL* me) {
      AVL* fafa = fa->father;
      me->father = fafa;
      if (fafa != NULL) {
          if (fafa->lson == fa) {
              fafa->lson = me;
          } else {
              fafa->rson = me;
          }
      }
      fa->lson = me->rson;
      if (me->rson != NULL) {
          me->rson->father = fa;
      }
      fa->father = me;
      me->rson = fa;
      updateHeight(fa);
  }
  void rebalance() {
      if (fafa->lson == fa && fa->lson == me) {
          rightRotate(fafa, fa);
          return;
      }
      if (fafa->rson == fa && fa->rson == me) {
          leftRotate(fafa, fa);
          return;
      }
      if (fafa->lson == fa && fa->rson == me) {
          leftRotate(fa, me);
          rightRotate(fafa, me);
          return;
      }
      rightRotate(fa, me);
      leftRotate(fafa, me);
  }
  void insert() {
      AVL* father = NULL;
      AVL* now = root;
      int cmp;
      while (now != NULL) {
          if (strcmp(now->key, key) == ) {
              now->value++;
              return;
          }
          father = now;
          cmp = strcmp(now->key, key);
          if (cmp == -) {
              now = now->rson;
          } else {
              now = now->lson;
          }
      }
      if (father == NULL) {
          root = init(NULL);
          return;
      } else if (cmp == -) {
          father->rson = init(father);
          updateHeight(father);
          if (unbalance(father->rson)) {
              rebalance();
          }
      } else {
          father->lson = init(father);
          updateHeight(father);
          if (unbalance(father->lson)) {
              rebalance();
          }
      }
  }
  int query() {
      AVL* now = root;
      while (now != NULL) {
          int cmp = strcmp(now->key, key);
          if (cmp == ) {
              return now->value;
          } else if (cmp == -) {
              now = now->rson;
          } else {
              now = now->lson;
          }
      }
      return ;
  }
  int main() {
      while (gets(key) && key[]) {
          int len = strlen(key);
          while (len != ) {
              key[len--] = '\0';
              insert();
              if (root->father != NULL) {
                  root = root->father;
              }
          }
      }
      while (~scanf("%s", key)) {
          printf("%d\n", query());
      }
      return ;
  }