UVA-116 Undirectional TSP

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>

#define MAXR 10
#define MAXC 100

using namespace std;



int main()
{
    int m,n;//row column
    int array[MAXR][MAXC],mini[MAXR][MAXC],child[MAXR][MAXC];//entry,minimum sum, path



    while(cin>>m>>n){if(feof(stdin))break;

                                 int i,j;//iterator

                                 for(i=0;i<m;i++)
                                        for(j=0;j<n;j++)cin>>array[i][j];  //array entry


                                 for(i=0;i<m;i++){mini[i][n-1]=array[i][n-1];}
                                   
                                for(j=n-2;j>=0;j--)            //dp apply +child set
                                     for(i=0;i<m;i++)
                                                          {
                                                            mini[i][j]=mini[(m+i-1)%m][j+1];
                                                            child[i][j]=(m+i-1)%m;

                                                          if(mini[i][j]>mini[i][j+1]){mini[i][j]=mini[i][j+1];
                                                                                                child[i][j]=i;
                                                                                              }
                                                         else if(mini[i][j]==mini[i][j+1] && child[i][j]>i)child[i][j]=i;

                                                    if(mini[i][j]>mini[(m+i+1)%m][j+1])
                                                                    {mini[i][j]=mini[(m+i+1)%m][j+1];
                                                                     child[i][j]=(m+i+1)%m;
                                                                     }
                                                   else if(mini[i][j]==mini[(m+i+1)%m][j+1] && child[i][j]>(m+i+1)%m)
                                                                      child[i][j]=(m+i+1)%m;

                                                     mini[i][j]+=array[i][j];
                                                         }


                    int minimum=30000000,minirow;
                    for(i=0;i<m;i++)if(minimum>mini[i][0]){minimum=mini[i][0];
                                                                               minirow=i;
                                                                               }   //minimum sum and source find

                    vector<int>path;
                    bool blank =false;

                    for(j=0;j<n;j++){path.push_back(minirow+1);                 //path ready+print
                                              if(blank)cout<<" ";
                                               cout<<path[j];
                                              minirow=child[minirow][j];
                                              blank=true;
                                              }


                    cout<<endl;


                    cout<<minimum<<endl;
                    }
   return 0;
}

UVA-108 Maximum sum

#include<cstdio>
#include<iostream>
#include<queue>

#define INF 30000
#define MAX 100

using namespace std;

int main()
{  int array[MAX][MAX];
   int sum[MAX][MAX][MAX];
 while(1){ int N;
           cin>>N;
           if(feof(stdin))break;
         
           priority_queue<int>pq;
           int i,j,k;

           for(i=0;i<N;i++)
               for(j=0;j<N;j++){cin>>array[i][j];          //array input
                                         pq.push(array[i][j]);} //to handle the case of all negative entries

         
            for(i=0;i<N;i++)                         // taking input for column combination sums
               for(j=0;j<N;j++){sum[i][j][j]=array[i][j];
                                           for(k=j+1;k<N;k++)sum[i][j][k]=sum[i][j][k-1]+array[i][k];
                                         }
       
          int Sum,maxsum=-INF;
          for(j=0;j<N;j++)
              for(k=j;k<N;k++){Sum=0;
                                         for(i=0;i<N;i++){Sum+=sum[i][j][k];
                                                                    if(Sum<0){Sum=0;}
                                                                    else if(Sum>=maxsum){maxsum=Sum;}
                                                                  }
                                           }
       
          if(maxsum==-INF)maxsum=pq.top();
          cout<<maxsum<<endl;

  }
  return 0;
}

UVA-103 Stacking Boxes

#include<iostream>
#include<algorithm>
#include<cstdio>

using namespace std;

int totalbox,DIM;
int len[32],order[32],pred[32];
class box{
int dim[12];
public:
void input();             //taking input
void dimsort();        //dimension sorting
int operator<<(box BOX1);  //lexico sorting;
int operator>(box BOX1);    //lis compare
box operator^(box &BOX1);  //swap box's
};

void box::input()
{
    int i;
    for(i=1;i<=DIM;i++)cin>>dim[i];

    return;
}

void box::dimsort()
{ sort(dim+1,dim+1+DIM);
  return;
}

int box::operator<<(box BOX1)
{ int i;
  for(i=1;i<=DIM;i++){if(dim[i]<BOX1.dim[i])return 1;
                                    if(dim[i]>BOX1.dim[i])return 0;
                                  }
  return 0;
}

int box::operator>(box BOX1)
{ int i;
  for(i=1;i<=DIM;i++)if(dim[i]<=BOX1.dim[i])return 0;
  return 1;
 }

box box::operator^(box &BOX1)
{
    int i;
    for(i=1;i<=DIM;i++)swap(dim[i],BOX1.dim[i]);
    return *this;
}
void setvalue()
{
   int i;
   for(i=1;i<=totalbox;i++){order[i]=i;len[i]=1;
                         
                           }

   return;
}

 int main()
 {   int signal=0;
     while(cin>>totalbox>>DIM)
    {   if(signal)cout<<endl;
        box BOX[32];
        int i,j;
        setvalue();
        for(i=1;i<=totalbox;i++){BOX[i].input();
                                              BOX[i].dimsort();
                                             }

        for(i=1;i<totalbox;i++)
                    for(j=i+1;j<=totalbox;j++)
                                             if(BOX[j]<<BOX[i]){ BOX[j]^BOX[i];
                                                                                swap(order[j],order[i]);
                                                                               }
                             
                               
       
         for(i=1;i<totalbox;i++)
           for(j=i+1;j<=totalbox;j++){ if(BOX[j]>BOX[i] && len[i]+1>len[j]){len[j]=len[i]+1;
                                                                                                                    pred[j]=i;
                                                                                                                   }
                                                     }

            int max=0,maxel;;
            for(i=1;i<=totalbox;i++)if(max<len[i]){max=len[i];maxel=i;}
          int rev[32];
            rev[max]=order[maxel];
            for(i=max-1;i>0;i--){ rev[i]=order[pred[maxel]];
                                            maxel=pred[maxel];
                                            }
         
            cout<<max<<endl;
            cout<<rev[1];
            for(i=2;i<=max;i++)cout<<" "<<rev[i];
            cout<<endl;
            signal=1;

    }
    return 0;
    }