Speeding up the generation of the sequence using my code

Question

Possible Duplicate:
I want to generate the nth term of the sequence 1,3,8,22,60 ,164 in Order(1) or order of (nlogn)

I am trying to generate a sequence 1,3,8,22,60... which is basically a[n]=2*(a[n-1]+a[n-2]); Please refer to my question here I want to generate the nth term of the sequence 1,3,8,22,60 ,164 in Order(1) or order of (nlogn)

Here is my implementation of it in c++.But I think it is too slow.The code runs in around 5 seconds for the worst case whereas I want it to run it in less than 1 second. The method is order of log n. So 10^9 takes only 29 steps. Here is my code.Please suggest ways to speed it up or any mistake I am doing

#include <iostream>
#define big long long unsigned int
#include<vector>
#include<stdio.h>
#define _SECURE_SCL 0
big m =1000000007;
using namespace std;
vector <vector <big> > vectin(vector<vector <big> > a)
{
    for(int i=0;i<2;i++)
    {
        vector <big> t;
        for(int j=0;j<2;j++)
        {
            t.push_back(0);
        }
        a.push_back(t);
    }
    return a;
}
vector <vector <big> > unit(vector<vector <big> > a)
{
    for(int i=0;i<2;i++)
    {
        vector <big> t;
        for(int j=0;j<2;j++)
        {   if(i!=j)
            t.push_back(0);
            else
            t.push_back(1);
        }
        a.push_back(t);
    }
    return a;
}
vector<vector <big> > multi(vector<vector <big> > a,vector<vector <big> >b )
{
    vector<vector <big> > c;
    c=vectin(c);
    for(big i=0;i<2;i++){

    for(big j=0;j<2;j++)
    {
        for(big k=0;k<2;k++)
            {
                c[i][j]+=((a[i][k])*(b[k][j]))%m;
            }
    }
}
return c;
}

big modexp_rl(big a,big b, big n)
{
    big r = 1;
    while (1){
        if (b&1)
            r = ((r )*(a) ) % n;
        b /= 2;
        if (!b )
            break;
        a = ((a )* (a) )% n;
    }
    return r;
}

vector <vector <big> > modexs (big b,vector <vector <big> > a )
{
    vector < vector <big > > r;
    r=unit(r);
    while(1)
    {  // cout<<b<<endl;
        if(b&1)
        r=multi(r,a);
        b/=2;

        if(!b)
        break;
        a=multi(a,a);
    }
    return r;
}

void displayvector(vector < vector <big> > s)
{
    for(big i=0;i<2;i++)
    {
        for(big j=0;j<2;j++)
        {
            cout<<s[i][j]<<"\t";
        }
    cout<<endl;
    }

}

vector <big> mul2( vector < vector <big> > a)
{
    vector <big> d;
    d.push_back(3*a[0][0]+1*a[0][1]);
    d.push_back(3*a[1][0]+1*a[1][1]);
return d;
}
int main()
{

  vector < vector <big> > a;
  vector <big> t1,t2;
  t1.push_back(2);
  t1.push_back(2);
  a.push_back(t1);
  t2.push_back(1);
  t2.push_back(0);
  a.push_back(t2);
  //dv(a);
  vector < vector <big> > ans;
  big t,n;
  //cin>>t;
  //scanf("%lld,&t);
  t=10000;
  while(t--){
  //cin>>n;
  //scanf("%lld",&n);
  n=1000000000;
  ans=modexs(n-1,a);
  vector <big> p;
  p=mul2(ans);
  //cout<<p[1]<<endl;
  printf("%lld\n",p[1]);
  //dv(ans);
  }
    return 0;
}

I think it's `1 1 3 8 22 60`, and `a[n] = 2*(a[n-1] + a[n-2])`. — Kerrek SB, Jul 04 '12 at 07:43
Sir Frunze ,the purpose of the questions are different.The first question ask for approaches and this question seeks some optimization techniques. — Ajax Aristodemos, Jul 04 '12 at 08:00
@Kerrek SB the first time is 1 ,the second term 3 and the next term 8. — Ajax Aristodemos, Jul 04 '12 at 08:01
@hamed ,does it matter if its indices are big or int.any ways I tried it ,it didnt make any noticeable running time difference. — Ajax Aristodemos, Jul 04 '12 at 08:07

jxh · Answer 1 · 2012-07-04T08:00:10.247

3

If you know how many elements are going into your a vector, you should reserve space for that many before you run your algorithm. This is to avoid data copying when the vectors do dynamic resizing.

edited Jul 04 '12 at 08:00

answered Jul 04 '12 at 07:51

jxh

69,070
8
110
193

2

Or you can use deque instead of vector! – hamed Jul 04 '12 at 08:24
2

@hamed: True, it would be more efficient than dynamically resizing a vector. – jxh Jul 04 '12 at 08:31
I have tried deque no such improvement – Ajax Aristodemos Jul 04 '12 at 10:13

score 1 · Answer 2 · answered Jul 04 '12 at 19:26

I plugged the generating function of the series into Wolfram Alpha, and it appears that the n^th term is:

[ (1 + Q)^(1+n) - (1 - Q)^(1+n) ] / (4Q) ,

where Q = sqrt(3).

You may observe that 1 - Q is smaller than unity in absolute value, and so the entire term is exponentially small for large n. That means that for large n you can just compute the first term and take the next biggest integer.

SƲmmēr Aƥ · Accepted Answer · 2012-07-05T00:52:57.470

0

If there is no way to enhance the function, you can try to research multi-core programming and learn how to implement it. Take this as a reference. It will increase performance of processing. However, it will consume resources. Hope this helps.

edited Jul 05 '12 at 00:52

answered Jul 04 '12 at 07:37

SƲmmēr Aƥ

2,374
6
24
29

Speeding up the generation of the sequence using my code

3 Answers3