Find maximum possible stolen value from houses - GeeksforGeeks

05 May, 2022
There are n houses build in a line, each of which contains some value in it. A thief is going to steal the maximal value of these houses, but he can’t steal in two adjacent houses because the owner of the stolen houses will tell his two neighbors left and right side. What is the maximum stolen value?Examples:  
Input: hval[] = {6, 7, 1, 3, 8, 2, 4}
Output: 19

Explanation: The thief will steal 6, 1, 8 and 4 from the house.

Input: hval[] = {5, 3, 4, 11, 2}
Output: 16

Explanation: Thief will steal 5 and 11
 
Naive Approach: Given an array, the solution is to find the maximum sum subsequence where no two selected elements are adjacent. So the approach to the problem is a recursive solution. So there are two cases.  
If an element is selected then the next element cannot be selected.if an element is not selected then the next element can be selected.
If an element is selected then the next element cannot be selected.
if an element is not selected then the next element can be selected.
Implementation of recursion approach:
C++
C
// CPP program to find the maximum stolen value#include <iostream>using namespace std; // calculate the maximum stolen valueint maxLoot(int* hval, int n){    // base case    if (n < 0) {        return 0;    }     if (n == 0) {        return hval[0];    }    // if current element is pick then previous cannot be    // picked    int pick = hval[n] + maxLoot(hval, n - 2);    // if current element is not picked then previous    // element is picked    int notPick = maxLoot(hval, n - 1);     // return max of picked and not picked    return max(pick, notPick);} // Driver to test above codeint main(){    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    cout << "Maximum loot possible : "         << maxLoot(hval, n - 1);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to find the maximum stolen value#include <stdio.h> // Find maximum between two numbers.int max(int num1, int num2){    return (num1 > num2) ? num1 : num2;} // calculate the maximum stolen valueint maxLoot(int* hval, int n){    // base case    if (n < 0)        return 0;     if (n == 0)        return hval[0];    // if current element is pick then previous cannot be    // picked    int pick = hval[n] + maxLoot(hval, n - 2);    // if current element is not picked then previous    // element is picked    int notPick = maxLoot(hval, n - 1);     // return max of picked and not picked    return max(pick, notPick);} // Driver to test above codeint main(){    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    printf("Maximum loot possible : %d ",           maxLoot(hval, n - 1));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
Maximum loot possible : 19
Complexity Analysis
Time Complexity:  O(2N). Every element has 2 choices to pick and not pick
Space Complexity: O(2N). A recursion stack space is required of size 2n, so space complexity is O(2N).
Method 2: Dynamic Programming : Top Down Approach
So the recursive solution can easily be deviced. The sub-problems can be stored thus reducing the complexity and converting the recursive solution to a Dynamic programming problem.
C++
// CPP program to find the maximum stolen value#include <bits/stdc++.h>using namespace std; // calculate the maximum stolen valueint maxLoot(int *hval, int n, vector<int> &dp){      // base case   if(n < 0){           return 0 ;   }       if(n == 0){           return hval[0] ;   }   // If the subproblem is already solved   // then return its value   if(dp[n] != -1 ){          return dp[n] ;   }      //if current element is pick then previous cannot be picked   int pick = hval[n] +  maxLoot(hval, n-2, dp) ;   //if current element is not picked then previous element is picked   int notPick = maxLoot(hval, n-1, dp)  ;      // return max of picked and not picked   return dp[n] = max(pick, notPick) ;   } // Driver to test above codeint main(){    int hval[] = {6, 7, 1, 3, 8, 2, 4};    int n = sizeof(hval)/sizeof(hval[0]);    // Initialize a dp vector    vector<int> dp(n+1, -1) ;    cout << "Maximum loot possible : "        << maxLoot(hval, n-1, dp);    return 0;}
Maximum loot possible : 19
Complexity Analysis:  
Time Complexity: O(n) . Only one traversal of original array is needed. So the time complexity is O(n)
Space Complexity:  O(n). Recursive stack space is required of size n, so space complexity is O(n).
Method 3: Dynamic Programming : Bottom Up Approach
So the recursive solution can easily be deviced. The sub-problems can be stored thus reducing the complexity and converting the recursive solution to a Dynamic programming problem. 
Algorithm:  
Create an extra space dp, DP array to store the sub-problems.Tackle some basic cases, if the length of the array is 0, print 0, if the length of the array is 1, print the first element, if the length of the array is 2, print maximum of two elements.Update dp[0] as array[0] and dp[1] as maximum of array[0] and array[1]Traverse the array from the second element (2nd index) to the end of array.For every index, update dp[i] as maximum of dp[i-2] + array[i] and dp[i-1], this step defines the two cases, if an element is selected then the previous element cannot be selected and if an element is not selected then the previous element can be selected.Print the value dp[n-1]
Create an extra space dp, DP array to store the sub-problems.
Tackle some basic cases, if the length of the array is 0, print 0, if the length of the array is 1, print the first element, if the length of the array is 2, print maximum of two elements.
Update dp[0] as array[0] and dp[1] as maximum of array[0] and array[1]
Traverse the array from the second element (2nd index) to the end of array.
For every index, update dp[i] as maximum of dp[i-2] + array[i] and dp[i-1], this step defines the two cases, if an element is selected then the previous element cannot be selected and if an element is not selected then the previous element can be selected.
Print the value dp[n-1]
Implementation:  
C++
C
Java
Python3
C#
PHP
Javascript
// CPP program to find the maximum stolen value#include <iostream>using namespace std; // calculate the maximum stolen valueint maxLoot(int* hval, int n){    if (n == 0)        return 0;    if (n == 1)        return hval[0];    if (n == 2)        return max(hval[0], hval[1]);     // dp[i] represent the maximum value stolen    // so far after reaching house i.    int dp[n];     // Initialize the dp[0] and dp[1]    dp[0] = hval[0];    dp[1] = max(hval[0], hval[1]);     // Fill remaining positions    for (int i = 2; i < n; i++)        dp[i] = max(hval[i] + dp[i - 2], dp[i - 1]);     return dp[n - 1];} // Driver to test above codeint main(){    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    cout << "Maximum loot possible : " << maxLoot(hval, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to find the maximum stolen value#include <stdio.h> // Find maximum between two numbers.int max(int num1, int num2){    return (num1 > num2) ? num1 : num2;} // calculate the maximum stolen valueint maxLoot(int* hval, int n){    if (n == 0)        return 0;    if (n == 1)        return hval[0];    if (n == 2)        return max(hval[0], hval[1]);     // dp[i] represent the maximum value stolen    // so far after reaching house i.    int dp[n];     // Initialize the dp[0] and dp[1]    dp[0] = hval[0];    dp[1] = max(hval[0], hval[1]);     // Fill remaining positions    for (int i = 2; i < n; i++)        dp[i] = max(hval[i] + dp[i - 2], dp[i - 1]);     return dp[n - 1];} // Driver to test above codeint main(){    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    printf("Maximum loot possible : %d", maxLoot(hval, n));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program to find the maximum stolen valueimport java.io.*; class GFG {    // Function to calculate the maximum stolen value    static int maxLoot(int hval[], int n)    {        if (n == 0)            return 0;        if (n == 1)            return hval[0];        if (n == 2)            return Math.max(hval[0], hval[1]);         // dp[i] represent the maximum value stolen        // so far after reaching house i.        int[] dp = new int[n];         // Initialize the dp[0] and dp[1]        dp[0] = hval[0];        dp[1] = Math.max(hval[0], hval[1]);         // Fill remaining positions        for (int i = 2; i < n; i++)            dp[i]                = Math.max(hval[i] + dp[i - 2], dp[i - 1]);         return dp[n - 1];    }     // Driver program    public static void main(String[] args)    {        int hval[] = { 6, 7, 1, 3, 8, 2, 4 };        int n = hval.length;        System.out.println("Maximum loot value : " + maxLoot(hval, n));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# Python3 program to find the maximum stolen value # calculate the maximum stolen valuedef maximize_loot(hval, n):    if n == 0:        return 0    if n == 1:        return hval[0]    if n == 2:        return max(hval[0], hval[1])     # dp[i] represent the maximum value stolen so    # for after reaching house i.    dp = [0]*n     # Initialize the dp[0] and dp[1]    dp[0] = hval[0]    dp[1] = max(hval[0], hval[1])         # Fill remaining positions    for i in range(2, n):        dp[i] = max(hval[i]+dp[i-2], dp[i-1])     return dp[-1] # Driver to test above codedef main():     # Value of houses    hval = [6, 7, 1, 3, 8, 2, 4]     # number of houses    n = len(hval)    print("Maximum loot value : {}".        format(maximize_loot(hval, n))) if __name__ == '__main__':    main()
// C# program to find the// maximum stolen valueusing System;         class GFG{   // Function to calculate the   // maximum stolen value    static int maxLoot(int []hval, int n)    {        if (n == 0)        return 0;        if (n == 1)            return hval[0];        if (n == 2)            return Math.Max(hval[0], hval[1]);         // dp[i] represent the maximum value stolen        // so far after reaching house i.        int[] dp = new int[n];         // Initialize the dp[0] and dp[1]        dp[0] = hval[0];        dp[1] = Math.Max(hval[0], hval[1]);         // Fill remaining positions        for (int i = 2; i<n; i++)            dp[i] = Math.Max(hval[i]+dp[i-2], dp[i-1]);         return dp[n-1];    }         // Driver program    public static void Main ()    {        int []hval = {6, 7, 1, 3, 8, 2, 4};        int n = hval.Length;        Console.WriteLine("Maximum loot value : " +                                 maxLoot(hval, n));    }} // This code is contributed by Sam007
<?php// PHP program to find// the maximum stolen value // calculate the maximum// stolen valuefunction maxLoot($hval, $n){    if ($n == 0)        return 0;    if ($n == 1)        return $hval[0];    if ($n == 2)        return max($hval[0],                   $hval[1]);     // dp[i] represent the maximum    // value stolen so far after    // reaching house i.    $dp = array();     // Initialize the    // dp[0] and dp[1]    $dp[0] = $hval[0];    $dp[1] = max($hval[0],                 $hval[1]);     // Fill remaining positions    for ($i = 2; $i < $n; $i++)        $dp[$i] = max($hval[$i] +                      $dp[$i - 2],                      $dp[$i - 1]);     return $dp[$n - 1];} // Driver Code$hval = array(6, 7, 1,              3, 8, 2, 4);$n = sizeof($hval);echo "Maximum loot possible : ",             maxLoot($hval, $n);     // This code is contributed by aj_36?>
<script>     // Javascript program to find    // the maximum stolen value         // Function to calculate the       // maximum stolen value    function maxLoot(hval, n)    {        if (n == 0)            return 0;        if (n == 1)            return hval[0];        if (n == 2)            return Math.max(hval[0], hval[1]);           // dp[i] represent the maximum value stolen        // so far after reaching house i.        let dp = new Array(n);           // Initialize the dp[0] and dp[1]        dp[0] = hval[0];        dp[1] = Math.max(hval[0], hval[1]);           // Fill remaining positions        for (let i = 2; i<n; i++)            dp[i] = Math.max(hval[i]+dp[i-2], dp[i-1]);           return dp[n-1];    }         let hval = [6, 7, 1, 3, 8, 2, 4];    let n = hval.length;    document.write(    "Maximum loot value : " + maxLoot(hval, n)    );     </script>
Maximum loot possible : 19
 
