#include <iostream>
#include <math.h>
#include <stdio.h>
#include <vector>
#include <map>
#include <deque>
#include <assert.h>
#include <cstring>
using namespace std;
struct TreeNode
{
int val;
TreeNode *left,*right;
TreeNode(int x):val(x),left(NULL),right(NULL){}
};
class Solution1
{
public:
/***************************************************
* 函数功能:规定路径必须从上往下,求二叉树上累加和为sum的最长路径长度
* 参数说明
* 输入参数:
* 输出参数:
* 复杂性分析:时间复杂度:O(2^n),空间复杂度:O(1)
* 题目来源 :
* 日期:2018-07-27-16.10
***************************************************/
int getMaxLength(TreeNode* head,int sum)
{
if(head==NULL) return 0;
map<int,int> M;
M[0]=-1;//very importance!!
return getMaxLength(head,sum,0,0,0,M);
}
private:
int getMaxLength(TreeNode* head,int sum,int preSum,int lavel,int max_len,map<int,int>& M)
{
if(head==NULL)
{
return max_len;
}
int curSum=preSum+head->val;
if(M.find(curSum-sum)!=M.end())
{
max_len=max(lavel-M[curSum-sum],max_len);
}
if(M.find(curSum)==M.end())
{
M[curSum]=lavel;
}
max_len=getMaxLength(head->left,sum,curSum,lavel+1,max_len,M);
max_len=getMaxLength(head->right,sum,curSum,lavel+1,max_len,M);
if(lavel==M[curSum])
{
M.erase(curSum);
}
return max_len;
}
};
//int main()
//{
// Solution1 s;
//
// TreeNode a1(-3);
// TreeNode b1(3);
// TreeNode b2(-9);
// TreeNode c1(1);
// TreeNode c2(0);
// TreeNode c3(2);
// TreeNode c4(1);
// TreeNode d1(1);
// TreeNode d2(6);
// a1.left=&b1;
// a1.right=&b2;
// b1.left=&c1;
// b1.right=&c2;
// b2.left=&c3;
// b2.right=&c4;
// c2.left=&d1;
// c2.right=&d2;
//
// cout<<s.getMaxLength(&a1,6)<<endl;//4
// cout<<s.getMaxLength(&a1,-9)<<endl;//1
// return 0;
//}
class Solution2
{
public:
/***************************************************
* 函数功能:给定一个数组和目标和,求累加和为target的最长子数组长度。
* 参数说明
* 输入参数:
* 输出参数:
* 复杂性分析:时间复杂度:O(n),空间复杂度:O(n)
* 题目来源 :
* 日期:2018-07-27-16.32
***************************************************/
int maxLength(vector<int>& arr,int k)
{
if(arr.size()<1) return 0;
map<int,int> M;
M[0]=-1;
return maxLength(arr,k,M,0);
}
private:
int maxLength(vector<int>& arr,int k,map<int,int>& M,int sum)
{
int max_len=0;
for(int i=0;i<arr.size();i++)
{
sum+=arr[i];
if(M.find(sum-k) != M.end())
{
max_len=max(i-M[sum-k],max_len);
}
if(M.find(sum)==M.end())
{
M[sum]=i;
}
}
return max_len;
}
};
//int main()
//{
// Solution2 s;
// int A[]={7,3,2,1,1,7,7,7};
// int len=sizeof(A)/sizeof(*A);
// vector<int> nums;
// for(int i=0;i<len;i++)
// {
// nums.push_back(A[i]);
// }
// cout<<s.maxLength(nums,7)<<endl;
//}
class Solution3
{
public:
/***************************************************
* 函数功能:判断一棵树是否为平衡二叉树
* 参数说明
* 输入参数:
* 输出参数:
* 复杂性分析:时间复杂度:O(),空间复杂度:O()
* 题目来源 :
* 日期:2018-07-27-16.47
***************************************************/
bool isBlanceTree(TreeNode* head)
{
if(head==NULL) return true;
bool flag=true;
isBlanceTree(head,flag,1);
return flag;
}
private:
int isBlanceTree(TreeNode* head,bool& flag,int level)
{
if(head==NULL)
{
return level;
}
int lH=isBlanceTree(head->left,flag,level+1);
if(!flag)
{
return level;
}
int rH=isBlanceTree(head->right,flag,level+1);
if(!flag)
{
return level;
}
if(abs(lH-rH)>1)
{
flag=false;
}
return max(lH,rH);
}
};
//int main()
//{
// Solution3 s;
//
// TreeNode a1(-3);
// TreeNode b1(3);
// TreeNode b2(-9);
// TreeNode c1(1);
// TreeNode c2(0);
//// TreeNode c3(2);
//// TreeNode c4(1);
// TreeNode d1(1);
// TreeNode d2(6);
// a1.left=&b1;
// a1.right=&b2;
// b1.left=&c1;
// b1.right=&c2;
//// b2.left=&c3;
//// b2.right=&c4;
// c2.left=&d1;
// c2.right=&d2;
//
// cout<<s.isBlanceTree(&a1)<<endl;
//
// return 0;
//}
/***************************************************
* 函数功能:最大搜索子树
* 参数说明
* 输入参数:
* 输出参数:
* 复杂性分析:时间复杂度:O(2^n),空间复杂度:O(1)
* 题目来源 :
* 日期:2018-07-27-16.10
***************************************************/
class Solution4
{
public:
TreeNode* biggestSubTree(TreeNode* root)
{
if(root==NULL) return root;
TreeNode* head=dfs_subTree(root);
cout<<"size "<<Size<<endl;
return head;
}
private:
TreeNode* dfs_subTree(TreeNode* root)
{
if(root==NULL)
{
Min=0;
Max=0;
Size=0;
return NULL;
}
TreeNode* LNode=dfs_subTree(root->left);
int lMin=Min;
int lMax=Max;
int lSize=Size;
TreeNode* RNode=dfs_subTree(root->right);
int rMin=Min;
int rMax=Max;
int rSize=Size;
if(LNode==NULL && RNode==NULL)
{
Max=root->val;
Min=root->val;
Size=1;
return root;
}else if(LNode==root->left && RNode==root->right && root->val >=lMax && root->val <=rMin)
{
Size=lSize+rSize+1;
Min=lMin;
Max=rMax;
return root;
}else
{
Min=min(lMin,min(rMin,root->val));
Max=max(lMax,max(rMax,root->val));
Size=lSize>rSize?lSize:rSize;
return lSize>rSize?LNode:RNode;
}
}
int Min;
int Max;
int Size;
};
void Print_Tree(TreeNode* root,int layer)
{
if(root==NULL)
{
return ;
}
for(int i=0;i<layer;i++)
{
cout<<"--";
}
cout<<root->val<<endl;
Print_Tree(root->left,layer+1);
Print_Tree(root->right,layer+1);
}
int main()
{
Solution4 s;
TreeNode a1(12);
TreeNode b1(6);
TreeNode b2(12);
TreeNode c1(4);
TreeNode c2(8);
TreeNode c3(10);
TreeNode c4(14);
TreeNode d1(2);
TreeNode d2(5);
TreeNode d3(7);
TreeNode d4(9);
a1.left=&b1;
a1.right=&b2;
b1.left=&c1;
b1.right=&c2;
b2.left=&c3;
b2.right=&c4;
c1.left=&d1;
c1.right=&d2;
c2.left=&d3;
c2.right=&d4;
TreeNode* head=s.biggestSubTree(&a1);
Print_Tree(head,0);
return 0;
}