code:

#include <iostream>
#include <vector>
#include <fstream>
#include <algorithm>
#include <string>
#include <cmath>
using namespace std;
struct node{
      int tekrar;
      string harf;
      node *l;
      node *r;
      node (){
         l=r=NULL;
         harf="";
      }
   };
vector < node* > v,v2;
void sort1(){//sorting on tekrar :D
   for (size_t i=0 ;i < v.size()-1;++i)
      for (size_t j=i+1 ; j < v.size() ; ++j )
         if ( v[i]->tekrar > v[j]->tekrar )
            swap ( v[i] , v[j] );
}
void sort2(){// sorting on harf
   for (size_t i=0 ;i < v2.size()-1;++i)
      for (size_t j=i+1 ; j < v2.size() ; ++j )
         if ( v2[i]->harf[0] > v2[j]->harf[0] )
            swap ( v2[i] , v2[j] );
}
void peymayesh(node *p){
   static string s="";
   static int i=0;
   p->harf += s;
   if (p->l){
      s+="0";
      peymayesh(p->l);
   }
   if (p->r){
      s+="1";
      peymayesh(p->r);
   }
   if (! s.empty() )
      s.erase(s.begin() + s.size() -1);
   else
      i=0;//for next use !! means next test case
   if (p->harf[0]>=97)
      v2[i++]=p;
}

int main (){
   ifstream in("Huffman.in");
   int t,n;
   for (in >> t;t>0;--t){
      v.clear();// for input and create tree
      v2.clear();// for output and calculate compressing volume
      in >> n ;
      v.assign(n,0);
      v2.assign(n,0);
      for (int i=0; i<n ; ++i){
         v[i]=new node;
         v2[i]=new node;
         in >> v[i]->harf >> v[i]->tekrar ;
      }
      int bits1= ceil( log((double)n )/ log((double)2 ) );
      int sum1 = 0 ;//regular coding
      for (int i=0 ; i<n ; ++i)
         sum1 += bits1 * v[i]->tekrar;
      node *p;
      while ( v.size() > 1 ){
         sort1();
         p=new node;
         p->l = v[0];
         p->r = v[1];
         p->tekrar = v[0]->tekrar + v[1]->tekrar;
         v[0]=p;
         v.erase(v.begin() + 1);
      }
      peymayesh(v[0]);
      sort2();
      for(int i=0;i<v2.size();++i){
         cout << v2[i]->harf[0] << ":";
         v2[i]->harf.erase(v2[i]->harf.begin());
         cout << v2[i]->harf <<" ";
      }
      cout<< endl;
      int sum2=0;//Huffman coding
      for (int i=0;i<n;++i)
         sum2+= v2[i]->harf.size() * v2[i]->tekrar;
      cout << "regular coding: " << sum1
         << " ,with Huffman coding: " << sum2 << endl << endl;
   }
   return 0;
}

code:

2
6
a 30
b 10
c 7
d 8
e 40
f 14
6
a 2000
b 1000
c 500
d 500
e 2000
f 2100

code:

#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
vector <int > s;
int **L,n;
int travelling ( int i ){
   if (s.empty())
      return L[i][0];
   int result = 100000 , distiaj , tempj;
   for (int j=0;j<s.size();++j){
      tempj = s[j];
      s.erase(s.begin() + j);
      distiaj = L[i][tempj] + travelling (tempj);
      s.insert(s.begin() + j , tempj );
      if ( distiaj < result )
         result = distiaj;
   }
   return result;
}

int main(){
   ifstream in("forushande_dore_gard.in");
   in >> n;
   L=new int *[n];
   for (int i=0;i<n;++i){
      L[i]=new int [n];
      for (int j=0;j<n;++j)
         in >> L[i][j];
   }
   for (int i=1;i<n;++i)
      s.push_back(i);
   int minsum = travelling (0);
   cout << "value of min path is: " << minsum << endl;
   return 0;
}

code:

4
0 10 15 20
5 0 9 10
6 13 0 12
8 8 9 0

