Open In App

# Maximum Sum Increasing Subsequence using Binary Indexed Tree

Given an array of size n. Find the maximum sum of an increasing subsequence.
Examples:

```Input :  arr[] = { 1, 20, 4, 2, 5 }
Output : Maximum sum of increasing subsequence is = 21
The subsequence  1, 20 gives maximum sum which is 21

Input  : arr[] = { 4, 2, 3, 1, 5, 8 }
Output : Maximum sum of increasing subsequence is = 18
The subsequence  2, 3, 5, 8 gives maximum sum which is 18```

Prerequisite
The solution makes the use of Binary Indexed Tree and map.
Dynamic Programming Approach: DP approach which is in O(n^2) .
Solution
Step 1 :
The first step is to insert all values in a map, later we can map these array values to the indexes of Binary Indexed Tree.
Step 2 :
Iterate the map and assign indexes. What this would do is for an array { 4, 2, 3, 8, 5, 2 }
2 will be assigned index 1
3 will be assigned index 2
4 will be assigned index 3
5 will be assigned index 4
8 will be assigned index 5
Step 3 :
Construct the Binary Indexed Tree.
Step 4 :
For every value in the given array do the following.
Find the maximum sum till that position using BIT and then update the BIT with New Maximum Value
Step 5 :
Returns the maximum sum which is present at last position in Binary Indexed Tree.

## C++

 `// C++ code for Maximum Sum``// Increasing Subsequence``#include ``using` `namespace` `std;` `// Returns the maximum value of``// the increasing subsequence``// till that index``// Link to understand getSum function``// https://www.geeksforgeeks.org/binary-indexed-tree-or-fenwick-tree-2/``int` `getSum(``int` `BITree[], ``int` `index)``{``    ``int` `sum = 0;``    ``while` `(index > 0) {``        ``sum = max(sum, BITree[index]);``        ``index -= index & (-index);``    ``}``    ``return` `sum;``}` `// Updates a node in Binary Index``// Tree (BITree) at given index in``// BITree. The max value is updated``// by taking max  of 'val' and the``// already present value in the node.``void` `updateBIT(``int` `BITree[], ``int` `newIndex,``               ``int` `index, ``int` `val)``{``    ``while` `(index <= newIndex) {``        ``BITree[index] = max(val, BITree[index]);``        ``index += index & (-index);``    ``}``}` `// maxSumIS() returns the maximum``// sum of increasing subsequence``// in arr[] of size n``int` `maxSumIS(``int` `arr[], ``int` `n)``{``    ``int` `newindex = 0, max_sum;` `    ``map<``int``, ``int``> uniqueArr;` `    ``// Inserting all values in map uniqueArr``    ``for` `(``int` `i = 0; i < n; i++) {``        ``uniqueArr[arr[i]] = 0;``    ``}` `    ``// Assigning indexes to all``    ``// the  values present in map``    ``for` `(map<``int``, ``int``>::iterator it = uniqueArr.begin();``         ``it != uniqueArr.end(); it++) {` `        ``// newIndex is actually the count of``        ``// unique values in the array.``        ``newindex++;` `        ``uniqueArr[it->first] = newindex;``    ``}` `    ``// Constructing the BIT``    ``int``* BITree = ``new` `int``[newindex + 1];` `    ``// Initializing the BIT``    ``for` `(``int` `i = 0; i <= newindex; i++) {``        ``BITree[i] = 0;``    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``// Finding maximum sum till this element``        ``max_sum = getSum(BITree, uniqueArr[arr[i]] - 1);` `        ``// Updating the BIT  with new maximum sum``        ``updateBIT(BITree, newindex,``                 ``uniqueArr[arr[i]], max_sum + arr[i]);``    ``}` `    ``// return maximum sum``    ``return` `getSum(BITree, newindex);``}` `// Driver program``int` `main()``{``    ``int` `arr[] = { 1, 101, 2, 3, 100, 4, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << ``"Maximum sum is = "` `<< maxSumIS(arr, n);` `    ``return` `0;``}`

