進階算法03

給定一個數組，數組中有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);
}