Rezultati

Up. imeNalogaJezikRezultatČas oddaje
ayy-2018 Alkani C++ 0/100Napačen odgovor (WA) 13. okt '18 @ 15:38

Test Točke Porabljen spomin Porabljen čas Status
#1 0/5 11,016 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
metan
C
Pravilen izhod:
​99973x metan
7x etan
1x propan
<<<EOF>>>
#2 0/5 4,875 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
metan
C
Pravilen izhod:
​3784x metan
1472x etan
1048x propan
522x butan
279x pentan
#3 0/5 5,254 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
pentan
-----
C
Pravilen izhod:
​2961x metan
2331x etan
1309x propan
494x butan
259x pentan
#4 0/5 5,250 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
etan
-----
C
Pravilen izhod:
​3044x metan
1658x etan
1363x propan
525x butan
305x pentan
#5 0/5 5,383 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
metan
C
Pravilen izhod:
​2227x metan
1172x propan
810x butan
741x etan
400x pentan
#6 0/5 4,008 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
pentan
-----
C
Pravilen izhod:
​476x metan
168x pentan
141x etan
101x heksan
94x propan
#7 0/5 5,281 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
etan
-----
C
Pravilen izhod:
​4955x metan
1545x etan
1070x propan
532x butan
284x pentan
#8 0/5 5,328 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
etan
-----
C
Pravilen izhod:
​3816x metan
1721x etan
1188x propan
544x butan
269x pentan
#9 0/5 5,102 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
metan
C
Pravilen izhod:
​4527x metan
1570x etan
1196x propan
495x butan
312x pentan
#10 0/5 5,445 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
--------
3-metil-heksan
Pravilen izhod:
​5311x metan
1798x etan
1150x propan
510x butan
288x pentan
#11 0/5 5,137 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
pentan
-----
C
Pravilen izhod:
​2469x metan
1252x etan
1220x propan
709x butan
333x pentan
#12 0/5 5,313 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
nonan
-----
C
Pravilen izhod:
​4337x metan
1403x etan
1016x propan
504x butan
315x pentan
#13 0/5 5,484 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
metan
C
--------
etan
Pravilen izhod:
​5103x metan
1584x etan
1080x propan
595x butan
289x pentan
#14 0/5 5,480 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
heksan
-----
C
Pravilen izhod:
​5734x metan
1668x etan
1214x propan
482x butan
291x pentan
#15 0/5 3,273 MiB 0,009 s Napačen odgovor
Tvoj izhod:
​C
metan
C
--------
etan
Pravilen izhod:
​1x butan
1x dekan
1x dodekan
1x etan
1x heksan
#16 0/5 3,059 MiB 0,003 s Napačen odgovor
Tvoj izhod:
​C
--------
2-metil-propan
l: 1  - 1 
-----
Pravilen izhod:
​2x 2,2,3-trimetil-butan
1x 2,2,3,3-tetrametil-butan
1x 2,2-dimetil-propan
1x 2,3,3-trimetil-pentan
1x 2,3,4,4-tetrametil-heksan
#17 0/5 3,059 MiB 0,004 s Napačen odgovor
Tvoj izhod:
​C
--------
5-metil-4-etil-oktan
l: 1  - 3 
l: 2  - 4 
Pravilen izhod:
​1x 4-etil-5-metil-oktan
<<<EOF>>>
#18 0/5 3,309 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
3-metil-dodekan
l: 1  - 2 
-----
Pravilen izhod:
​3x 3,3,4,4,5,5,6,7,7,9,9-undekametil-dodekan
2x 3,3,4,4,5,5,6,7,7,9,9,10-dodekametil-dodekan
1x 3,3,4,4,5,5,6,7,9,9-dekametil-dodekan
1x 3,3,4,4,5,5,6,9,9-nonametil-dodekan
1x 3,3,4,4,5,5,6,9-oktametil-dodekan
#19 0/5 3,277 MiB 0,007 s Napačen odgovor
Tvoj izhod:
​C
--------
propan
-----
C
Pravilen izhod:
​17x metan
4x etan
4x propan
3x butan
1x 3,7-dimetil-nonan
#20 0/5 3,277 MiB 0,000 s Napačen odgovor
Tvoj izhod:
​C
--------
propan
-----
C
Pravilen izhod:
​5x metan
2x etan
2x propan
1x 3-metil-oktan
1x 3-metil-pentan