## Java

 `// JAVA code for Maximum Sum``// Increasing Subsequence``import` `java.util.*;``class` `GFG{` `// Returns the maximum value of``// the increasing subsequence``// till that index``// Link to understand getSum function``// https://www.geeksforgeeks.org/``// binary-indexed-tree-or-fenwick-tree-2/``static` `int` `getSum(``int` `BITree[], ``int` `index)``{``  ``int` `sum = ``0``;``  ``while` `(index > ``0``)``  ``{``    ``sum = Math.max(sum,``                   ``BITree[index]);``    ``index -= index & (-index);``  ``}``  ``return` `sum;``}` `// Updates a node in Binary Index``// Tree (BITree) at given index in``// BITree. The max value is updated``// by taking max  of 'val' and the``// already present value in the node.``static` `void` `updateBIT(``int` `BITree[],``                      ``int` `newIndex,``                      ``int` `index, ``int` `val)``{``  ``while` `(index <= newIndex)``  ``{``    ``BITree[index] = Math.max(val,``                             ``BITree[index]);``    ``index += index & (-index);``  ``}``}` `// maxSumIS() returns the maximum``// sum of increasing subsequence``// in arr[] of size n``static` `int` `maxSumIS(``int` `arr[],``                    ``int` `n)``{``  ``int` `newindex = ``0``, max_sum;` `  ``HashMap uniqueArr =``          ``new` `HashMap<>();` `  ``// Inserting all values in map``  ``// uniqueArr``  ``for` `(``int` `i = ``0``; i < n; i++)``  ``{``    ``uniqueArr.put(arr[i], ``0``);``  ``}` `  ``// Assigning indexes to all``  ``// the  values present in map``  ``for` `(Map.Entry entry :``                 ``uniqueArr.entrySet())``  ``{``    ``// newIndex is actually the``    ``// count of unique values in``    ``// the array.``    ``newindex++;` `    ``uniqueArr.put(entry.getKey(),``                  ``newindex);``  ``}` `  ``// Constructing the BIT``  ``int` `[]BITree = ``new` `int``[newindex + ``1``];` `  ``// Initializing the BIT``  ``for` `(``int` `i = ``0``; i <= newindex; i++)``  ``{``    ``BITree[i] = ``0``;``  ``}` `  ``for` `(``int` `i = ``0``; i < n; i++)``  ``{``    ``// Finding maximum sum till``    ``// this element``    ``max_sum = getSum(BITree,``                     ``uniqueArr.get(arr[i]) - ``3``);` `    ``// Updating the BIT with``    ``// new maximum sum``    ``updateBIT(BITree, newindex,``              ``uniqueArr.get(arr[i]),``              ``max_sum + arr[i]);``  ``}` `  ``// return maximum sum``  ``return` `getSum(BITree,``                ``newindex);``}` `// Driver program``public` `static` `void` `main(String[] args)``{``  ``int` `arr[] = {``1``, ``101``, ``2``,``               ``3``, ``100``, ``4``, ``5``};``  ``int` `n = arr.length;``  ``System.out.print(``"Maximum sum is = "` `+ ``                    ``maxSumIS(arr, n));``}``}` `// This code is contributed by shikhasingrajput`

