code:

#include <iostream>
#include <fstream>
#include"stdio.h"
using namespace std;
int main()
{
   struct
   {
      int x1,x2,y1,y2;
   }y[100],x[100],temp;
   int ix=0,jy=0,i,j,tx1,tx2,ty1,ty2,m,s,k,l,cnt;
   FILE *in=fopen("d.in","r");
   fscanf(in,"%d",&m);
   for(;m;--m)
   {
      cnt=0;
      ix=jy=0;
      fscanf(in,"%d",&s);
      for(;s;--s)
      {
         fscanf(in,"%d %d %d %d",&tx1,&ty1,&tx2,&ty2);
         if(tx1==tx2)
         {
            if(ty1>ty2)
            {
               l=ty1;
               ty1=ty2;
               ty2=l;
            }
            y[jy].y1=ty1;y[jy].y2=ty2;
            y[jy].x1=tx2;y[jy].x2=tx2;
            jy++;
         }
         else
         {
            if(tx1>tx2)
            {
               l=tx1;
               tx1=tx2;
               tx2=l;
            }
            x[ix].x1=tx1;x[ix].x2=tx2;
            x[ix].y1=ty1;x[ix].y2=ty2;
            ix++;
         }
      }
      for(i=0;i<ix;i++)
         for(j=0;j<ix;j++)
            if(x[i].y1<x[j].y1)
            {   
               temp=x[i];
               x[i]=x[j];
               x[j]=temp;
            }
      for(i=0;i<jy;i++)
         for(j=0;j<jy;j++)
            if(y[i].x1<y[j].x1)
            {
               temp=y[i];
               y[i]=y[j];
               y[j]=temp;
            }
      for(i=0;i<jy;i++)
         for(j=0;j<ix;j++)
            if(y[i].x1>=x[j].x1&&y[i].x1<=x[j].x2&&y[i].y1<=x[j].y1&&y[i].y2>=x[j].y1)
               for(k=j+1;k<ix;k++)
                  if(y[i].x1>=x[k].x1&&y[i].x1<=x[k].x2&&y[i].y1<=x[k].y1&&y[i].y2>=x[k].y1)
                     for(l=i+1;l<jy;l++)
                        if(y[l].x1>=x[j].x1&&y[l].x1<=x[j].x2&&y[l].y1<=x[j].y1&&y[l].y2>=x[j].y1&&y[l].x1>=x[k].x1&&y[l].x1<=x[k].x2&&y[l].y1<=x[k].y1&&y[l].y2>=x[k].y1)
                           cnt++;
   cout<<cnt<<"\n";
   }

}

code:

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <list>
const int _invalid=1000000000;
using namespace std;
struct now{
   int a,b,c,sum;
   now(int aa,int bb, int cc,int ss){
      a=aa;
      b=bb;
      c=cc;
      sum=ss;
   }
   bool operator == (now & p) const {
      return (a==p.a && b==p.b && c==p.c /*&& sum==p.sum*/ );
   }
};
vector<vector<now> > paths;
vector <vector <int> > cost;
void sorting (now & p){
   if (p.a<p.b)
      swap (p.a,p.b);
   if (p.a<p.c)
      swap(p.a,p.c);
   if (p.b<p.c)
      swap(p.b,p.c);
}
bool cmd (now &p,now &q) {
   if (p.a!=q.a)
      return p.a<q.a;
   else if (p.b!=q.b)
      return p.b<q.b;
   else if (p.c!=q.c)
      return p.c<q.c;
   else
      return p.sum < q.sum;
}
int main(){
   ifstream in("sharif_99_F.in");
   int t,n;
   for (in >> t;t>0;--t){
      in>>n;
      cost.assign ( n ,vector <int> (n));
      for (int i=0;i<n-1;++i)
         for(int j=i+1;j<n;++j)
            in >> cost[i][j];

      paths.assign(n ,vector<now>());
      now home(0,0,0,0);
      paths[0].push_back(home);
      for (int i=1;i<n;++i){
         for (size_t j=0;j<paths[i-1].size();++j){
            int a,b,c,each_cost;
            for (int l=0;l<3;++l){
               switch (l) {
                  case 0:a=i,b=paths[i-1][j].b,c=paths[i-1][j].c;
                     each_cost=cost[paths[i-1][j].a][i];
                     break;
                  case 1:b=i,a=paths[i-1][j].a,c=paths[i-1][j].c;
                     each_cost=cost[paths[i-1][j].b][i];
                     break;
                  case 2:c=i,b=paths[i-1][j].b,a=paths[i-1][j].a;
                     each_cost=cost[paths[i-1][j].c][i];
                     break;
               }
               now point(a,b,c,paths[i-1][j].sum + each_cost);
               sorting(point);
               paths[i].push_back(point);
            }
            sort (paths[i].begin(),paths[i].end(),cmd);
            for (size_t r=0;r<paths[i].size()-1;++r)
               if (paths[i][r]==paths[i][r+1])
                  paths[i].erase(paths[i].begin()+r+1);
               //for (size_t j=r+1 ;j<paths[i].size();++j)
               //   if ( paths[i][r]==paths[i][j] ){
               //      int p=paths[i][r].sum > paths[i][j].sum ? r : j;
               //      paths[i].erase(paths[i].begin()+p);
               //      //--r;
               //      break;
               //   }

         }
      }
      int minimum=_invalid;
      for (size_t i=0;i<paths[n-1].size();++i)
         minimum = min (paths[n-1][i].sum , minimum);
      cout << minimum << endl;
         
   }
   return 0;
}

