Algorytm z iteracją

Mam napisać algorytm który wyznacza n-ty wyraz ciągu:
*Pierwszy i drugi wyraz ciągu są równe 1.
*Jeśli n>2 i n jest parzyste, to n-ty wyraz jest sumą trzech wyrazów go poprzedzających.
*Jeśli n>2 i n jest nieparzyste, to n-ty wyraz jest równy wyrazowi o numerze (n-1).
Wiem jak to zrobić rekurencją, ale muszę użyć iteracji.

unsigned int Algorytm(unsigned int n)
{
    unsigned int Al=1,Al_1=1,Al_2=1,i=2,pom=0,pom_1=0;
    if (n>2&&n%2==0)
    {
        while (i<n)
        {
            pom=Al;
            pom_1=Al_1;
            Al=Al+Al_1+Al_2;
            Al_1=pom;
            Al_2=pom_1;
            i++;
        }
    }
    if (n>2&&n%2!=0)
    {
        while (i<n-1)
        {
            pom=Al;
            Al=Al+Al_1;
            Al_1=pom;
            i++;
        }
    }
    return Al;
}

Coś takiego zrobiłem, ale jeśli n%2==0 to liczy mi tak, jakby wszystkie n były parzyste (?ciąg Tribonacciego?) i analogicznie n%2!=0 - wszystkie n nieparzyste.

Ten pierwszy jest dla mnie bardziej zrozumiały, aczkolwiek nie wiem czy dobrze rozumiem te działania na bitach. Czy (n^s)&1 można zapisać jako (n-s)%2!=0? Czy w warunku pętli while dekrementacja jest wykonywana nawet jeżeli warunek nie jest spełniony. Chyba jest bo dla n=3 odczytywało by A[4]. Czy jeśli przekroczymy rozmiar tablicy to liczy od początku? Wszystkie te pytania oparłem nie na wiedzy tylko na dedukcji jak powinno być, żeby działało.

Według moich obliczeń taki algorytm powinienem napisać w 15 minut. "Trochę" mi jeszcze brakuje. Mam takie pytanie, czy gdy ma się doświadczenie to gdy widzisz, jaki algorytm masz napisać to jest "A, to ten tylko go się trochę przerobi" czy piszesz od zera.

Ad.1. Nie. Ewentualnie (s%2!=n%2)
Ad.2. Tak
Ad.3. Nie liczy się od początku, a tu nie przekroczymy rozmiaru tablicy.
Ad.4. Widzisz jakiekolwiek podobieństwa ze swoim kodem?

Dlaczego to działa gdy przyrównujesz parzystość s i n zamiast po prostu sprawdzać parzystość n? Jestem ślepy albo głupi, sprawdziłem jeszcze 5 razy i tak nie przekroczy rozmiaru tablicy. Czy Ad.4. miała być odpowiedzią na drugi akapit? Podobieństwa są:

pom=Al;
pom_1=Al_1;
Al=Al+Al_1+Al_2;
Al_1=pom;
Al_2=pom_1;

A[0]=A[1];
A[1]=A[2];
A[2]=A[3];
A[3]+=A[1]+A[0];

Chodziło mi o to czy gdy masz napisać jakiś algorytm to ze startu wiesz jak będzie wyglądał czy wymyślasz go w trakcie pisania?

EDIT:
Żeby nie robić nowego tematu dopiszę tutaj.
Mam daną tablicę i rozmiar(n) tablicy. Elementy nie są równe, mają numery 1,2,...,n. Algorytm ma zwrócić i - numer elementu z największą wartością. Muszę użyć operację większe której podaję dwa numery elementów i zwraca true jeśli pierwszy jest większy.

#include <cstdlib>
#include <iostream>
using namespace std;
bool wieksze(int i,int j)
{
     if (tab[i]>tab[j]) return 1;
     if (tab[i]<tab[j]) return 0;
     }

int main(){
    int i=1,j=2,n=0;
    cin>>n;
    float tab[n];
    while (j<=n)
    {
         if(wieksze(i-1,j-1)) j++;
         else {i=j; j++;}
         }
    cout<<i<<endl;
	system("PAUSE");
	return EXIT_SUCCESS;
}

Dostaję error 'tab' undeclared. Co robię źle?