Scorpion and frogs

input/code.cpp: In function 'uint64_t jump(uint64_t, uint64_t, std::vector<long unsigned int>&)':
input/code.cpp:42:19: warning: comparison of integer expressions of different signedness: 'int' and 'uint64_t' {aka 'long unsigned int'} [-Wsign-compare]
   42 |     for (int i=k;i<n+2;i++) {
      |                  ~^~~~

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <vector>
/*
sort(apples)
weightA=0
weightB=0
for (apples from last to first)
if (weightB=>weightA) {

    weightA+=appleweight
} else weightB+=appleweight;

return abs(weightA-weightB)
*/

/*Total weight of apples do not fit in 32bit integers in tests I failed
 * during the competition.
 */
//*
/*
def jump(k,n):
    if k >= n+1:
        return 1
    res = 0
    for i in range(k,n+2):
        res += jump(i+2,n)
    return res

n = int(input())

print(jump(1,n)%998244353)
*/
//*

uint64_t jump(uint64_t k,uint64_t n,std::vector<uint64_t> &memo) {
    if (k>=n+1) {
        return 1;
    }
    uint64_t res=0;
    for (int i=k;i<n+2;i++) {
        if (!memo[i+2]) memo[i+2]=jump(i+2,n,memo);
        res+=memo[i+2];
        if (res>998244453) {
            res=res%998244353;
        }
    }
    return res;
}

int main() {
    uint32_t frogs=0;

    std::cin>>frogs;
    std::vector<uint64_t> memo;
    std::vector<uint64_t> memoSum;



        uint64_t j=1;
        memo.assign(frogs+10,0);
        memoSum.assign(frogs+10,0);
        memo[0]=1;
        memo[1]=2;
        memoSum[0]=0;
        for (uint64_t i=2;i<=frogs;i++) {
            memo[i]=(memo[i-2]+memoSum[i-2]+2)%998244353;
            memoSum[i-1]=(memoSum[i-2]+memo[i-2])%998244353;
        }
        j=memo[frogs];
        std::cout<<j<<std::endl;
    }


/*
int main() {
    using std::cin;
    using std::vector;
    int n;
    cin>>n;
    vector<int64_t> apples;
    for (int i=0;i<n;i++) {
        int j;
        cin>>j;
        apples.emplace_back(j);
    }
    int64_t minimum=2147483647;
    int count=0;
    //std::sort(apples.begin(),apples.end());
    for (int i=0;i<=(1<<n)+1;i++) {
       int64_t  weightA=0,weightB=0;
        count++;
        for (int j=0;j<n;j++) {
            if (i&(1<<j)) {
                weightA+=apples[j];
            } else {
                weightB+=apples[j];
            }
        }
        if (weightA>=weightB) {
            minimum=std::min(minimum,weightA-weightB);
        } else {
            minimum=std::min(minimum,weightB-weightA);
        }

    }

    std::cout<<minimum<<std::endl;
}
*/

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: ACCEPTED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: ACCEPTED

Test 21

Verdict: ACCEPTED

Test 22

Verdict: ACCEPTED

Test 23

Verdict: ACCEPTED

Test 24

Verdict: ACCEPTED

Test 25

Verdict: ACCEPTED

Test 26

Verdict: ACCEPTED

Test 27

Verdict: ACCEPTED

Test 28

Verdict: ACCEPTED

Test 29

Verdict: ACCEPTED

Test 30

Verdict: ACCEPTED

Test 31

Verdict: ACCEPTED

Test 32

Verdict: ACCEPTED

Test 33

Verdict: ACCEPTED

Test 34

Verdict: ACCEPTED

Test 35

Verdict: ACCEPTED

Test 36

Verdict: ACCEPTED

Test 37

Verdict: ACCEPTED

Test 38

Verdict: ACCEPTED

Test 39

Verdict: ACCEPTED

Test 40

Verdict: ACCEPTED

Test 41

Verdict: ACCEPTED

Test 42

Verdict: ACCEPTED

Test 43

Verdict: ACCEPTED

Test 44

Verdict: ACCEPTED

Test 45

Verdict: ACCEPTED

Test 46

Verdict: ACCEPTED

Test 47

Verdict: ACCEPTED

Test 48

Verdict: ACCEPTED

Test 49

Verdict: ACCEPTED

Test 50

Verdict: ACCEPTED

Test 51

Verdict: ACCEPTED

Test 52

Verdict: ACCEPTED

Test 53

Verdict: ACCEPTED

Test 54

Verdict: ACCEPTED

Test 55

Verdict: ACCEPTED