zhouyouisme
BAN USER//suppose treenode data is normal integer
bool JudgeBST(TreeNode *pTreeNode)
{
if(!pTreeNode) return true;
if(pTreeNode->leftchild && pTreeNode->rightchild){
return (pTreeNode->leftchild->data < pTreeNode->rightchild->data) &&
JudgeBST(pTreeNode->leftchild) && JudgeBST(pTreeNode->rightchild);
}else if(pTreeNode->leftchild){
return JudgeBST(pTreeNode->leftchild);
}else if(){
return JudgeBST(pTreeNode->rightchild);
}
return true;
}
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
void BuildMatrix(int *** pmaze,unsigned row_num,unsigned column_num)
{
*pmaze = new int*[row_num];
for(unsigned i=0;i<row_num;++i){
(*pmaze)[i] = new int[column_num];
}
}
void ReleaseMatrix(int ***pmaze,unsigned row_num)
{
if(!pmaze) return;
for(unsigned i=0;i<row_num;++i){
delete [](*pmaze)[i];
}
delete [](*pmaze);
}
void CoreSolve(int ***ppDistanceMatrix,unsigned matrix_size)
{
for(int i=0;i<matrix_size;++i){
for(int j=i;j<matrix_size;++j){
if(i-1>=0&&j-1>=0){
(*ppDistanceMatrix)[i][j] += max((*ppDistanceMatrix)[i-1][j],(*ppDistanceMatrix)[i][j-1]);
}else if(i-1>=0){
(*ppDistanceMatrix)[i][j] += (*ppDistanceMatrix)[i-1][j];
}else if(j-1>=0){
(*ppDistanceMatrix)[i][j] += (*ppDistanceMatrix)[i][j-1];
}
}
for(int k=i+1;k<matrix_size;++k){
if(k-1>=0&&i-1>=0){
(*ppDistanceMatrix)[k][i] += max((*ppDistanceMatrix)[k-1][i],(*ppDistanceMatrix)[k][i-1]);
}else if(k-1>=0){
(*ppDistanceMatrix)[k][i] += (*ppDistanceMatrix)[k-1][i];
}else if(i-1>=0){
(*ppDistanceMatrix)[k][i] += (*ppDistanceMatrix)[k][i-1];
}
}
}
}
void Solve()
{
unsigned matrix_size = 0;
int **ppmatrix = NULL;
cin>>matrix_size;
BuildMatrix(&ppmatrix,matrix_size,matrix_size);
for(unsigned i=0;i<matrix_size;++i){
for(unsigned j=0;j<matrix_size;++j){
cin>>ppmatrix[i][j];
}
}
int **ppDistanceMatrix = NULL;
BuildMatrix(&ppDistanceMatrix,matrix_size,matrix_size);
for(unsigned i=0;i<matrix_size;++i){
for(unsigned j=0;j<matrix_size;++j){
ppDistanceMatrix[i][j]=ppmatrix[i][j];
}
}
CoreSolve(&ppDistanceMatrix,matrix_size);
cout<<ppDistanceMatrix[matrix_size-1][matrix_size-1];
ReleaseMatrix(&ppmatrix,matrix_size);
ReleaseMatrix(&ppDistanceMatrix,matrix_size);
}
int main()
{
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
unsigned case_num = 0;
cin>>case_num;
for(unsigned i=1;i<=case_num;++i){
cout<<"Case #"<<i<<": ";
Solve();
cout<<endl;
}
return 0;
}
string GetCommonElements(char* array1,char* array2,unsigned length1,unsigned length2)
{
if(!array1 || !array2 || length1<=0 || length2<=0){
return "";
}
char v_char[256];
for(int i=0;i<256;++i){
v_char[i]=0;
}
for(int i=0;i<length1;++i){
v_char[array1[i]]++;
}
string str_ret;
for(int i=0;i<length2;++i){
if(v_char[array2[i]]!=0){
str_ret.push_back(array2[i]);
}
}
return str_ret;
}
Repmariawharris2, Computer Scientist at Adjetter Media Network Pvt Ltd.
Hi I am an IT Project Management Professional with 2 years' experience,Handled project development and documentation of copier rentals ...
/*************************************************
- zhouyouisme September 09, 2014Author:Zhou You
Time:2014.09.09
*************************************************/
#include <iostream>
#include <cstdio>
using namespace std;
struct matrix_element
{
public:
matrix_element():
star_num_(0),
hash_num_(0){}
matrix_element(unsigned star_num,unsigned hash_num):
star_num_(star_num),
hash_num_(hash_num){
}
unsigned star_num_;
unsigned hash_num_;
};
void BuildMatrix(matrix_element *** pmaze,unsigned row_num,unsigned column_num)
{
*pmaze = new matrix_element*[row_num];
for(unsigned i=0;i<row_num;++i){
(*pmaze)[i] = new matrix_element[column_num];
}
}
void ReleaseMatrix(matrix_element ***pmaze,unsigned row_num)
{
if(!pmaze) return;
for(unsigned i=0;i<row_num;++i){
delete [](*pmaze)[i];
}
delete [](*pmaze);
}
void CoreSolve(char **parray,unsigned element_num)
{
matrix_element **pnote = NULL;
BuildMatrix(&pnote,element_num,element_num);
for(unsigned i=0;i<element_num;++i){
if((*parray)[i]=='*'){
++pnote[i][i].star_num_;
}else if((*parray)[i]=='#'){
++pnote[i][i].hash_num_;
}
}
int index_start = -1,index_end = -1;
unsigned cur_length = 0;
for(unsigned sub_array_length = 2;sub_array_length<=element_num;++sub_array_length){
for(unsigned i=0;i<=element_num-sub_array_length;++i){
pnote[i][i+sub_array_length-1].hash_num_ =
pnote[i][i+sub_array_length-2].hash_num_+
pnote[i+sub_array_length-1][i+sub_array_length-1].hash_num_;
pnote[i][i+sub_array_length-1].star_num_ =
pnote[i][i+sub_array_length-2].star_num_+
pnote[i+sub_array_length-1][i+sub_array_length-1].star_num_;
if(pnote[i][i+sub_array_length-1].star_num_==
pnote[i][i+sub_array_length-1].hash_num_){
if(sub_array_length>cur_length){
cur_length = sub_array_length;
index_start = i;
index_end = i+sub_array_length-1;
}
}
}
}
cout<<index_start<<" "<<index_end;
ReleaseMatrix(&pnote,element_num);
}
void Solve()
{
unsigned element_num = 0;
cin>>element_num;
char *parray = new char[element_num];
for(unsigned i=0;i<element_num;++i){
cin>>parray[i];
}
CoreSolve(&parray,element_num);
delete []parray;
}
int main()
{
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
unsigned case_num = 0;
cin>>case_num;
for(unsigned i=1;i<=case_num;++i){
cout<<"Case #"<<i<<" ";
Solve();
cout<<endl;
}
return 0;
}