oj.uz

답안 #652562

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
652562 2022-10-23T06:46:06 Z alvinpiter Type Printer (IOI08_printer) C++17
80 / 100
 1000 ms 99512 KB 
/*
* Insert each word into a trie
* "Add" operation is the same as going an edge downward, while "Remove" operation is the same as
  going an edge upward. If there is a requirement that the printer must be empty after all operations
  are performed, then the answer is 2 * numberOfEdgesInTheTrie + numberOfWords.
* However, we are allowed to leave some letters in the printer, so it is best if we leave the longest word in
  the printer.
*/

#include<bits/stdc++.h>
using namespace std;

struct TrieNode {
  int maxDepth;
  bool isEndOfAWord;
  TrieNode* children[26];

  TrieNode(): maxDepth(0), isEndOfAWord(false) {}
};

void insert(TrieNode* root, string s) {
  TrieNode* currentNode = root;
  for (int i = 0; i < s.length(); i++) {
    int charIndex = (s[i] - 'a');

    currentNode->maxDepth = max(currentNode->maxDepth, (int) s.length() - i);
    if (currentNode->children[charIndex] == NULL) {
      currentNode->children[charIndex] = new TrieNode();
    }

    currentNode = currentNode->children[charIndex];
  }

  currentNode->isEndOfAWord = true;
}

void traverse(TrieNode* root, vector<char>& result) {
  if (root->isEndOfAWord) {
    result.push_back('P');
  }

  int deepestChildIdx = -1;
  for (int i = 0; i < 26; i++) {
    if (root->children[i] != NULL && (deepestChildIdx == -1 || root->children[deepestChildIdx]->maxDepth < root->children[i]->maxDepth)) {
      deepestChildIdx = i;
    }
  }

  for (int i = 0; i < 26; i++) {
    if (root->children[i] != NULL && i != deepestChildIdx) {
      result.push_back((char) (i + 'a'));
      traverse(root->children[i], result);
    }
  }

  if (deepestChildIdx != -1) {
    result.push_back((char) (deepestChildIdx + 'a'));
    traverse(root->children[deepestChildIdx], result);
  }

  result.push_back('-');
}

int main() {
  int n;
  cin >> n;

  TrieNode* trieRoot = new TrieNode();
  for (int i = 0; i < n; i++) {
    string s;
    cin >> s;

    insert(trieRoot, s);
  }

  vector<char> result;
  traverse(trieRoot, result);

  while (result.back() == '-') {
    result.pop_back();
  }

  cout << result.size() << endl;
  for (auto r: result) {
    cout << r << endl;
  }
}

Compilation message

printer.cpp: In function 'void insert(TrieNode*, std::string)':
printer.cpp:23:21: warning: comparison of integer expressions of different signedness: 'int' and 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   23 |   for (int i = 0; i < s.length(); i++) {
      |                   ~~^~~~~~~~~~~~

Subtask #1
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct

Subtask #2
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct

Subtask #3
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 296 KB Output is correct

Subtask #4
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct

Subtask #5
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 3 ms 340 KB Output is correct
2 Correct 12 ms 1160 KB Output is correct

Subtask #6
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 22 ms 1792 KB Output is correct
2 Correct 25 ms 2132 KB Output is correct

Subtask #7
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 68 ms 5928 KB Output is correct
2 Correct 159 ms 12516 KB Output is correct

Subtask #8
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 203 ms 14660 KB Output is correct
2 Correct 55 ms 3364 KB Output is correct

Subtask #9
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 458 ms 36540 KB Output is correct
2 Execution timed out 1012 ms 83844 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #10
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 392 ms 28372 KB Output is correct
2 Execution timed out 1098 ms 99512 KB Time limit exceeded
3 Halted 0 ms 0 KB -