day14pt2

#include <iostream>
#include <fstream>
#include <vector>
#include <map>
using namespace std;

typedef struct element
{
    char element_letter;
    bool inserted;
    struct element *next_element;
    element() : element_letter('\0'), inserted(true), next_element(nullptr) {}
    element(char x) : element_letter(x), inserted(true), next_element(nullptr) {}
    void reset_inserted()
    {
        inserted = false;
        for (element *p = next_element; p != nullptr; p = p->next_element)
            p->inserted = false;
    }
} element;

typedef struct rule
{
    string elements_rule;
    char insert;

    void apply_rule(map<string, size_t> &current_applied_rules, map<string, size_t> &added_rules, size_t *amount_elements)
    {
        if (current_applied_rules.find(elements_rule) != current_applied_rules.end())
        {
            size_t amount = current_applied_rules[elements_rule];
            current_applied_rules.erase(elements_rule);
            string add_rule_1 = elements_rule.substr(0, 1);
            add_rule_1 += insert;
            string add_rule_2;
            add_rule_2 += insert;
            add_rule_2 += elements_rule.substr(1);
            if (added_rules.find(add_rule_1) != added_rules.end())
                added_rules[add_rule_1] += amount;
            else
                added_rules.insert(make_pair(add_rule_1, amount));
            if (added_rules.find(add_rule_2) != added_rules.end())
                added_rules[add_rule_2] += amount;
            else
                added_rules.insert(make_pair(add_rule_2, amount));

            amount_elements[(size_t)insert - 65] += amount;
            cout << elements_rule << " triggered " << amount << "times, added: "<< add_rule_1 << " and "<< add_rule_2 << endl;

        }
    }
    rule(string in, char i) : elements_rule(in), insert(i) {}
} rule;

int main(int argc, char **argv)
{
    fstream file(argv[1], ios_base::in);
    string input;
    bool input_switch = true;
    vector<rule> rules;
    size_t max_iteration = stoi(argv[2]);
    size_t amount_elements[26] = {0};
    map<string, size_t> current_rules;
    map<string, size_t> to_add_rules;
    while (getline(file, input, '\n'))
    {
        if (input == "")
            input_switch = false;
        else if (input_switch)
        {
            for (size_t j = 0; j < input.length() - 1; j++)
            {
                string new_rule = input.substr(j, 2);
                current_rules.insert(make_pair(new_rule, 1));
                amount_elements[(size_t)input[j] - 65]++;
            }
            amount_elements[(size_t)input[input.length() - 1] - 65]++;
        }
        else
        {
            char insert = input[input.length() - 1];
            rule r(input.substr(0, 2), insert);
            rules.push_back(r);
        }
    }
    //cout << "input handled" << endl;
    for (size_t j = 0; j < max_iteration; j++)
    {
        for (map<string, size_t>::iterator ptr = to_add_rules.begin(); ptr != to_add_rules.end(); ptr++)
            {
                if(current_rules.find(ptr->first)!=current_rules.end())
                    current_rules[ptr->first] += ptr->second;
                else
                    current_rules.insert(make_pair(ptr->first,ptr->second));
            }
        cout << "iteration: " << j << endl;
        to_add_rules.clear();


        for (auto _r : rules)
        {
            _r.apply_rule(current_rules, to_add_rules, amount_elements);
        }
        for (map<string, size_t>::iterator ptr = current_rules.begin(); ptr != current_rules.end(); ptr++)
        {

            cout <<"current rules "<< ptr->first << ": " << ptr->second << endl;
            ptr++;
        }
    }
    size_t max = 0, min = 99999999999999999;
    for (size_t j = 0; j < 26; j++)
    {
        if (max < amount_elements[j])
            max = amount_elements[j];
        if (min > amount_elements[j] && amount_elements[j] != 0)
            min = amount_elements[j];
    }
    cout << max - min << endl;
    cout << max << endl;
    cout << min << endl;
}