Uolevin kalansaalis

input/code.cpp: In function 'int main()':
input/code.cpp:19:11: warning: 'cur_val' may be used uninitialized [-Wmaybe-uninitialized]
   19 |     value = count;
      |     ~~~~~~^~~~~~~
input/code.cpp:60:20: note: 'cur_val' was declared here
   60 |   int y, x, count, cur_val, grid_total;
      |                    ^~~~~~~
input/code.cpp:120:3: warning: 'i' may be used uninitialized in this function [-Wmaybe-uninitialized]
  120 |   for (int i; i < y; i++) {
      |   ^~~
input/code.cpp:179:29: warning: 'grid_total' may be used uninitialized in this function [-Wmaybe-uninitialized]
  179 |   std::cout << grid_total - num;
      |                             ^~~

#include <iostream>
#include <vector>
#include <bits/stdc++.h> 
 
class Node {
  public:
 
  int value = 0;
  Node* right = nullptr;
  Node* rightu = nullptr;
  Node* rightd = nullptr;
  /*
  Node* left = nullptr;
  Node* leftu = nullptr;
  Node* leftd = nullptr;
  */
 
  Node (int count) {
    value = count;
  }
 
  void link_br(Node* other) { // executed from the top node
    //other->leftu = this;
    rightd = other;
    return;
  }
  
  void link_tr(Node* other) { // executed from the bottom node
    //other->leftd = this;
    rightu = other;
    return;
  }
 
  void link_right(Node* other) { // executed from the left node
    //other->left = this;
    right = other;
    return;
  }
 
  void set_value(char fish) {
    if (fish == 'H') {
      value = 1;
    } else {
      value = -10;
    }
    return;
  }
};
 
/*
y, x, count = gets.chomp.split(" ").map(&:to_i)
grid = Array.new(y){Array.new(x, 0)}
count.times do
  yi, xi, t = gets.chomp.split(" ")
  grid[yi.to_i-1][xi.to_i-1] = (t == "H" ? 1 : -10)
end
*/
 
int main() {
  int y, x, count, cur_val, grid_total;
 
  std::cin >> y >> x >> count;
  //std::cout << "y=" << y << ", x=" << x << ", count=" << count << "\n";
 
  Node* grid[y][x];
  
  // make grid
  for (int i = 0; i < y; i++) {
    for (int j = 0; j < x; j++) {
      grid[i][j] = new Node(cur_val);
    }
  }
 
  int cx, cy;
  char f;
 
  for (int i = 0; i < count; i++) {
    std::cin >> cx >> cy >> f;
    if (f == 'H') {
      cur_val = 1;
    } else {
      cur_val = -10;
    }
    grid_total += cur_val;
    grid[cx-1][cy-1]->value = cur_val;
  }
  
  // then add ptrs
  int addval = 0; // because hex grid and not square grid
  for (int i = 0; i < y; i++) {
    for (int j = 0; j < x; j++) {
      
      if ((j+addval) < x) {
        if (i > 0) {
          grid[i][j]->link_tr(grid[i-1][j+addval]);
        }
        if (i < (y - 1)) {
          grid[i][j]->link_br(grid[i+1][j+addval]);
        }
      }
      if ((j + 1) < x) {
        grid[i][j]->link_right(grid[i][j+1]);
      }
 
    }
    addval = 1 - addval;
  }
 
  /*
  find biggest triangle here 
  */
 
  Node *leftcorner, 
       *topcorner, 
       *bottomcorner,
       *rightcorner,
       *cur;
  int up_sum, down_sum;
  std::vector<int> values; // stores triangle values, for answer take grid_sum - values[n]
  for (int i; i < y; i++) {
    leftcorner = grid[i][0];
    while (leftcorner != nullptr) { // for each in row, walk right
 
    up_sum = leftcorner->value;
    down_sum = leftcorner->value;
    values.push_back(up_sum); // no need to do it twice
 
    topcorner = leftcorner->rightu;
    rightcorner = leftcorner->right;
    while (topcorner != nullptr && rightcorner != nullptr) {
      up_sum += rightcorner->value;
 
      cur = topcorner;
      while (cur != rightcorner) {
        up_sum += cur->value;
        cur = cur->rightd;
 
        if (cur->rightd == nullptr) {
          throw "aaaaaa";
          return 1;
        }
 
      }
      
 
      values.push_back(up_sum);
      topcorner = topcorner->rightu;
      rightcorner = rightcorner->right;
    }
 
    bottomcorner = leftcorner->rightd;
    rightcorner = leftcorner->right;
    while (bottomcorner != nullptr && rightcorner != nullptr) {
      down_sum += rightcorner->value;
 
      cur = bottomcorner;
      while (cur != rightcorner) {
        up_sum += cur->value;
        cur = cur->rightu;
 
        if (cur->rightu == nullptr) {
          throw "aaaaaa";
          return 1;
        }
 
      }
      
      
      values.push_back(down_sum);
      bottomcorner = bottomcorner->rightd;
      rightcorner = rightcorner->right;
    }
 
    leftcorner = leftcorner->right;
    }
  }
 
  int num = *min_element(values.begin(), values.end());
  std::cout << grid_total - num;
 
  return 0;
}

Test 1

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 2

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 3

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 4

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 5

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 6

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 7

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 8

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 9

Group: 1, 2

Verdict: WRONG ANSWER

Test 10

Group: 1, 2

Verdict: WRONG ANSWER

Test 11

Group: 1, 2

Verdict: WRONG ANSWER

Test 12

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 13

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 14

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 15

Group: 1, 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 16

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 17

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 18

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 19

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 20

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 21

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 22

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 23

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'

Test 24

Group: 2

Verdict: RUNTIME ERROR

terminate called after throwing an instance of 'char const*'