code:

int toloo(node *p){
   int temp1=0,temp2=0;
   if (p->down)
      temp1=toloo(p->down);
   if (p->right)
      temp2=toloo(p->right);
   return max(p->num_childs+1,max(temp1,temp2));
}

code:

#include <iostream>
#include <cmath>
#include <fstream>
#include <map>
#include <vector>

using namespace std;

ifstream fin ("e.in");
vector <vector<int> > v;

void readCase()
{
   v.clear();

   int N;
   fin >> N;
   v.resize(N + 1);
   while (N--)
   {
      int label, r;
      fin >> label >> r;
      v[label].resize(r);
      for (int i = 0 ; i <r>> v[label][i];
   }
}

int calculateNeededStones (int parent)
{
   int temp1 = 0,   //maximum stones needed for childs
      temp1Cnt=0 ,//number of childs which need maximum stones
      temp2;      //number of children
   for (int i = 0; i < v[parent].size(); i++)
      temp1 = max(temp1, calculateNeededStones(v[parent][i]));

   for (int i = 0; i <v>> T;
   while (T--)
   {
      readCase();   //read the input for one test case in a 2d vector
      cout << calculateNeededStones(1) << endl;
   }
   return 0;
}

code:

4
5
4
7
4
50
28
10
3

code:

#include <algorithm>
#include <iostream>
#include <cmath>
#include <fstream>
#include <map>
#include <vector>

using namespace std;

ifstream fin ("e.in");
vector <vector<int> > v;

void readCase()
{
   v.clear();

   int N;
   fin >> N;
   v.resize(N + 1);
   while (N--)
   {
      int label, r;
      fin >> label >> r;
      v[label].resize(r);
      for (int i = 0 ; i < r ; i++)
         fin >> v[label][i];
   }
}

int calculateNeededStones (int parent)
{
   if (v[parent].size() == 0) return 1;

   vector <int> stones;

   for (int i = 0; i < v[parent].size(); i++)
      stones.push_back(calculateNeededStones(v[parent][i]));
   sort (stones.begin(), stones.end(), greater<int>());
   
   int pickedStones = stones[0];
   int res = pickedStones;
   for (vector <int>::iterator it = stones.begin(); it != stones.end(); it++)
   {
      if (pickedStones < *it)
      {
         res+= *it- pickedStones;
         pickedStones+= *it - pickedStones;
      }
      pickedStones--;
   }

   return res;
}

int main()
{
   int T;
   fin >> T;
   while (T--)
   {
      readCase();   //read the input for one test case in a 2d vector
      cout << calculateNeededStones(1) << endl;
   }
   return 0;
}