code:

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
using namespace std;
string zarb(string &a,string &b){
   reverse (a.begin(),a.end());
   reverse (b.begin(),b.end());
   string ans;
   ans.insert(0,1000,'0'); // inja mishe andazeye javab ro taghir dad
   int c=0;
   int i,j;
   for (i=0;i<a.size();++i){
      for (j=0;j<b.size();++j){
         if ( (ans[i+j]-48 + ((a[i]-48)*(b[j]-48)+c)%10) > 9 ){
            int carry=(ans[i+j]-48 + ((a[i]-48)*(b[j]-48)+c)%10) /10;
            ans[i+j] = (ans[i+j]-48 + ((a[i]-48)*(b[j]-48)+c)%10) %10 + 48;
            c=((a[i]-48)*(b[j]-48)+c)/10;
            int k=1;
            ans[i+j+k]+=carry;
            while ( ans[i+j+k]>'9' ){
               carry = (ans[i+j+k] - '0')/10;
               ans[i+j+k]= (ans[i+j+k]-48)%10 +'0';
               ++k;
               ans[i+j+k]+=carry;
            }
         }
         else{
            ans[i+j] += ((a[i]-48)*(b[j]-48)+c)%10;
            c = ((a[i]-48)*(b[j]-48)+c ) /10;
         }
      }
      ans[i+j]+=c;
      c=0;
   }
   for (int i=ans.size()-1;i>0;--i)
         if (ans[i]=='0')
             ans.erase (ans.end()-1);
         else
            break;
   reverse (ans.begin(),ans.end());
   return ans;
}
int main() {
    string s1,s2;
    cin >> s1 >> s2;
    cout << zarb(s1,s2) << endl;
    return 0;
}

code:

unsigned __int64 fact[19]={0};
__int64 factorial(__int64 a){
   if ( fact[a]!=0 )
      return fact [a];
   if (a==1){
      fact[a]=1;
      return 1;
   }
   fact[a] = a * factorial(a-1);
   return fact[a];
}

code:

unsigned __int64 tark[19][19]={{0,0}};
__int64 tarkib ( __int64 n , __int64 i){
   if ( tark[n][i]!= 0 )
      return tark [n][i];
   if ( n==i || i==0 ){
      tark[n][i]=1;
      return 1;
   }
   tark[n][i] = tarkib( n-1 , i ) + tarkib ( n-1 , i-1 );
   return tark[n][i];
}

code:

void tentotwo(int a){
   if (a/2==0){
      cout<<a; return;
   }
   int x=a%2; a/=2;
   tentotwo(a);
   cout<<x;
}

code:

struct point {
   double x,y;
   point(){}
   point (double a,double b){
      x=a,y=b;
   }
};

double ex_mult(point &a,point &b){
   return ((a.x*b.y)-(a.y*b.x));
}

for (int j=0;j<v[i].size();++j)
            sum += ex_mult( v[i] , v[(i+1)%v.size()] );
         cout << abs(sum)/2 << endl;

code:

bool cmd(complex<double> &p,complex<double> &q){
   if (p.real() != q.real())
      return p.real()<q.real();
   return p.imag()<q.imag();
}

code:

sort ( v.begin() , v.end() ,cmd );
      vector < complex<double> > ans;
      //complex <double > cur_p,first = v[0];
      ans.push_back(v[0]);
      double ang,temp_ang,rotate=0;
      int min_point=n-1,cnt_choice=0;
      while (min_point!=0){
         ang=1.0e+8;
         for (int i=0;i<n;++i){//temp_ang == #INF ?
            temp_ang=atan2( v[i].imag() - ans[cnt_choice].imag() , v[i].real() - ans[cnt_choice].real() );
            if (temp_ang==0)
               continue;
            temp_ang-=rotate;
            while (temp_ang < -PI/2 )
               temp_ang+=2*PI;
            if (temp_ang < ang ){
               min_point = i;
               ang=temp_ang;
            }
         }
         ans.push_back (v[min_point]);
         ++cnt_choice;
         rotate += PI/2 + ang ;//important !
         if (rotate >= 2*PI )
            rotate -= 2*PI;
      }

code:

/**
 *   //////////////////
 *   // MAXIMUM FLOW //
 *   //////////////////
 *
 * This file is part of my library of algorithms found here:
 *      http://www.palmcommander.com:8081/tools/
 * LICENSE:
 *      http://www.palmcommander.com:8081/tools/LICENSE.html
 * Copyright (c) 2004
 * Contact author:
 *      igor at cs.ubc.ca
 **/

