牛客 进阶课程1 笔记 程序

#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;
}