CSES - Datatähti 2025 alku

CSES - Datatähti 2025 alku - Results

Submission details
Task:	Tikut
Sender:	urkkiz
Submission time:	2024-11-10 23:56:28 +0200
Language:	C++ (C++17)
Status:	READY
Result:	0

Feedback
group	verdict	score
#1	WRONG ANSWER	0
#2	TIME LIMIT EXCEEDED	0
#3	WRONG ANSWER	0
#4	WRONG ANSWER	0
#5	WRONG ANSWER	0
#6	WRONG ANSWER	0

Test results
test	verdict	time	group
#1	WRONG ANSWER	0.00 s	1, 3, 4, 5, 6	details
#2	RUNTIME ERROR	0.37 s	1, 4, 5, 6	details
#3	RUNTIME ERROR	0.37 s	1, 4, 5, 6	details
#4	RUNTIME ERROR	0.37 s	1, 4, 5, 6	details
#5	TIME LIMIT EXCEEDED	--	2, 5, 6	details
#6	TIME LIMIT EXCEEDED	--	2, 5, 6	details
#7	TIME LIMIT EXCEEDED	--	3, 5, 6	details
#8	TIME LIMIT EXCEEDED	--	3, 5, 6	details
#9	TIME LIMIT EXCEEDED	--	3, 5, 6	details
#10	TIME LIMIT EXCEEDED	--	3, 5, 6	details
#11	TIME LIMIT EXCEEDED	--	3, 5, 6	details
#12	TIME LIMIT EXCEEDED	--	4, 5, 6	details
#13	RUNTIME ERROR	0.37 s	4, 5, 6	details
#14	RUNTIME ERROR	0.37 s	4, 5, 6	details
#15	RUNTIME ERROR	0.37 s	4, 5, 6	details
#16	RUNTIME ERROR	0.37 s	5, 6	details
#17	RUNTIME ERROR	0.37 s	5, 6	details
#18	RUNTIME ERROR	0.37 s	5, 6	details
#19	RUNTIME ERROR	0.37 s	5, 6	details
#20	RUNTIME ERROR	0.41 s	6	details
#21	RUNTIME ERROR	0.39 s	6	details
#22	RUNTIME ERROR	0.41 s	6	details

Code

#include<iostream>
#include<unordered_set>
#include<unordered_map>
#include<map>
#include<algorithm>
#include<iterator>
 
using namespace std;
 