## C#

 `// C# code for Maximum Sum``// Increasing Subsequence``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Returns the maximum value of``// the increasing subsequence``// till that index``// Link to understand getSum function``// https://www.geeksforgeeks.org/``// binary-indexed-tree-or-fenwick-tree-2/``static` `int` `getSum(``int` `[]BITree,``                  ``int` `index)``{``  ``int` `sum = 0;``  ``while` `(index > 0)``  ``{``    ``sum = Math.Max(sum,``                   ``BITree[index]);``    ``index -= index & (-index);``  ``}``  ``return` `sum;``}` `// Updates a node in Binary Index``// Tree (BITree) at given index in``// BITree. The max value is updated``// by taking max  of 'val' and the``// already present value in the node.``static` `void` `updateBIT(``int` `[]BITree,``                      ``int` `newIndex,``                      ``int` `index, ``int` `val)``{``  ``while` `(index <= newIndex)``  ``{``    ``BITree[index] = Math.Max(val,``                             ``BITree[index]);``    ``index += index & (-index);``  ``}``}` `// maxSumIS() returns the maximum``// sum of increasing subsequence``// in []arr of size n``static` `int` `maxSumIS(``int` `[]arr,``                    ``int` `n)``{``  ``int` `newindex = 0, max_sum;` `  ``Dictionary<``int``,``             ``int``> uniqueArr =``             ``new` `Dictionary<``int``,``                            ``int``>();` `  ``// Inserting all values in map``  ``// uniqueArr``  ``for` `(``int` `i = 0; i < n; i++)``  ``{``    ``uniqueArr.Add(arr[i], 0);``  ``}``    ``Dictionary<``int``,``               ``int``> uniqueArr1 =``               ``new` `Dictionary<``int``,``                              ``int``>();` `  ``// Assigning indexes to all``  ``// the  values present in map``  ``foreach` `(KeyValuePair<``int``,``                        ``int``> entry ``in``                        ``uniqueArr)``  ``{``    ``// newIndex is actually the``    ``// count of unique values in``    ``// the array.``    ``newindex++;``    ``if``(uniqueArr1.ContainsKey(entry.Key))``      ``uniqueArr1[entry.Key] = newindex;``    ``else``      ``uniqueArr1.Add(entry.Key,``                     ``newindex);``  ``}` `  ``// Constructing the BIT``  ``int` `[]BITree = ``new` `int``[newindex + 1];` `  ``// Initializing the BIT``  ``for` `(``int` `i = 0; i <= newindex; i++)``  ``{``    ``BITree[i] = 0;``  ``}` `  ``for` `(``int` `i = 0; i < n; i++)``  ``{``    ``// Finding maximum sum till``    ``// this element``    ``max_sum = getSum(BITree,``                     ``uniqueArr1[arr[i]] - 4);` `    ``// Updating the BIT with``    ``// new maximum sum``    ``updateBIT(BITree, newindex,``              ``uniqueArr1[arr[i]],``              ``max_sum + arr[i]);``  ``}` `  ``// return maximum sum``  ``return` `getSum(BITree,``                ``newindex);``}` `// Driver program``public` `static` `void` `Main(String[] args)``{``  ``int` `[]arr = {1, 101, 2,``               ``3, 100, 4, 5};``  ``int` `n = arr.Length;``  ``Console.Write(``"Maximum sum is = "` `+ ``                 ``maxSumIS(arr, n));``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

## Python3

 `# python code for Maximum Sum``# Increasing Subsequence` `# Returns the maximum value of``# the increasing subsequence``# till that index``# Link to understand getSum function``def` `getSum(BITree, index):` `    ``sum` `=` `0``    ``while` `(index > ``0``):``        ``sum` `=` `max``(``sum``, BITree[index])``        ``index ``-``=` `index & (``-``index)` `    ``return` `sum` `# Updates a node in Binary Index``# Tree (BITree) at given index in``# BITree. The max value is updated``# by taking max  of 'val' and the``# already present value in the node.``def` `updateBIT(BITree, newIndex, index, val):``    ``while` `(index <``=` `newIndex):``        ``BITree[index] ``=` `max``(val, BITree[index])``        ``index ``+``=` `index & (``-``index)`  `# maxSumIS() returns the maximum``# sum of increasing subsequence``# in arr[] of size n``def` `maxSumIS(arr, n):` `    ``newindex ``=` `0``    ``max_sum ``=` `0``    ``uniqueArr ``=` `{}` `    ``# Inserting all values in map uniqueArr``    ``for` `i ``in` `range``(``0``, n):``        ``uniqueArr[arr[i]] ``=` `0` `    ``# Assigning indexes to all``    ``# the  values present in map``    ``for` `it ``in` `sorted``(uniqueArr):` `        ``# newIndex is actually the count of``        ``# unique values in the array.``        ``newindex ``+``=` `1``        ``uniqueArr[it] ``=` `newindex` `    ``# Constructing the BIT``    ``BITree ``=` `[``0``]``*``(newindex ``+` `1``)` `    ``# Initializing the BIT``    ``for` `i ``in` `range``(``0``, newindex``+``1``):``        ``BITree[i] ``=` `0` `    ``for` `i ``in` `range``(``0``, n):``        ``# Finding maximum sum till this element``        ``max_sum ``=` `getSum(BITree, uniqueArr[arr[i]] ``-` `1``)``        ` `        ``# Updating the BIT  with new maximum sum``        ``updateBIT(BITree, newindex, uniqueArr[arr[i]], max_sum ``+` `arr[i])` `    ``# return maximum sum``    ``return` `getSum(BITree, newindex)` `# Driver program``arr ``=` `[``1``, ``101``, ``2``, ``3``, ``100``, ``4``, ``5``]``n ``=` `len``(arr)``print``(``"Maximum sum is = "``, maxSumIS(arr, n))` `# This code is contributed by rj13to.`

Output

`Maximum sum is = 106`

Note
Time Complexity of the solution
O(nLogn) for the map and O(nLogn) for updating and getting sum. So overall complexity is still O(nLogn).