进阶算法03

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zxt_1/article/details/89366980

给定一个数组，数组中有0，正数，负数，找到一个累加和为目标值的最长子数组，返回最长子数组的长度。

int maxLength(int *arr, int len, int target)
{
    if (!arr || len == 0)
        return 0;

    int sum = 0;
    int ret = 0;

    map<int, int> m;        //first:子数组arr[0...second]的和，second：末尾下标
    m.insert(make_pair(0, -1));

    for (int i = 0; i < len; i++)
    {
        sum += arr[i];
        auto it = m.find(sum - target);
        if (it != m.end())
            ret = max(i - it->second, ret);

        if (m.find(sum) == m.end())
            m.insert(make_pair(sum, i));
    }

    return ret;
}

扩展：给定一个数组，数组中有奇数和偶数，找到一个最长子数组，其中包含的奇数和偶数个数相等，返回最长子数组的长度。
思路：奇数==-1，偶数==1，找到一个累加和为0的最长子数组

求一个二叉树中最大搜索二叉树的头部（1.是一棵搜索二叉树 2.包含节点最多）

三种情况：
1.这棵最大搜索二叉树在当前节点的左边
2.这棵最大搜索二叉树在当前节点的右边
3.以当前节点为头节点就是最大搜索二叉树

要搜集的信息：
1.左子树的最大搜索二叉树的大小
2.右子树的最大搜索二叉树的大小
3.左子树的最大搜索二叉树的头部
4.右子树的最大搜索二叉树的头部
5.左子树的最大二叉搜索树的最大值
6.右子树的最大二叉搜索树的最小值

化简后;
1.最大搜索二叉树的大小
2.最大搜索二叉树的头部
3.最大搜索二叉树的最大值
4.最大搜索二叉树的最小值

class Node
{
public:
    int val;
    Node *left;
    Node *right;

    Node(int data)
    {
        val = data;
        left = NULL;
        right = NULL;
    }
};

class returnType
{
public:
    int size;
    Node *head;
    int maxVal;
    int minVal;

    returnType(int a, Node *b, int c, int d)
    {
        size = a;
        head = b;
        maxVal = c;
        minVal = d;
    }
};


returnType process(Node *head)
{
    if (!head)
        return returnType(0, NULL, INT_MIN, INT_MAX);

    returnType leftRetType = process(head->left);
    returnType rightRetType = process(head->right);

    int p1 = leftRetType.size;
    int p2 = rightRetType.size;
    int p3 = 0;
    if (head->left == leftRetType.head &&
        head->right == rightRetType.head &&
        head->val > leftRetType.maxVal &&
        head->val < rightRetType.minVal)
    {
        p3 = leftRetType.size + rightRetType.size + 1;
    }

    int size = max(max(p1, p2), p3);
    Node *node = (leftRetType.size == size) ? leftRetType.head : rightRetType.head;
    if (size == p3)
        node = head;

    int maxVal = max(max(leftRetType.maxVal, rightRetType.maxVal), head->val);
    int minVal = min(min(leftRetType.minVal, rightRetType.minVal), head->val);

    return returnType(size, node, maxVal, minVal);
}

Node *biggestSubBST(Node *head)
{
    return process(head).head;
}

求一棵二叉树的最远距离（任意两个节点的距离，求最大）

三种情况：
1.最远距离产生自当前节点的左边
2.最远距离产生自当前节点的右边
3.最远距离包含当前节点

要搜集的信息：
1.最远距离的大小
2.深度

class Node
{
public:
    int val;
    Node *left;
    Node *right;

    Node(int data)
    {
        val = data;
        left = NULL;
        right = NULL;
    }
};

class returnType
{
public:
    int maxDis;
    int height;

    returnType(int a, int b)
    {
        maxDis = a;
        height = b;
    }
};


returnType process(Node *head)
{
    if (!head)
        return returnType(0, 0);

    returnType leftRetType = process(head->left);
    returnType rightRetType = process(head->right);

    int p1 = leftRetType.maxDis;
    int p2 = rightRetType.maxDis;
    int p3 = leftRetType.height + rightRetType.height + 1;
    

    int size = max(max(p1, p2), p3);
    int height = max(leftRetType.height, rightRetType.height) + 1;

    return returnType(size, height);
}

int maxDistance(Node *head)
{
    return process(head).maxDis;
}

两种情况：
1.当前节点来
2.当前节点不来

要搜集的信息：
1.当前节点来的最大活跃度
2.当前节点不来的最大活跃度

//改写形式
class Node
{
public:
    int activity;
    vector<Node*> nexts;

    Node(int data)
    {
        activity = data;
    }
};

class returnType
{
public:
    int comeActivity;
    int notcomeActivity;

    returnType(int a, int b)
    {
        comeActivity = a;
        notcomeActivity = b;
    }
};


returnType process(Node *head)
{
    if (!head)
        return returnType(0, 0);


    int comeActivity = 0;
    int notcomeActivity = 0;
    for (int i = 0; i < head->nexts.size(); i++)
    {
        Node *node = head->nexts[i];
        returnType ret = process(node);
        comeActivity += ret.notcomeActivity;
        notcomeActivity += max(ret.comeActivity, ret.notcomeActivity);
    }

    return returnType(comeActivity, notcomeActivity);
}

int maxActivity(Node *head)
{
    returnType ret = process(head);
    return max(ret.comeActivity, ret.notcomeActivity);
}