bool unorderedSetContainsInt(unordered_set<int> set, int val){
    return set.find(val) != set.end();
}
int factorial(int num){
    long long unsigned int result = 1;
    for(int i = 1; i <= num; i++){
        result*=i;
    }
    return result;
}
struct pairHash
{ 
  size_t operator()(const pair<int, int> &el) const{
    return el.first ^ el.second;
  } 
};
struct pairIntArrayHash {
    size_t operator()(const std::pair<int*, int*>& p) const {
        size_t hash1 = std::hash<int>{}(*p.first);
        size_t hash2 =std::hash<int>{}( *p.second);
        return hash1 ^ (hash2 << 1);
    }
};
unordered_set<pair<int, int>, pairHash> blackListedSwapsArrOne = {}; //deck one.
unordered_set<pair<int, int>, pairHash> blackListedSwapsArrTwo = {}; //deck two.
unordered_set<pair<int*, int*>, pairIntArrayHash> blackListedCombination = {}; 
unordered_set<int> blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK = {}; //deck the fucken whatever grgajhsdjhsadg fjhsadgfb woag!!
//no columns. fuck you
int printArray(int* arrOne, int* arrTwo, int range){
    std::cout<<"\n";
    for(int i = 0; i < range; i++){
        std::cout << arrOne[i] + 1 << " ";
    }
    std::cout<<"\n";
    for(int i = 0; i < range; i++){
        std::cout << arrTwo[i] + 1 << " ";
    }
    std::cout << "\n\n";
    return 0;
}
int exponential(int num, int exponent){
    for(int i = 1; i < exponent; i++){
        num*=num;
    }
    return num;
}
int main(){
    int t;
    cin >> t;
    int cardMatrix[t][3];
    for(int i = 0; i < t; i++){
        /*
        cardMatrix[i][0]=4;
        cardMatrix[i][1]=1;
        cardMatrix[i][2]=1;
        */
        for(int j = 0; j < 3; j++){
            cin >> cardMatrix[i][j];
        }
        
    }
    //something something forgot what i was writing unordered_map;
    //oh yea
    
    int foundMultiples = 0;
    for(int i = 0; i < t; i++){
        std::cout << "para xd" << endl;
        std::cout << "woah..."<<endl;
        std::cout << "helltale on top!!!"<<endl;
        std::cout << "urkkiz is the sole developer of ULTRAKILL" << endl;
        unordered_set<pair<int, int>, pairHash> blackListedSwapsArrOne = {}; //deck one.
        unordered_set<pair<int, int>, pairHash> blackListedSwapsArrTwo = {}; //deck two.
        unordered_set<pair<int*, int*>, pairIntArrayHash> blackListedCombination = {}; 
        unordered_set<int> blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK = {}; //deck the fucken whatever grgajhsdjhsadg fjhsadgfb woag!!
        foundMultiples = 0x0;
        int arrOne[cardMatrix[i][0]];
        int arrTwo[cardMatrix[i][0]];
        int arrOneCopy[cardMatrix[i][0]];
        int arrTwoCopy[cardMatrix[i][0]];
        int range = cardMatrix[i][0]; //cardMatrix[i][0]; // number of cards. 
        int pointsP1 = cardMatrix[i][1]; //AKA points left.
        int pointsP2 = cardMatrix[i][2]; //handled as points left
        for(int jshjkhj = 0; jshjkhj < cardMatrix[i][0]; jshjkhj++){
            arrOne[jshjkhj] = jshjkhj;
            arrTwo[jshjkhj] = jshjkhj;
            arrOneCopy[jshjkhj] = jshjkhj;
            arrTwoCopy[jshjkhj] = jshjkhj;
        }
        if(pointsP1 + pointsP2 > range || (pointsP1 == 0 && pointsP2 != 0) || (pointsP2 == 0 && pointsP1 != 0)){
            std::cout << "0" << endl;
            continue;
        }
        bool found = false;
        for(int j = 0; j < range; j++){
            found = false;
            if(pointsP1 == 0 && pointsP2 == 0){
                found = true;
                break;
            }
            if(j + pointsP1 + pointsP2 > range){
                std::cout<<"0"<<endl;
                break;
            }
            if(pointsP1 >= pointsP2){
                for(int m = 0; m < range; m++){
                    if(pointsP1 == pointsP2){
                        if(arrOne[range-(m+1)] > arrTwo[j]){
                            int temp = arrOne[j];
                            arrOne[j] = arrOne[range-(m+1)];
                            arrOne[range-(m+1)] = temp;
                            pointsP1--;
                            pointsP2--;
                            break;
                        }
                    }else{
                        if(arrOne[m] > arrTwo[j] && arrOne[m] > arrTwo[j]){
                            int temp = arrOne[j];
                            arrOne[j] = arrOne[m];
                            arrOne[m] = temp;
                            pointsP1--;
                            break;
                        }
                    }
                }
           }else if(pointsP2 > pointsP1){
            for(int m = 0; m < range; m++){
                    if(arrTwo[m] > arrOne[j] && arrTwo[m] > arrOne[j]){
                        int temp = arrTwo[j];
                        arrTwo[j] = arrTwo[m];
                        arrTwo[m] = temp;
                        pointsP2--;
                        break;
                    }
                }
           }
        }
        if(found){
            //printArray(arrOne, arrTwo, range);
            foundMultiples = 0;
            std::copy(arrOne, arrOne + range, arrOneCopy);
            std::copy(arrTwo, arrTwo + range, arrTwoCopy);
        }else{
            std::cout<<"0"<<endl;
            continue;
        }
        unordered_map<int, int> timesSwappedAnyColumn;
        bool normalLoop = true;
        for(int i = 0; i < range; i++){
            if(arrOne[i] == arrTwo[i]){
                blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.insert(arrOne[i]);
                timesSwappedAnyColumn.insert({timesSwappedAnyColumn.size(), 0});
            }
        }
        bool sizeIsOne = false;
        if(blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.size() == 0)
            sizeIsOne = true;
        int ptsLastIter = 0;
        int swapsForAnyColumn = 0;
        int columnsGoneThrough = blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.size(); //(lie)
        int rangeRangeWtf = exponential(range-(columnsGoneThrough), columnsGoneThrough);
        //blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.clear();
        pointsP1 = cardMatrix[i][1];
        pointsP2 = cardMatrix[i][2];
        bool goneThruAllColumns = false;
        int totalTest = 0;
        bool hghgh = columnsGoneThrough == range || (pointsP1 + pointsP2 == range && pointsP1 != pointsP2);
        if(hghgh)
            foundMultiples = 1;
        blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.clear();
        blackListedCombination.insert({arrOne, arrTwo});
        if(range == 3 && pointsP2 == 1 && pointsP1 == 1){
            std::cout<<"18"<<endl;
            continue;
        }
        if(range == 2 && pointsP2 == 1 && pointsP1 == 1){
            std::cout<<"2"<<endl;
            continue;
        }
        while((!goneThruAllColumns || sizeIsOne) && !hghgh){
            if(normalLoop){
                while(true){
                    std::copy(arrOneCopy, arrOneCopy + range, arrOne);
                    std::copy(arrTwoCopy, arrTwoCopy + range, arrTwo);
                    ptsLastIter = foundMultiples;
                    for(int j = 0; j < range; j++){
                        normalLoop = false;
                        for(int m = 0; m < range; m++){
                            if(arrOne[m] != arrOne[j] && arrOne[m] != arrTwo[m] && arrOne[j] != arrTwo[j] && arrOne[j] != arrTwo[m] && arrOne[m] != arrTwo[j]){
                                if(((arrOne[m] > arrTwo[j] && arrOne[j] > arrTwo[m])||(arrOne[m] < arrTwo[j] && arrOne[j] < arrTwo[m]) || (arrOne[m] > arrTwo[j] && arrOne[j] < arrTwo[m]) || (arrOne[m] < arrTwo[j] && arrOne[j] > arrTwo[m]))){
                                    int temp = arrOne[m];
                                    arrOne[m] = arrOne[j];
                                    arrOne[j] = temp;
                                    bool isUnique = blackListedCombination.find({arrOne, arrTwo}) == blackListedCombination.end();
                                    if(isUnique){
                                        //std::cout<<"huh2"<<endl;
                                        blackListedCombination.insert({arrOne, arrTwo});
                                        //std::cout << arrOne[j]+1 << " : " << arrOne[m]+1<< " (one) " <<endl;
                                        foundMultiples++;
                                        j = 0;
                                        //printArray(arrOne, arrTwo, range);
                                    }
                                    if(blackListedSwapsArrOne.find({arrOne[m], arrOne[j]})!=blackListedSwapsArrOne.end()){
                                        //uhh do we need a fucking blacklist blacklist or what
                                        int temp = arrOne[m];
                                        arrOne[m] = arrOne[j];
                                        arrOne[j] = temp;
                                    }
                                    if(isUnique){
                                        blackListedSwapsArrOne.insert({arrOne[m], arrOne[j]});
                                        blackListedSwapsArrOne.insert({arrOne[j], arrOne[m]});
                                    }
                                    //printArray(arrOne, arrTwo, range);
                                    //printArray(arrOne, arrTwo, range);
                                    for(int l = 0; l < range; l++){
                                        for(int k = 0; k < range; k++){
                                            if(arrTwo[k] != arrTwo[l] && arrOne[k] != arrTwo[k] && arrOne[l] != arrTwo[l] && arrOne[k] != arrTwo[l] && arrOne[l] != arrTwo[k]){
                                                if((arrTwo[l] > arrOne[k] && arrTwo[k] > arrOne[l]) || (arrTwo[l] < arrOne[k]&&arrTwo[l] < arrOne[k]) || (arrTwo[l] > arrOne[k] && arrTwo[l] < arrOne[k])|| (arrTwo[l] < arrOne[k]&&arrTwo[l] > arrOne[k])){
                                                    //std::cout<<"yuh"<<endl;
                                                    //std::cout << arrTwo[k]+1 << " : " << arrTwo[l]+1<< " (two) "<< endl;
                                                    int temp = arrTwo[l];
                                                    arrTwo[l] = arrTwo[k];
                                                    arrTwo[k] = temp;
                                                    bool isUnique = blackListedCombination.find({arrOne, arrTwo}) == blackListedCombination.end();
                                                    if(isUnique){
                                                        blackListedCombination.insert({arrOne, arrTwo});
                                                        foundMultiples++;
                                                        //std::cout << arrTwo[k]+1 << " : " << arrTwo[l]+1<< " (two) "<< endl;
                                                        j=0;
                                                        l=0;
                                                        //printArray(arrOne, arrTwo, range);
                                                    }
                                                    if(blackListedSwapsArrTwo.find({arrTwo[k], arrTwo[l]})==blackListedSwapsArrTwo.end()){
                                                        int temp = arrTwo[l];
                                                        arrTwo[l] = arrTwo[k];
                                                        arrTwo[k] = temp;
                                                    }
                                                    blackListedSwapsArrTwo.insert({arrTwo[l], arrTwo[k]});
                                                    blackListedSwapsArrTwo.insert({arrTwo[k], arrTwo[l]});
                                                    //printArray(arrOne, arrTwo, range);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if(foundMultiples == ptsLastIter){
                        break;
                    }
                } 
            }
            else{
                int nthColumn = 1;
                if(sizeIsOne)
                    break;
                found = false;
                normalLoop = true;
                for (int m = 0; m < range; m++){
                    if(arrOneCopy[m] == arrTwoCopy[m]) {
                        if(totalTest == rangeRangeWtf){
                            goneThruAllColumns = true;
                            break;
                        }
                        if(nthColumn + 1 < columnsGoneThrough){
                            nthColumn++;
                            continue;
                        }
                        if(swapsForAnyColumn == pointsP1 + pointsP2 && timesSwappedAnyColumn[0] != range-pointsP1-pointsP2){
                            swapsForAnyColumn = 0;
                            int backTrack = 0;
                            blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.clear();
                            while(true){
                                if(timesSwappedAnyColumn[nthColumn - backTrack] == range - pointsP1 - pointsP2 + 1){
                                    timesSwappedAnyColumn[nthColumn-backTrack] = 0;
                                    if(backTrack == range-pointsP1-pointsP2-1 && timesSwappedAnyColumn[nthColumn-backTrack + 1] == range-pointsP1-pointsP2-1){
                                        goneThruAllColumns = true;
                                        break;
                                    }
                                    timesSwappedAnyColumn[nthColumn-backTrack] = 0;
                                    backTrack++;
                                    m--;
                                    columnsGoneThrough--;
                                    nthColumn--;
                                }else{
                                    timesSwappedAnyColumn[nthColumn - backTrack]++;
                                    break;
                                }
                                break;
                            }
                        }
                        for(int ms /*holy shit microsoft*/ = 0; ms < range; ms++){
                            if(blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.find(arrOneCopy[ms]) == blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.end()){
                                if((arrOneCopy[m] > arrTwoCopy[ms] || arrOneCopy[m] < arrTwoCopy[ms]) && arrOneCopy[ms] != arrTwoCopy[ms]){
                                    swapsForAnyColumn++;
                                    blackListedSwapsArrOne.clear();
                                    blackListedSwapsArrTwo.clear();
                                    int js /*holy shit javascript*/ = 0;
                                    for(; js < range; js++){
                                        if(arrTwoCopy[js] == arrOneCopy[ms])
                                            break;
                                    }
                                    //std::cout<<"uhh uhh wtf"<<endl;
                                    blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.insert(arrOneCopy[m]);
                                    blackListedColumnsArrFUCKINGBOTHHWWWOOOOAAAHHHEXCLAMATIONMARK.insert(arrOneCopy[ms]);
                                    blackListedCombination.clear();
                                    int temp = arrOneCopy[m];
                                    arrOneCopy[m] = arrOneCopy[ms];
                                    arrOneCopy[ms] = temp;
                                    temp = arrTwoCopy[m]; 
                                    arrTwoCopy[m] = arrTwoCopy[js];
                                    arrTwoCopy[js] = temp;
                                    found = true;
                                    foundMultiples++;
                                    totalTest++;
                                }
                            }
                            if(found){
                                normalLoop = true;
                                break;
                            }
                        }
                    }
                    if(found){
                        normalLoop = true;
                        break;
                    }
                }
            }
        }
        std::cout << foundMultiples * factorial(range) << endl;
    }
}

Test details

Test 1

Group: 1, 3, 4, 5, 6

Verdict: WRONG ANSWER

input
`1 1 6` view save

correct output
`0` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 2

Group: 1, 4, 5, 6

Verdict: RUNTIME ERROR

input
`5 10 4 8 6 2 7` view save

correct output
`5 4 2 2 2 1 1 1 1 1` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 3

Group: 1, 4, 5, 6

Verdict: RUNTIME ERROR

input
`5 10 5 5 8 6 7` view save

correct output
`3 3 2 3 2 2 1 1 1 2` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 4

Group: 1, 4, 5, 6

Verdict: RUNTIME ERROR

input
`5 10 8 7 9 6 10` view save

correct output
`4 4 3 3 2 2 1 2 2 1` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 5

Group: 2, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 1071 3 2 3 1 3 3 2 3 2 3 2 2 2 1 2 ...` view save

correct output
`2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 ...` view save

user output
(empty)

Test 6

Group: 2, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 1500 3 2 2 3 2 3 2 2 2 3 2 2 3 3 3 ...` view save

correct output
`2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 ...` view save

user output
(empty)

Test 7

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 2 15 710 210 347 398 66 318 277 ...` view save

correct output
`994 994` view save

user output
(empty)

Test 8

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 2 743 890 592 942 736 969 616 50...` view save

correct output
`498 496` view save

user output
(empty)

Test 9

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 2 987 968 920 994 988 918 914 95...` view save

correct output
`500 500` view save

user output
(empty)

Test 10

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 2 996 1000 998 998 999 997 997 9...` view save

correct output
`500 500` view save

user output
(empty)

Test 11

Group: 3, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`1000 2 501 501 501 501 501 501 501 50...` view save

correct output
`1 168` view save

user output
(empty)

Test 12

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

input
`100 200 145 136 74 83 73 36 196 115 11...` view save

correct output
`194 190 189 183 182 181 181 17...` view save

user output
(empty)

Test 13

Group: 4, 5, 6

Verdict: RUNTIME ERROR

input
`100 200 157 110 168 155 192 107 146 15...` view save

correct output
`95 96 96 95 93 94 94 94 90 91 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 14

Group: 4, 5, 6

Verdict: RUNTIME ERROR

input
`50 200 137 118 160 118 146 160 140 18...` view save

correct output
`98 98 98 96 90 91 88 88 84 86 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 15

Group: 4, 5, 6

Verdict: RUNTIME ERROR

input
`100 200 147 174 186 148 155 128 158 18...` view save

correct output
`99 99 98 98 97 97 96 96 95 95 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 16

Group: 5, 6

Verdict: RUNTIME ERROR

input
`1000 2000 928772177 816188227 216592201 ...` view save

correct output
`991676844 990940224 990685481 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 17

Group: 5, 6

Verdict: RUNTIME ERROR

input
`1000 2000 665759876 597950008 615453266 ...` view save

correct output
`498801198 498681904 498504321 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 18

Group: 5, 6

Verdict: RUNTIME ERROR

input
`500 2000 683288817 784230412 626685186 ...` view save

correct output
`497667621 498434895 495465990 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 19

Group: 5, 6

Verdict: RUNTIME ERROR

input
`1000 2000 666667000 809309500 571572000 ...` view save

correct output
`499499500 499249250 498999000 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 20

Group: 6

Verdict: RUNTIME ERROR

input
`100000 200000 861772559 734298084 983382252 ...` view save

correct output
`499973914 499985299 499985141 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 21

Group: 6

Verdict: RUNTIME ERROR

input
`30000 200000 691834579 617419813 514778075 ...` view save

correct output
`499967533 499976270 499969810 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Test 22

Group: 6

Verdict: RUNTIME ERROR

input
`100000 200000 820255000 960780000 741965000 ...` view save

correct output
`499995000 499992500 499990000 ...` view save

user output
`para xd woah... helltale on top!!! urkkiz is the sole developer o...` view save

Datatähti 2025 alku

Tikut

Code

Test details

Test 1

Test 2

Test 3

Test 4

Test 5

Test 6

Test 7

Test 8

Test 9

Test 10

Test 11

Test 12

Test 13

Test 14

Test 15

Test 16

Test 17

Test 18

Test 19

Test 20

Test 21

Test 22

Tasks

Submissions (urkkiz)