Sherlock and Cost Discussions | Algorithms | HackerRank

Sort by

recency

|

262 Discussions

|

  • + 0 comments

    Locksmith Courses offer the perfect starting point for anyone looking to enter the security industry with confidence. These hands-on programs teach essential skills, from lock picking to advanced security systems. With rising interest in crime-solving, think Sherlock—but with real-world, practical knowledge. Cost varies by course level, but the investment pays off in job readiness and independence. Gain valuable skills and open doors to a secure and rewarding career path today.

  • + 1 comment

    testcase=int(input()) for i in range(testcase): n=int(input()) b=[int(x) for x in input().split(' ')]
    maxi, max1 = 0, 0 for i in range(1,len(b)): curr, prev = b[i], b[i-1] newmaxi = max(maxi + abs(curr - prev), max1 + (curr - 1)) newmax1 = max(maxi + abs(1 - prev), max1) maxi, max1 = newmaxi, newmax1
    print(max(maxi, max1))

  • + 1 comment

    Sherlock and Cost, a leading provider of investigative services, offers unparalleled expertise in solving complex cases. With a team of seasoned professionals and cutting-edge technology, we deliver comprehensive solutions tailored to your needs Gatwick Airport Transfer. From corporate investigations to personal matters, trust Sherlock and Cost to uncover the truth. Plus, don't miss out on our exclusive Wow deals, providing exceptional value for our clients. Experience excellence in investigation services with Sherlock and Cost.

  • + 2 comments

    Here's a PHP solution to solve this problem:

    <?php
    
    function cost($B) {
        $n = count($B);
    
        // dp array where dp[0] means A[i] is 1 and dp[1] means A[i] is B[i]
        $dp = array_fill(0, 2, 0);
    
        for ($i = 1; $i < $n; $i++) {
            $prevDp0 = $dp[0];
            $prevDp1 = $dp[1];
    
            // When A[i] is 1
            $dp[0] = max(
                $prevDp0 + abs(1 - 1), // A[i-1] is 1
                $prevDp1 + abs(1 - $B[$i - 1]) // A[i-1] is B[i-1]
            );
    
            // When A[i] is B[i]
            $dp[1] = max(
                $prevDp0 + abs($B[$i] - 1), // A[i-1] is 1
                $prevDp1 + abs($B[$i] - $B[$i - 1]) // A[i-1] is B[i-1]
            );
        }
    
        // The result is the maximum value when A[n-1] is either 1 or B[n-1]
        return max($dp[0], $dp[1]);
    }
    
    // Example usage:
    $B = [10, 1, 10, 1, 10];
    echo cost($B); // Output: 36
    
    ?>
    

    Explanation:

    1. Dynamic Programming Table (dp):

      • dp[0]: The maximum cost when A[i] is set to 1.
      • dp[1]: The maximum cost when A[i] is set to B[i].
    2. Transition between states:

      • For each i from 1 to n-1, we update dp[0] and dp[1] based on the previous values:
        • If A[i] is 1, the cost can come from either A[i-1] being 1 or B[i-1].
        • If A[i] is B[i], the cost can come from either A[i-1] being 1 or B[i-1].
    3. Final Result:

      • The result will be the maximum value between dp[0] and dp[1] at the end of the array, which represents the maximum cost achievable by either setting A[n-1] to 1 or B[n-1].

    This solution efficiently computes the desired result with a time complexity of O(n), making it suitable for large inputs within the constraints.

  • + 4 comments
    #include<bits/stdc++.h>
    #define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
    using namespace std;
    typedef long long ll;
    ll mod = 1e9+7;
    ll dp[100001][101];
    ll Fun(ll idx, ll n, vector<ll>&B,ll previous){
        if (idx == n)return 0;
        if(dp[idx][previous]!=-1)return dp[idx][previous];
        ll ans = 0 , left  = 0;
        if(idx == 0)ans = max(Fun(idx+1,n,B,1),Fun(idx+1,n,B,B[idx]));
        else{
            left = max(abs(previous-1) + Fun(idx+1,n,B,1), abs(previous-B[idx])+Fun(idx+1,n,B,B[idx]));
            ans = max(ans,left);
        }
        return dp[idx][previous]=ans;
    }
    void Don(){
        ll n;
        cin >> n;
        vector<ll>B(n);
        for(int i = 0 ; i < n ; i++)cin >> B[i];
        memset(dp,-1,sizeof(dp));
        ll ans = Fun(0,n,B,0);
        cout<<ans<<endl;
    }
    int main(){
        ll t;
        cin >> t;
        while(t--){
            Don();
        }
    }
    /*
    instead of trying to place A[i] from 1 to B[i], just try 1 or B[i] because 1-B[i] gives us maximum.
    here is my solution using recursion to try all possible ways of keeping either 1 or B[i]
    after that i added memoization 
    */