The Fibonacci sequence is defined using the following recursive formula:
F(0) = 0 F(1) = 1 F(M) = F(M - 1) + F(M - 2) if M >= 2A small frog wants to get to the other side of a river. The frog is initially located at one bank of the river (position −1) and wants to get to the other bank (position N). The frog can jump over any distance F(K), where F(K) is the K-th Fibonacci number. Luckily, there are many leaves on the river, and the frog can jump between the leaves, but only in the direction of the bank at position N.
The leaves on the river are represented in an array A consisting of N integers. Consecutive elements of array A represent consecutive positions from 0 to N − 1 on the river. Array A contains only 0s and/or 1s:
- 0 represents a position without a leaf;
- 1 represents a position containing a leaf.
The goal is to count the minimum number of jumps in which the frog can get to the other side of the river (from position −1 to position N). The frog can jump between positions −1 and N (the banks of the river) and every position containing a leaf.
For example, consider array A such that:
A[0] = 0 A[1] = 0 A[2] = 0 A[3] = 1 A[4] = 1 A[5] = 0 A[6] = 1 A[7] = 0 A[8] = 0 A[9] = 0 A[10] = 0The frog can make three jumps of length F(5) = 5, F(3) = 2 and F(5) = 5.
Write a function:
int solution(vector<int> &A);
that, given an array A consisting of N integers, returns the minimum number of jumps by which the frog can get to the other side of the river. If the frog cannot reach the other side of the river, the function should return −1.
For example, given:
A[0] = 0 A[1] = 0 A[2] = 0 A[3] = 1 A[4] = 1 A[5] = 0 A[6] = 1 A[7] = 0 A[8] = 0 A[9] = 0 A[10] = 0the function should return 3, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [0..100,000];
- each element of array A is an integer that can have one of the following values: 0, 1.
vector<long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
func.cpp: In function 'std::vector<long long int> getFibonacciArrayMax(size_t)': func.cpp:7:64: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++) func.cpp: In function 'int solution(std::vector<int>)': func.cpp:21:20: error: 'INT_MAX' was not declared in this scope const int oo = INT_MAX; ^~~~~~~ func.cpp:25:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (i<A.size() && A[i]) ~^~~~~~~~~ func.cpp:16:9: warning: unused variable 'min_jumps' [-Wunused-variable] int min_jumps = 0; ^~~~~~~~~ func.cpp:20:15: warning: unused variable 'fsize' [-Wunused-variable] const int fsize = f.size(); ^~~~~
vector<long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<unsilong long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
func.cpp: In function 'std::vector<long long unsigned int> getFibonacciArrayMax(size_t)': func.cpp:6:16: error: could not convert 'std::vector<long long int>(1ul, 0ll, std::allocator<long long int>())' from 'std::vector<long long int>' to 'std::vector<long long unsigned int>' return vector<long long>(1, 0); ^~~~~~~~~~~~~~~~~~~~~~~ func.cpp: In function 'int solution(std::vector<int>)': func.cpp:21:47: error: conversion from 'std::vector<long long unsigned int>' to non-scalar type 'std::vector<long long int>' requested vector<long long> f = getFibonacciArrayMax(N); ~~~~~~~~~~~~~~~~~~~~^~~ func.cpp:27:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (i<A.size() && A[i]) ~^~~~~~~~~ func.cpp:18:9: warning: unused variable 'min_jumps' [-Wunused-variable] int min_jumps = 0; ^~~~~~~~~ func.cpp:22:15: warning: unused variable 'fsize' [-Wunused-variable] const int fsize = f.size(); ^~~~~
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
func.cpp: In function 'std::vector<long long unsigned int> getFibonacciArrayMax(size_t)': func.cpp:6:16: error: could not convert 'std::vector<long long int>(1ul, 0ll, std::allocator<long long int>())' from 'std::vector<long long int>' to 'std::vector<long long unsigned int>' return vector<long long>(1, 0); ^~~~~~~~~~~~~~~~~~~~~~~ func.cpp: In function 'int solution(std::vector<int>)': func.cpp:35:28: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (pos + f[i] < N && A[pos + f[i]]) { ~~~~~~~~~~~^~~ func.cpp:18:9: warning: unused variable 'min_jumps' [-Wunused-variable] int min_jumps = 0; ^~~~~~~~~ func.cpp:22:15: warning: unused variable 'fsize' [-Wunused-variable] const int fsize = f.size(); ^~~~~
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsignedlong long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
func.cpp: In function 'int solution(std::vector<int>)': func.cpp:35:28: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (pos + f[i] < N && A[pos + f[i]]) { ~~~~~~~~~~~^~~ func.cpp:18:9: warning: unused variable 'min_jumps' [-Wunused-variable] int min_jumps = 0; ^~~~~~~~~ func.cpp:22:15: warning: unused variable 'fsize' [-Wunused-variable] const int fsize = f.size(); ^~~~~ main.o: In function `main': /tmp/exec.cpp:116: undefined reference to `solution(std::vector<int, std::allocator<int> >&)' collect2: error: ld returned 1 exit status
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
#pragma GCC diagnostic ignored "-Wsign-compare"
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
#pragma GCC diagnostic ignored "-Wsign-compare"
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
int min_jumps = 0;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
#pragma GCC diagnostic ignored "-Wsign-compare"
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int fsize = f.size();
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
#pragma GCC diagnostic ignored "-Wsign-compare"
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (si pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<int> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<unsigned long long> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<unsigned long long>(1, 0);
vector<unsigned long long> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<unsigned long long> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
func.cpp: In function 'int solution(std::vector<int>&)': func.cpp:19:20: error: 'INT_MAX' was not declared in this scope const int oo = INT_MAX; ^~~~~~~ func.cpp:26:30: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] for (size_t pos = 0; pos < N; pos++) { ~~~~^~~ func.cpp:31:28: warning: comparison between signed and unsigned integer expressions [-Wsign-compare] if (pos + f[i] < N && A[pos + f[i]]) { ~~~~~~~~~~~^~~
#include <climits>
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
Segmentation Fault
#include <climits>
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
Segmentation Fault
#include <climits>
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i > 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
#include <climits>
vector<uint64_t> getFibonacciArrayMax(size_t MaxNum) {
if (MaxNum == 0)
return vector<uint64_t>(1, 0);
vector<uint64_t> fib(2, 0);
fib[1] = 1;
for (size_t i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
size_t N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<uint64_t> f = getFibonacciArrayMax(N);
const int oo = INT_MAX;
vector<size_t> moves(N, oo);
for (auto i : f)
if (i<A.size() && A[i])
moves[i] = 1;
for (size_t pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (size_t i = f.size()-1; i > 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
[]
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int>& A) {
int N = A.size();
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
[]
[0]
[1]
function result: 1
function result: 1
function result: 1
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
[]
[0]
[1]
function result: 1
function result: 1
function result: 1
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
[]
[0]
[1]
function result: 1
function result: 1
function result: 1
vector<int> getFibonacciArrayMax(int MaxNum) {
if (MaxNum == 0)
return vector<int>(1, 0);
vector<int> fib(2, 0);
fib[1] = 1;
for (int i = 2; fib[fib.size()-1] + fib[fib.size() - 2] <= MaxNum; i++)
fib.push_back(fib[i - 1] + fib[i - 2]);
return fib;
}
int solution(vector<int> &A) {
int N = A.size();
if (N == 0)
return 1;
A.push_back(1);
N++;
vector<int> f = getFibonacciArrayMax(N);
const int oo = 1'000'000;
vector<int> moves(N, oo);
for (auto i : f)
if (i - 1 >= 0 && A[i-1])
moves[i-1] = 1;
for (int pos = 0; pos < N; pos++) {
if (A[pos] == 0)
continue;
for (int i = f.size()-1; i >= 0; i--) {
if (pos + f[i] < N && A[pos + f[i]]) {
moves[pos + f[i]] = min(moves[pos]+1, moves[pos + f[i]]);
}
}
}
if (moves[N - 1] != oo) {
return moves[N - 1];
}
return -1;
}
The solution obtained perfect score.