Ocenjevani program (main.cpp):
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <sstream>

using namespace std;

int n, m;

vector<string> alkani = {
    "", "metan", "etan", "propan", "butan", "pentan", "heksan", "heptan", "oktan", "nonan", "dekan", "undekan", "dodekan"
};

vector<string> alkili = {
    "", "metil", "etil", "propil", "butil", "pentil", "heksil", "heptil", "oktil", "nonil", "dekil", "undekil", "dodekil"
};

vector<string> stevniki = {
    "", "", "di", "tri", "tetra", "penta", "heksa", "hepta", "okta", "nona", "deka", "undeka", "dodeka"
};

struct z {
    int len;
    vector<int> where;
};

struct node {
    vector<node*> siblings;
    bool main = false;
    bool visited = false;
    bool visitedReverse = false;
    bool visitedBranch = false;
    int depth = 0;
    int depthReverse = 0;
    node* previous = nullptr;
    vector<int> branchLengths;
};

node* obdelaj(vector<string>& input, int x, int y) {
    node* novi = new node();

    input[y][x] = '.';
    if (y - 1 >= 0) {
        if (input[y - 1][x] == '|') {
            input[y - 1][x] = '.';
            node* a = obdelaj(input, x, y - 2);
            a->siblings.push_back(novi);
            novi->siblings.push_back(a);
        }
    }

    if (y + 1 < n) {
        if (input[y + 1][x] == '|') {
            input[y + 1][x] = '.';
            node* a = obdelaj(input, x, y + 2);
            a->siblings.push_back(novi);
            novi->siblings.push_back(a);
        }
    }

    if (x - 1 >= 0) {
        if (input[y][x - 1] == '-') {
            input[y][x - 1] = '.';
            node* a = obdelaj(input, x - 2, y);
            a->siblings.push_back(novi);
            novi->siblings.push_back(a);
        }
    }

    if (x + 1 < m) {
        if (input[y][x + 1] == '-') {
            input[y][x + 1] = '.';
            node* a = obdelaj(input, x + 2, y);
            a->siblings.push_back(novi);
            novi->siblings.push_back(a);
        }
    }

    return novi;
}