Complexity Analysis:  
Time Complexity: . Only one traversal of original array is needed. So the time complexity is O(n)
Space Complexity: . An array is required of size n, so space complexity is O(n).
Efficient Approach: By carefully observing the DP array, it can be seen that the values of previous two indices matter while calculating the value for an index. To replace the total DP array by two variables.
Algorithm:  
Tackle some basic cases, if the length of the array is 0, print 0, if the length of the array is 1, print the first element, if the length of the array is 2, print maximum of two elements.Create two variables value1 and value2 value1 as array[0] and value2 as maximum of array[0] and array[1] and a variable max_val to store the answerTraverse the array from the second element (2nd index)  to the end of array.For every index, update max_val as maximum of value1 + array[i] and value2, this step defines the two cases, if an element is selected then the previous element cannot be selected and if an element is not selected then the previous element can be selected.For every index, Update value1 = value2 and value2 = max_valPrint the value of max_val
Tackle some basic cases, if the length of the array is 0, print 0, if the length of the array is 1, print the first element, if the length of the array is 2, print maximum of two elements.
Create two variables value1 and value2 value1 as array[0] and value2 as maximum of array[0] and array[1] and a variable max_val to store the answer
Traverse the array from the second element (2nd index)  to the end of array.
For every index, update max_val as maximum of value1 + array[i] and value2, this step defines the two cases, if an element is selected then the previous element cannot be selected and if an element is not selected then the previous element can be selected.
For every index, Update value1 = value2 and value2 = max_val
Print the value of max_val
Implementation:  
C++
C
Java
Python3
C#
PHP
Javascript
// C++ program to find the maximum stolen value#include <iostream>using namespace std; // calculate the maximum stolen valueint maxLoot(int* hval, int n){    if (n == 0)        return 0;     int value1 = hval[0];    if (n == 1)        return value1;     int value2 = max(hval[0], hval[1]);    if (n == 2)        return value2;     // contains maximum stolen value at the end    int max_val;     // Fill remaining positions    for (int i = 2; i < n; i++) {        max_val = max(hval[i] + value1, value2);        value1 = value2;        value2 = max_val;    }     return max_val;} // Driver to test above codeint main(){    // Value of houses    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    cout << "Maximum loot possible : " << maxLoot(hval, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to find the maximum stolen value#include <stdio.h> //Find maximum between two numbers.int max(int num1, int num2){  return (num1 > num2) ? num1 : num2;} // calculate the maximum stolen valueint maxLoot(int* hval, int n){    if (n == 0)        return 0;     int value1 = hval[0];    if (n == 1)        return value1;     int value2 = max(hval[0], hval[1]);    if (n == 2)        return value2;     // contains maximum stolen value at the end    int max_val;     // Fill remaining positions    for (int i = 2; i < n; i++) {        max_val = max(hval[i] + value1, value2);        value1 = value2;        value2 = max_val;    }     return max_val;} // Driver to test above codeint main(){    // Value of houses    int hval[] = { 6, 7, 1, 3, 8, 2, 4 };    int n = sizeof(hval) / sizeof(hval[0]);    printf("Maximum loot possible : %d", maxLoot(hval, n));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program to find the maximum stolen valueimport java.io.*; class GFG {    // Function to calculate the maximum stolen value    static int maxLoot(int hval[], int n)    {        if (n == 0)            return 0;         int value1 = hval[0];        if (n == 1)            return value1;         int value2 = Math.max(hval[0], hval[1]);        if (n == 2)            return value2;         // contains maximum stolen value at the end        int max_val = 0;         // Fill remaining positions        for (int i = 2; i < n; i++) {            max_val = Math.max(hval[i] + value1, value2);            value1 = value2;            value2 = max_val;        }         return max_val;    }     // driver program    public static void main(String[] args)    {        int hval[] = { 6, 7, 1, 3, 8, 2, 4 };        int n = hval.length;        System.out.println("Maximum loot value : "                           + maxLoot(hval, n));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# Python3 program to find the maximum stolen value # calculate the maximum stolen valuedef maximize_loot(hval, n):    if n == 0:        return 0     value1 = hval[0]    if n == 1:        return value1     value2 = max(hval[0], hval[1])    if n == 2:        return value2     # contains maximum stolen value at the end    max_val = None     # Fill remaining positions    for i in range(2, n):        max_val = max(hval[i]+value1, value2)        value1 = value2        value2 = max_val     return max_val # Driver to test above codedef main():     # Value of houses    hval = [6, 7, 1, 3, 8, 2, 4]     # number of houses    n = len(hval)    print("Maximum loot value : {}".format(maximize_loot(hval, n))) if __name__ == '__main__':    main()
// C# program to find the// maximum stolen valueusing System;         public class GFG{    // Function to calculate the    // maximum stolen value    static int maxLoot(int []hval, int n)    {        if (n == 0)        return 0;         int value1 = hval[0];        if (n == 1)            return value1;         int value2 = Math.Max(hval[0], hval[1]);        if (n == 2)            return value2;             // contains maximum stolen value at the end        int max_val = 0;         // Fill remaining positions        for (int i = 2; i < n; i++)        {            max_val = Math.Max(hval[i] + value1, value2);            value1 = value2;            value2 = max_val;        }         return max_val;    }         // Driver program    public static void Main ()    {        int []hval = {6, 7, 1, 3, 8, 2, 4};        int n = hval.Length;        Console.WriteLine("Maximum loot value : " +                                 maxLoot(hval, n));    }} // This code is contributed by Sam007
<?php// PHP program to find// the maximum stolen value // calculate the// maximum stolen valuefunction maxLoot($hval, $n){    if ($n == 0)        return 0;     $value1 = $hval[0];    if ($n == 1)        return $value1;     $value2 = max($hval[0],                  $hval[1]);    if ($n == 2)        return $value2;     // contains maximum    // stolen value at the end    $max_val;     // Fill remaining positions    for ($i = 2; $i < $n; $i++)    {        $max_val = max($hval[$i] +                       $value1, $value2);        $value1 = $value2;        $value2 = $max_val;    }     return $max_val;} // Driver code$hval = array(6, 7, 1, 3, 8, 2, 4);$n = sizeof($hval);echo "Maximum loot value : ",          maxLoot($hval, $n);     // This code is contributed by ajit?>
<script>     // Javascript program to find the    // maximum stolen value         // Function to calculate the    // maximum stolen value    function maxLoot(hval, n)    {        if (n == 0)            return 0;          let value1 = hval[0];        if (n == 1)            return value1;          let value2 = Math.max(hval[0], hval[1]);        if (n == 2)            return value2;              // contains maximum stolen value at the end        let max_val = 0;          // Fill remaining positions        for (let i = 2; i < n; i++)        {            max_val = Math.max(hval[i] +                               value1, value2);            value1 = value2;            value2 = max_val;        }          return max_val;    }         let hval = [6, 7, 1, 3, 8, 2, 4];    let n = hval.length;    document.write("Maximum loot value : "    + maxLoot(hval, n));     </script>
Maximum loot possible : 19
Complexity Analysis: 
Time Complexity: , Only one traversal of original array is needed. So the time complexity is O(n).
Auxiliary Space: , No extra space is required so the space complexity is constant.
This article is contributed by Atul Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Sam007
jit_t
andrew1234
suresh07
divyesh072019
raghvendraprasad5678
amartyaghoshgfg
prasanna1995
arorakashish0911
adityakumar129
Amazon
FactSet
Oxigen Wallet
OYO Rooms
Paytm
Walmart
Yahoo
Arrays
Dynamic Programming
Paytm
Amazon
OYO Rooms
FactSet
Walmart
Oxigen Wallet
Yahoo
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
0-1 Knapsack Problem | DP-10
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Longest Increasing Subsequence | DP-3