/****************
 * Maximum flow * (Ford-Fulkerson on an adjacency matrix)
 ****************
 * Takes a weighted directed graph of edge capacities as an adjacency
 * matrix 'cap' and returns the maximum flow from s to t.
 *
 * PARAMETERS:
 *      - cap (global): adjacency matrix where cap[u][v] is the capacity
 *          of the edge u->v. cap[u][v] is 0 for non-existent edges.
 *      - n: the number of vertices ([0, n-1] are considered as vertices).
 *      - s: source vertex.
 *      - t: sink.
 * RETURNS:
 *      - the flow
 *      - fnet contains the flow network. Careful: both fnet[u][v] and
 *          fnet[v][u] could be positive. Take the difference.
 *      - prev contains the minimum cut. If prev[v] == -1, then v is not
 *          reachable from s; otherwise, it is reachable.
 * DETAILS:
 * FIELD TESTING:
 *      - Valladolid 10330: Power Transmission
 *      - Valladolid 653:   Crimewave
 *      - Valladolid 753:   A Plug for UNIX
 *      - Valladolid 10511: Councilling
 *      - Valladolid 820:   Internet Bandwidth
 *      - Valladolid 10779: Collector's Problem
 * #include <string.h>
 * #include <queue>
 **/

#include <string.h>

// the maximum number of vertices
#define NN 1024

// adjacency matrix (fill this up)
int cap[NN][NN];

// flow network
int fnet[NN][NN];

// BFS
int q[NN], qf, qb, prev[NN];

int fordFulkerson( int n, int s, int t )
{
    // init the flow network
    memset( fnet, 0, sizeof( fnet ) );

    int flow = 0;

    while( true )
    {
        // find an augmenting path
        memset( prev, -1, sizeof( prev ) );
        qf = qb = 0;
        prev[q[qb++] = s] = -2;
        while( qb > qf && prev[t] == -1 )
            for( int u = q[qf++], v = 0; v < n; v++ )
                if( prev[v] == -1 && fnet[u][v] - fnet[v][u] < cap[u][v] )
                    prev[q[qb++] = v] = u;

        // see if we're done
        if( prev[t] == -1 ) break;

        // get the bottleneck capacity
        int bot = 0x7FFFFFFF;
        for( int v = t, u = prev[v]; u >= 0; v = u, u = prev[v] )
            bot <?= cap[u][v] - fnet[u][v] + fnet[v][u];

        // update the flow network
        for( int v = t, u = prev[v]; u >= 0; v = u, u = prev[v] )
            fnet[u][v] += bot;

        flow += bot;
    }

    return flow;
}

//----------------- EXAMPLE USAGE -----------------
int main()
{
    memset( cap, 0, sizeof( cap ) );
    int numVertices = 100;
   
    // ... fill up cap with existing edges.
    // if the edge u->v has capacity 6, set cap[u][v] = 6.       
   
    cout << fordFulkerson( numVertices, s, t ) << endl;
   
    return 0;
}

code:

unsigned __int64 gcd(unsigned __int64 a,unsigned __int64 b) {
   if (a%b==0) return b; else return gcd(b,a%b);
}
void Divbygcd(unsigned __int64& a,unsigned __int64& b) {
   unsigned __int64 g=gcd(a,b);
   a/=g;
   b/=g;
}
unsigned __int64 C(int n,unsigned int k){
   unsigned __int64 numerator=1,denominator=1,toMul,toDiv,i;
   if (k>n/2) k=n-k; /* use smaller k */
   for (i=k;i;i--) {
      toMul=n-k+i;
      toDiv=i;
      Divbygcd(toMul,toDiv); /* always divide before multiply */
      Divbygcd(numerator,toDiv);
      Divbygcd(toMul,denominator);
      numerator*=toMul;
      denominator*=toDiv;
   }
   return numerator/denominator;
}

code:

int Fib(int n)
{
    int i,h,j,k,t;
    i = h = 1;
    j = k = 0;
    while (n > 0)
    {
        if (n%2 == 1)
        {
            t = j*h;
            j = i*h + j*k + t;
            i = i*k + t;
        }
        t = h*h;
        h = 2*k*h + t;
        k = k*k + t;
        n = n/2;
    }
return j;
}