int main() {
    cin >> n >> m;
    int read = n;

    string str;
    vector<string> input;

    while (read--) {
        cin >> str;
        input.push_back(str);
    }

    for (int y = 0; y < n; y++) {
        for (int x = 0; x < m; x++) {
            if (input[y][x] == 'C') {
                cout << "C" << endl;
                node* js = obdelaj(input, x, y);

                if (js->siblings.size() == 0) {
                    cout << "metan" << endl;
                } else {
                    node* maxNode;
                    {
                        stack<node*> sklad;
                        js->depth = 0;
                        sklad.push(js);

                        maxNode = js;

                        while (!sklad.empty()) {
                            node* top = sklad.top();
                            sklad.pop();

                            top->visited = true;
                            if (top->depth > maxNode->depth) {
                                maxNode = top;
                            }

                            for (int i = 0; i < top->siblings.size(); i++) {
                                node* tmp = top->siblings[i];
                                if (!tmp->visited) {
                                    tmp->depth = top->depth + 1;
                                    sklad.push(tmp);
                                }
                            }
                        }
                    }

                    node* maxNodeReverse;
                    {
                        stack<node*> sklad;
                        maxNode->depthReverse = 0;
                        sklad.push(maxNode);

                        maxNodeReverse = maxNode;

                        while (!sklad.empty()) {
                            node* top = sklad.top();
                            sklad.pop();

                            top->visitedReverse = true;
                            if (top->depthReverse > maxNodeReverse->depthReverse) {
                                maxNodeReverse = top;
                            }

                            for (int i = 0; i < top->siblings.size(); i++) {
                                node* tmp = top->siblings[i];
                                if (!tmp->visitedReverse) {
                                    tmp->depthReverse = top->depthReverse + 1;
                                    tmp->previous = top;
                                    sklad.push(tmp);
                                }
                            }
                        }
                    }

                    cout << "--------" << endl;

                    {
                        node* tmp = maxNodeReverse;
                        while (tmp != nullptr) {
                            tmp->main = true;
                            tmp = tmp->previous;
                        }
                    }

                    {
                        node* tmp = maxNodeReverse;
                        while (tmp != nullptr) {
                            tmp->visitedBranch = true;
                            for (int i = 0; i < tmp->siblings.size(); i++) {
                                node* sibling = tmp->siblings[i];
                                if (!sibling->main) {
                                    int branchDepth = 1;

                                    while (true) {
                                        sibling->visitedBranch = true;
                                        bool jeKonec = true;
                                        for (int j = 0; j < sibling->siblings.size(); j++) {
                                            if (!sibling->siblings[j]->visitedBranch) {
                                                branchDepth++;
                                                sibling = sibling->siblings[j];
                                                jeKonec = false;
                                                break;
                                            }
                                        }

                                        if (jeKonec)
                                            break;
                                    }

                                    tmp->branchLengths.push_back(branchDepth);
                                }
                            }

                            tmp = tmp->previous;
                        }
                    }

                    vector<vector<int>> branches;

                    {
                        node* tmp = maxNodeReverse;
                        while (tmp != nullptr) {
                            branches.push_back(tmp->branchLengths);
                            tmp = tmp->previous;
                        }
                    }

                    vector<z> zs;
                    vector<z> zsr;
                    vector<int> a;
                    vector<int> b;

                    for (int l = 1; l <= 12; l++) {
                        bool exists = false;
                        for (int i = 0; i < branches.size(); i++) {
                            for (int j = 0; j < branches[i].size(); j++) {
                                if (l == branches[i][j]) {
                                    exists = true;
                                }
                            }
                        }

                        if (exists) {
                            z tmpz;
                            tmpz.len = l;
                            z tmpr;
                            tmpr.len = l;

                            for (int i = 0; i < branches.size(); i++) {
                                for (int j = 0; j < branches[i].size(); j++) {
                                    if (l == branches[i][j]) {
                                        tmpz.where.push_back(i);
                                        tmpr.where.push_back(maxNodeReverse->depthReverse - i);
                                        a.push_back(i);
                                        b.push_back(maxNodeReverse->depthReverse - i);
                                    }
                                }
                            }

                            zs.push_back(tmpz);
                            zsr.push_back(tmpr);
                        }
                    }

                    sort(a.begin(), a.end());
                    sort(b.begin(), b.end());
                    bool aZmagal;

                    for (int i = 0; i < a.size(); i++) {
                        if (a[i] == b[i]) continue;

                        aZmagal = a[i] < b[i];
                        break;
                    }

                    vector<z> boljsi = aZmagal ? zs : zsr;

                    stringstream ss;

                    for (int i = 0; i < boljsi.size(); i++) {
                        for (int j = 0; j < boljsi[i].where.size(); j++) {
                            ss << boljsi[i].where[j] + 1;

                            if (j < boljsi[i].where.size() - 1) {
                                ss << ",";
                            } else {
                                ss << "-";
                            }
                        }

                        ss << stevniki[boljsi[i].where.size()] << alkili[boljsi[i].len] << "-";
                    }

                    ss << alkani[maxNodeReverse->depthReverse + 1];

                    cout << ss.str() << endl;

                    for (int i = 0; i < zs.size(); i++) {
                        cout << "l: " << zs[i].len << "  - ";
                        for (int j = 0; j < zs[i].where.size(); j++) {
                            cout << zs[i].where[j] << " ";
                        }

                        cout << endl;
                    }

                    cout << "-----\n";

                    for (int i = 0; i < zsr.size(); i++) {
                        cout << "l: " << zsr[i].len << "  - ";
                        for (int j = 0; j < zsr[i].where.size(); j++) {
                            cout << zsr[i].where[j] << " ";
                        }

                        cout << endl;
                    }
                }
            }
        }
    }

    return 0;
}