id int64 1 3.58k | problem_description stringlengths 516 21.8k | instruction int64 0 3 | solution_c dict |
|---|---|---|---|
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n \n int m=grid.size();\n int n=grid[0].size();\n\n vector<pair<int,int>>v;\n\n for(int i=0;i<m;i++){\n for(int j=0;j<n;j++){\n if(grid[i][j]==1)v.push_back({i,j})... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n int l1 = grid[0].size();int l2=0;\n int b1 =grid.size(); int b2=0;\n\n for(int i=0;i<grid.size();i++)\n {\n for(int j=0;j<grid[0].size();j... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row, col;\n for(int i=0; i<grid.size(); i++){\n for(int j=0; j<grid[i].size(); j++){\n if(grid[i][j]==1){\n row.push_back(i);\n col.push_ba... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n\n for(int i=0;i<grid.size();i++)\n {\n for(int j=0;j<grid[0].size();j++)\n {\n if(grid[i][j]==1)\n {\n ... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n\n for(int i=0;i<grid.size();i++)\n {\n for(int j=0;j<grid[0].size();j++)\n {\n if(grid[i][j]==1)\n {\n ... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n\n for(int i=0;i<grid.size();i++)\n {\n for(int j=0;j<grid[0].size();j++)\n {\n if(grid[i][j]==1)\n {\n ... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\n /*\n get the min and max values of i and j that appear for a grid ele 1\n find area\n tc : o(m*n)\n */\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n int l1 = grid[0].size();int l2=0;\n int b1 ... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n vector<int> row;\n vector<int> col;\n for(int i=0;i<grid.size();i++){\n for(int j=0;j<grid[0].size();j++){\n if(grid[i][j]==1){\n row.push_back(i);\n ... |
3,461 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. Find a rectangle with horizontal and vertical sides with the<strong> smallest</strong> area, such that all the 1's in <code>grid</code> lie inside this rectangle.</p>
<p>Return the <strong>minimum</strong> possible area of the rectangle.</p>
<... | 3 | {
"code": "class Solution {\npublic:\n int minimumArea(vector<vector<int>>& grid) {\n //Try to store the i and j indexs for grid[i][j] = 1 in these two vector \n vector<int>horizontal_index;\n vector<int>vertical_index;\n \n \n for(int i = 0 ; i< grid.size();i++){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n ios::sync_with_stdio(false);\n int n = nums.size();\n long long p1 = nums[0];\n long long p2 = nums[0];\n for(int i =1; i< n; i++){\n long long p3 = max(p1,p2) + nums[i];\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "auto init = []()\n{ \n ios::sync_with_stdio(0);\n cin.tie(0);\n cout.tie(0);\n return 'c';\n}();\nclass Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n const int n = nums.size();\n\n if (n == 1) {\n return nums[0];\n }\n\n long l... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n long long int sum = 0;\n int n = nums.size();\n vector<vector<long long int>> dp(2,vector<long long>(2,LONG_LONG_MIN));\n dp[0][0] = INT_MIN;\n dp[0][1] = nums[0];\n for(int i=1;i<n;i... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long ff(vector<int> &a,int n,int id,int c,int f,vector<vector<vector<long long>>> &dp){\n if(id>n) return 0;\n if(dp[id][c][f]!=-1) return dp[id][c][f];\n if(c>0){\n if(f){\n return dp[id][c][f]=max(a[id]+ff(a,n,id+1,1,0,dp)... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n = nums.size();\n if (n == 1) return nums[0];\n long long dp[n][2];\n dp[1][0] = nums[0] + nums[1];\n dp[1][1] = nums[0] - nums[1];\n\n for (int i = 2; i < n; i++) {\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n = (int)nums.size();\n long long dp[n][2];\n dp[0][0] = nums[0];\n dp[0][1] = LONG_LONG_MIN;\n\n for(int i=1;i<n;i++) {\n dp[i][1] = dp[i-1][0]-nums[i];\n dp[i][0] ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& a) {\n int n = a.size();\n vector<long long> f(n + 1);\n f[1] = a[0];\n for (int i = 1; i < n; i++) {\n f[i + 1] = max(f[i] + a[i], f[i - 1] + a[i - 1] - a[i]);\n }\n return f[n];\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 0 | {
"code": "#include<bits/stdc++.h>\nusing namespace std;\nclass Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n int n = nums.size();\n vector<long long>dp(n+1,0);\n dp[1] = nums[0];\n\n for(int i = 1; i<n; i++){\n long long op1 = dp[i]+... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n unordered_map<string,long long> dp;\n \n long long recurse(int l, int r, vector<int>& v){ \n if(l>r){\n return 0;\n }\n \n if(l==r){\n return v[l];\n }\n \n if(dp.find(to_string(l)+\" \"+to_str... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "typedef long long ll;\nclass Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n vector<ll> dp{-100000000000000ll, 0};\n for (int i : nums) {\n if (i >= 0) {\n dp[0] = max(dp[0], dp[1]) + i;\n dp[1] = -100000000000000ll;\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "int n;\nvector <int> a;\nlong long dp[100100];\n\nlong long rec(int i){\n if(i==n)\n return 0;\n\n if(dp[i]!=-1)\n return dp[i];\n\n //take this element as it is\n long long ans = a[i]+rec(i+1);\n //take next two elements\n if(i<n-1)\n ans = max(ans, a[i]-a[i+1]+rec(i+2));\n\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "int n;\nvector <int> a;\nlong long dp[100100];\n\nlong long rec(int i){\n if(i==n)\n return 0;\n\n if(dp[i]!=-1)\n return dp[i];\n\n //take this element as it is\n long long ans = a[i]+rec(i+1);\n //take next two elements\n if(i<n-1)\n ans = max(ans, a[i]-a[i+1]+rec(i+2));\n\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "int n;\nvector<long long> dp[2];\nvector<int> a;\n\nlong long recur(int c,int f)\n{\n if(c==n)\n {\n return 0;\n }\n if(dp[f][c]==-1)\n {\n if(f==0)\n return dp[f][c]=max(recur(c+1,0),recur(c+1,1))+a[c];\n else\n return dp[f][c]=recur(c+1,0)+a[c]*(-1);\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& a) {\n int n = a.size() ;\n vector<pair<long long,long long>> dp(n) ;\n dp[n-1] = {a[n-1],-a[n-1]} ;\n\n for(int e=n-2 ;e>=0 ;e--){\n dp[e] = {a[e]+max(dp[e+1].first,dp[e+1].second),-a[e]+dp[e+1].f... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n int n;\n long long dp[100000][2];\n long long f(int i, bool minus, vector<int>& nums){\n if(i == n) return 0;\n if(dp[i][minus] != LONG_MIN) return dp[i][minus];\n long long sum=((!minus)?nums[i]:-1*nums[i])+f(i+1, !minus, nums);\n sum = m... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n#define ll long long \nll dp[100005][3];\nll solve(int indx,int sign,vector<int>&nums){\n if(indx>=nums.size()) return 0;\n if(dp[indx][sign+1] != -1) return dp[indx][sign+1];\n ll take = nums[indx]*sign +solve(indx+1,(sign==1)?(-1):(1),nums);\n ll nottake = nums[indx... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "using ll = long long;\nclass Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n vector<int> vec;\n\n vec.push_back(nums[0]);\n\n for(int i=1; i<nums.size(); i++){\n if(nums[i]==0 && vec.back()==0) continue;\n vec.push_back(nums[i]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "using ll = long long;\nclass Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n vector<int> vec;\n vec.push_back(nums[0]);\n for(int i=1; i<nums.size(); i++){\n if(nums[i]==0 && vec.back()==0) continue;\n vec.push_back(nums[i]);\n... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n long long vis[3][100004];\n int n;vector<int>arr;\n long long recru(int par,int i){\n if(i==n)return 0;\n if(vis[par][i]!=-1)return vis[par][i];\n //not break\n long long nobreak=INT_MIN,yesbreak=INT_MIN;\n if(par==0)nobreak=arr[i]+rec... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "#define ll long long\nclass Solution {\npublic:\n vector<int> nums;\n int n;\n ll dp[100001][2];\n \n ll solve(int index,bool pos){\n if(index==n)\n return 0;\n \n if(dp[index][pos]!=-1)\n return dp[index][pos];\n \n if(pos){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n long long int help(vector<int>&nums,long long int ind, vector<long long int>&dp)\n {\n if(ind>=nums.size())\n return 0;\n if(dp[ind]!=-1)\n return dp[ind];\n if(ind==nums.size()-1)\n {\n return nums[ind];\n }\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n \n vector<long long> dp(n,LLONG_MIN);\n \n dfs(nums,dp,0,n,true);\n \n return dp[0];\n }\n \n long long dfs(vector<int>& nums, vector<long long>& d... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 1 | {
"code": "class Solution {\npublic:\n int n;\n long long func(int ind, vector<long long> &dp, vector<int> &nums){\n if(ind>=n)return 0;\n if(ind == n-1)return nums[n-1];\n if(dp[ind]!=-1)return dp[ind];\n dp[ind] = 1ll*nums[ind]+func(ind+1,dp,nums);\n if(ind+1<n){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n\nlong long dp[100005][2][2];\n\nlong long rec(int i, vector<int>& nums, int start, int sign, int n) {\n if (i == n)\n return 0;\n \n if (dp[i][start][sign] != LLONG_MIN)\n return dp[i][start][sign];\n \n long long ans = LLONG_MIN;\n \n if (star... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n //vector<vector<int>> dp(nums.size(), vector<int>(2,-1));\n vector<long long int> prev(2,0);\n prev[0]=prev[1]=nums[0];\n for(int i=1;i<nums.size();i++){\n vector<long long int> curr(2,0)... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n\n long long dp1(int sign, int n, vector<int>& nums, vector<vector<long long>>& dp, int size){\n if(n==size) return 0;\n if(dp[sign][n]!=-1) return dp[sign][n];\n long long ans = INT_MIN;\n if(sign==1){\n ans = max(ans,-nums[n]+dp1(0,n+1,... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n int n = nums.size();\n vector<vector<long long>> cache_money(2, vector<long long>(n+1, -1));\n auto dp = [&](auto& dp, int i, bool is_pos) -> long long {\n if(i >= n) {\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long util(vector<int>& nums, int ind, bool prev, vector<vector<long long>>& dp) {\n\n if (ind >= nums.size()) {\n return 0;\n }\n\n long long nottake = 0;\n long long take = 0;\n\n if (dp[prev][ind] != -1) {\n retu... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long util(vector<int>& nums, int ind, bool prev, vector<vector<long long>>& dp) {\n\n if (ind >= nums.size()) {\n return 0;\n }\n\n long long nottake = 0;\n long long take = 0;\n\n if (dp[prev][ind] != -1) {\n retu... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n#define ll long long\n ll dp[1000005][3];\n long long solve(int i,int n,int k,vector<int>&nums){\n if(i>=n){\n return 0;\n }\n if(dp[i][k+1]!=-1) return dp[i][k+1];\n ll pick=nums[i]*k+solve(i+1,n,k*(-1),nums);\n ll notPick=num... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n\n\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n vector<vector<long long>>dp(n,vector<long long>(2,INT_MIN));\ndp[0][0]=nums[0];\ndp[0][1]=nums[0];\nfor(int i=1;i<nums.size();i++){\n dp[i][0]=max(nums[i]+dp[i-1][0],nums[i]+dp[i-1][1])... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n #define ll long long int\n long long maximumTotalCost(vector<int>& a) {\n int n = a.size();\n vector<vector<ll>> dp(n+1,vector<ll>(2,0));\n dp[0][0] = a[0];\n dp[0][1] = -1e18;\n for(int i = 1;i<n;i++){\n dp[i][0] = max(dp[i-1]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n //each entry can be taken as is or if it was made negative then previous should be positive\n int n=nums.size();\n vector<vector<long long>> dp(n,vector<long long>(2,0));\n\n dp[0][0]=nums... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n \n // We want to maximize the subarray\n // 1 6 -3 -4 2 -9 -8\n // 1 7 4 6 \n // 0 -5 10 8\n // positive - > individual\n // negative -> 2nd person \n \n //dp[i]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n vector<vector<long long>> dp(n+1, vector<long long>(2, -1e18));\n dp[1][0] = nums[0];\n for(int i=2; i<=n; i++){\n dp[i][0] = nums[i-1] + max(dp[i-1][0], dp[i-1][1]);... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n vector<vector<long long>> dp(nums.size()+1, vector<long long>(2, 0));\n\n for(int i=nums.size()-1 ; i>=0 ; i--) {\n for(int sign=1 ; sign>=0 ; sign--) {\n long long opt1 = nums[i] + dp[i... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n if(n<=0) return 0;\n if(n==1) return nums[0];\n vector<vector<long>>dp(n, vector<long>(2, 0));\n vector<int>curr(2, 0), prev(2, 0);\n dp[0][0]=nums[0];\n dp... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n if(n<=0) return 0;\n if(n==1) return nums[0];\n vector<vector<long>>dp(n, vector<long>(2, 0));\n vector<long>curr(2, 0), prev(2, 0);\n // dp[0][0]=nums[0];\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n#define ll long long\nll f(int i,int c,int n,vector<int>&nums,vector<vector<ll>>&dp){\n if(i>=n)return 0;\n if(dp[i][c]!=-1)return dp[i][c];\n ll int p=0,np=0;\n p=pow(-1,c)*nums[i]+f(i+1,0,n,nums,dp);\n np=pow(-1,c)*nums[i]+f(i+1,1-c,n,nums,dp);\n return dp[i][c]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "#include<bits/stdc++.h>\n#include <climits>\n#undef INT64_MIN\n#define LLONG_MIN -9223372036854775808\nclass Solution {\npublic:\n long long dp[100012][2];\n int n;\n long long r(int b,int i,vector<int>&nums){\n if(i==n)return 0;\n if(dp[i][b]!=LLONG_MIN)return dp[i][b];\n lon... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "typedef long long int;\nclass Solution {\npublic:\n const long long inf=1e18+5;\n long long maximumTotalCost(vector<int>& nums) {\n int n=nums.size();\n vector<int>a=nums;\n // dp[i][par] -> start new par or continue last par\n // start new par\n // dp[i][1]=a[i]+ma... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n vector<vector<long>> dpvalues;\n long long maximumTotalCost(vector<int>& nums) {\n //inner vector to contain flip or not flip\n dpvalues = vector<vector<long>>(nums.size(),vector<long>(2,-1));\n return flipper(0,false,nums); \n }\n //flip ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n\n long long helper(int i, int isStart, int sign, vector<int> &nums, vector<vector<vector<long long>>> &dp){\n\n if(i==nums.size()){\n return 0;\n }\n\n if(dp[isStart][sign][i]!=-1e15){\n return dp[isStart][sign][i];\n }\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\nprivate:\n long long f(int index, int sign, vector<int>& nums, vector<vector<long long>>& dp){\n if(index == nums.size()-1){\n if(nums[index] >= 0) return nums[index];\n else return sign * nums[index];\n }\n\n if(dp[index][sign+1] != -1) retur... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long helper(int i,vector<int>& nums,bool flag,vector<vector<long long>>& dp){\n if(i==nums.size()){\n return 0;\n }\n long long ops1,ops2;\n if(dp[i][flag]!=-1){\n return dp[i][flag];\n }\n if(flag==1){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long f(vector<int> &nums, int i, int l, vector<vector<long long>> &dp){\n if(i==nums.size()) return 0;\n if(dp[i][l] != INT_MIN) return dp[i][l];\n long long np,p;\n if(l){\n p = f(nums,i+1,!l,dp) + nums[i];\n }\n else... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "class Solution {\npublic:\n long long f (int ind, int fl, vector <int> &nums, vector <vector <long long>> &dp){\n if (ind == nums.size()) return 0;\n\n if (dp[ind][fl] != -1) return dp[ind][fl];\n\n long long p = 0, np = 0;\n if (fl){\n p = f (ind + 1, !fl, nums, d... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "#define ll long long\nclass Solution {\npublic:\n ll solve(vector<int> &nums, int i, bool neg, vector<vector<ll>> &dp){ \n if(i >= nums.size())\n return 0;\n\n if(dp[i][neg] != -1e9)\n return dp[i][neg];\n\n ll negTake = -1e8, take = -1e8;\n if(neg){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "int IO = []{\n ios::sync_with_stdio(false); cin.tie(nullptr); return 0;\n}();\n\nclass Solution {\npublic:\n #define ll long long\n ll find(int flag,int curr,int n,vector<int>&nums,vector<vector<ll> > &dp)\n {\n if(curr>=n)\n return 0;\n \n if(dp[curr][flag]!=-1)\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 2 | {
"code": "#define ll long long\nclass Solution {\npublic:\nint n;vector<int>a;\n vector<vector<ll>>dp;\n ll rec(int l,int s){\n if(l==n)return 0;\n auto &ans=dp[l][s];\n if(ans!=-1e14)return ans;\n ans=max((s?a[l]:-a[l])+rec(l+1,1),(s?a[l]:-a[l])+rec(l+1,!s));//new subarray\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n long long solve(int i, int sign, int n, vector<int>& nums, vector<vector<long long>> &dp){\n if(i==n) return 0;\n if(dp[i][sign]!=-1) return dp[i][sign];\n long long a = 0, b=0;\n if(sign==0){\n a = nums[i]+solve(i+1,0,n,nums,dp);\n b ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long solve(int s,int &n,vector<vector<long long>> &dp,vector<int> &v,int k){\n if(s>=n)return 0;\n if(dp[s][k]!=LONG_LONG_MIN)return dp[s][k];\n long long ans1 = LONG_LONG_MIN,ans2 = LONG_LONG_MIN;\n if(k==0){\n ans1 = v[s]+solve(s+... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n#define ll long long\nll f(int i,int c,int n,vector<int>&nums,vector<vector<ll>>&dp){\n if(i>=n)return 0;\n if(dp[i][c]!=-1)return dp[i][c];\n ll int p=0,np=0;\n p=pow(-1,c)*nums[i]+f(i+1,0,n,nums,dp);\n np=pow(-1,c)*nums[i]+f(i+1,1-c,n,nums,dp);\n return dp[i][c]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n private:\n typedef long long ll;\n vector<vector<ll>> dp;\n ll n;\n ll func(vector<int>&nums,int id,int f){\n if(id>=n) return 0;\n if(dp[id][f]!=-1) return dp[id][f];\n ll take = -1e15,ntake = -1e15;\n if(f==1){\n ntake = (-nums[id])+f... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n private:\n typedef long long ll;\n vector<vector<ll>> dp;\n ll n;\n ll func(vector<int>&nums,int id,int f){\n if(id>=n) return 0;\n if(dp[id][f]!=-1) return dp[id][f];\n ll take = -1e15,ntake = -1e15;\n if(f==1){\n ntake = (-nums[id]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n private:\n typedef long long ll;\n vector<vector<ll>> dp;\n ll n;\n ll func(vector<int>&nums,int id,int f){\n if(id>=n) return 0;\n if(dp[id][f]!=-1) return dp[id][f];\n ll take = -1e15,ntake = -1e15;\n if(f==1){\n ntake = (-nums[id]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n private:\n typedef long long ll;\n vector<vector<ll>> dp;\n ll n;\n ll func(vector<int>&nums,int id,int f){\n if(id>=n) return 0;\n if(dp[id][f]!=-1) return dp[id][f];\n ll take = -1e15,ntake = -1e15;\n if(f==1){\n ntake = (-nums[id]... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n typedef long long ll;\n ll n;\n ll dpf(vector<int>&nums,int i,int f,vector<vector<ll>>& dp){\n if(i>=n) return 0;\n if(dp[i][f]!=-1) return dp[i][f];\n\n ll p=INT_MIN,np=INT_MIN;\n\n if(f==1) np=(-nums[i]+dpf(nums,i+1,0,dp));\n\n p=num... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\nint n;\n long long solve(int i,int flag,vector<int>&nums, vector<vector<long long>>&dp){\n if(i==n)return 0;\n if(dp[i][flag+1]!=-1)return dp[i][flag+1];\n long long take=nums[i]*flag+solve(i+1,flag*(-1),nums,dp);\n long long notTake=nums[i]+solve(i... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long recur(int i ,int n,vector<int>&nums,bool take,int sign,vector<vector<long long>>&dp){\n if(i==n)return 0;\n if(dp[i][sign+1]!=-1)return dp[i][sign+1];\n long long x=0;\n \n if(take){\n x+=nums[i]*sign+recur(i+1,n,nums,tr... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\n\n private:\n\n long long solve(int indx , int mul , vector<int>&nums , int n , \n vector<vector<long long>>&dp)\n {\n if(indx >= n)\n return 0;\n\n if(dp[indx][mul + 1] != -1)\n return dp[indx][mul + 1];\n\n long long same = nums[ind... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long ans(int i,int mul,vector<int>& nums,vector<vector<long long>>&dp){\n int n=nums.size();\n if(i==n)\n return 0;\n long long sum=0;\n if(dp[i][mul+1]!=-1)\n return dp[i][mul+1];\n if(mul==1){\n sum+=n... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n unordered_map <int, long long> costs;\n long long helper(int index, vector <int> &nums) {\n if (index == nums.size()) return 0;\n if (index == (nums.size()-1)) return nums[index];\n if (costs.find(index) != costs.end()) {\n return costs[inde... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=ssize(nums);\n\n vector<vector<long long>>dp(n+1,vector<long long>(2,-1));\n function<long long(long long,long long)> f=[&](long long i,long long pow) -> long long {\n if(i==n) {\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long maximumTotalCost(vector<int>& nums) {\n int n=ssize(nums);\n\n vector<vector<long long>>dp(n+1,vector<long long>(2,-1));\n function<long long(long long,long long)> f=[&](long long i,long long pow) -> long long {\n if(i==n) {\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n unordered_map<long long, long long> dp;\n long long f(int idx, vector<int> &nums){\n if(idx == nums.size()){\n return 0;\n }\n if(dp.count(idx)) return dp[idx];\n\n long long take1 = nums[idx] + f(idx + 1, nums);\n long long ta... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "#include <bits/stdc++.h>\n#include <ext/pb_ds/assoc_container.hpp>\nusing namespace __gnu_pbds;\nusing namespace std;\nusing ll=long long;\ntypedef tree <pair<ll,ll>, null_type, less<>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;\n/*\n order_of_key (k)\n find_by_order(k)\n*/\ntemplat... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n vector<vector<vector<long long>>> dp;\n\n long long f(int i, int fresh, int sign, vector<int>& nums){\n if(i == nums.size()) return 0;\n if(dp[i][fresh][sign] != -1e15) return dp[i][fresh][sign];\n long long ans = -1e15;\n if(fresh == 1){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n long long ff(vector<int> &a,int n,int id,int c,int f,vector<vector<vector<long long>>> &dp){\n if(id>n) return 0;\n if(dp[id][c][f]!=-1) return dp[id][c][f];\n if(c>0){\n if(f){\n return dp[id][c][f]=max(a[id]+ff(a,n,id+1,1,0,dp)... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "class Solution {\npublic:\n vector<vector<vector<long long>>> dp;\n\n long long f(int i, int fresh, int sign, vector<int>& nums){\n if(i == nums.size()) return 0;\n if(dp[i][fresh][sign] != -1e15) return dp[i][fresh][sign];\n long long ans = -1e15;\n if(fresh == 1){\n ... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "#define ll long long\n\nclass Solution {\npublic:\n\n vector<vector<vector<ll>>> dp;\n\n ll solve(int i, int isStart, int sign, vector<int> &a){\n\n if(i == a.size()) return 0;\n\n if(dp[i][isStart][sign] != -1e15) return dp[i][isStart][sign];\n\n ll ans = -1e15;\n\n if(is... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "#define ll long long\nclass Solution {\npublic:\n vector<vector<vector<ll>>> dp;\n ll max_sum(int i, int start, int sign, vector<int> &nums){\n if(i==nums.size()){\n return 0 ;\n }\n if(dp[i][start][sign]!= -1e15) return dp[i][start][sign];\n ll ans = -1e15 ;\n... |
3,464 | <p>You are given an integer array <code>nums</code> with length <code>n</code>.</p>
<p>The <strong>cost</strong> of a <span data-keyword="subarray-nonempty">subarray</span> <code>nums[l..r]</code>, where <code>0 <= l <= r < n</code>, is defined as:</p>
<p><code>cost(l, r) = nums[l] - nums[l + 1] + ... + nums... | 3 | {
"code": "typedef long long ll;\nclass Solution {\npublic:\nvector<vector<vector<ll>>>dp;\nll solve(int i,int iss,int sign,vector<int>&nums){\n if(i==nums.size())return 0;\n if(dp[i][iss][sign]!=-1e15)return dp[i][iss][sign];\n ll ans=-1e15;\n if(iss==0){\n ans=max(ans,nums[i]+solve(i+1,1,sign^1,n... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 0 | {
"code": "class Solution {\npublic:\n int minimumSum(vector<vector<int>>& grid) {\n constexpr int INF = std::numeric_limits<int>::max() / 4;\n const int m = static_cast<int>(grid.size()),\n n = static_cast<int>(grid[0].size());\n int result = m * n;\n auto minArea = [&](... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 0 | {
"code": "class Solution {\npublic:\n int findArea(int x1,int y1,int x2,int y2,vector<vector<int>>& grid) {\n int left=y2,right=y1;\n int top=x2,bottom=x1;\n bool flag=false;\n for(int i=x1;i<=x2;i++){\n for(int j=y1;j<=y2;j++){\n if(grid[i][j]==1){\n ... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 0 | {
"code": "class Solution {\npublic:\n vector<vector<int>> m;\n int Calc(int x0,int x1,int y0,int y1)\n {\n int up=x1+1,dn=-1,le=y1+1,ri=-1;\n for(int i=x0;i<=x1;++i)\n {\n for(int j=y0;j<=y1;++j)\n {\n if(m[i][j])\n {\n ... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 0 | {
"code": "class Solution {\npublic:\n long long minimumArea(vector<vector<int>>& grid, int st_i, int en_i, int st_j, int en_j) {\n long long top = -1, bottom = -1, left = -1, right = -1;\n for(int i = st_i; i <= en_i; i++) {\n for(int j = st_j; j <= en_j; j++) {\n if(grid[i... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "class Solution {\npublic:\n int minimumSum(vector<vector<int>>& grid) {\n constexpr int INF = std::numeric_limits<int>::max() / 4;\n const int m = static_cast<int>(grid.size()),\n n = static_cast<int>(grid[0].size());\n int result = m * n;\n auto minArea = [&](... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "static const int __ = [](){\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 0;\n}();\n\nclass Solution {\npublic:\n int minimumSum(vector<vector<int>>& grid) {\n const int m = grid.size(), n = grid[0].size();\n int tl[m][n], tr[m][n], bl[m]... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#define pii pair<int, int>\n#define F first\n#define S second\n\nclass Solution {\n \n vector<vector<int>> grid;\n \n pair<pii, pii> MinRectangle(pii x, pii y) {\n int lft = x.S, rgt = y.S;\n for (; lft <= y.S; lft ++) {\n int one = 0;\n for (int i = x.F; i <... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#define pii pair<int, int>\n#define F first\n#define S second\n\nclass Solution {\n \n vector<vector<int>> grid;\n \n pair<pii, pii> MinRectangle(pii x, pii y) {\n int lft = x.S, rgt = y.S;\n for (; lft <= y.S; lft ++) {\n int one = 0;\n for (int i = x.F; i <... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#define pii pair<int, int>\n#define F first\n#define S second\n\nclass Solution {\n vector<vector<int>> grid;\n pair<pii, pii> MinRectangle(pii x, pii y) {\n int lft = x.S, rgt = y.S;\n for (; lft <= y.S; lft++) {\n int one = 0;\n for (int i = x.F; i <= y.F; i++)\n... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define f(i, start, end) for (int i = start; i < end; i++)\n#define fs(i, start, end, step) for (int i = start; i < end; i = i + step)\n#define fr(i, start, end) for (int i = start; i > end; i--)\n#define all(arr) arr.begin(), arr.end()\n#define vi vector<i... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "class Solution {\n vector<vector<int>> grid;\n pair<pair<int,int>,pair<int,int>> MinRectangle(pair<int,int> x,pair<int,int> y){\n\n int lft = x.second,rgt = y.second;\n for(; lft<=y.second;lft++){\n int one = 0;\n for(int i=x.first;i<=y.first;i++) one += grid[i][l... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#define pii pair<int, int>\n#define F first\n#define S second\n\nclass Solution {\n \n vector<vector<int>> grid;\n \n pair<pii, pii> MinRectangle(pii x, pii y) {\n int lft = x.S, rgt = y.S;\n for (; lft <= y.S; lft ++) {\n int one = 0;\n for (int i = x.F; i <... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "class Solution {\nprivate:\n vector<vector<int>> dp;\n \n int sum1(int i1, int j1, int i2, int j2) {\n int res = dp[i2][j2];\n if (i1 > 0) res -= dp[i1-1][j2];\n if (j1 > 0) res -= dp[i2][j1-1];\n if (i1 > 0 && j1 > 0) res += dp[i1-1][j1-1];\n return res;\n }\... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 2 | {
"code": "#define LOW_BIT(i) __builtin_ctz(i)\n#define HIGH_BIT(i) (31 - __builtin_clz(i))\n\nint speedup = []{ios::sync_with_stdio(0); cin.tie(0); return 0;}();\n\nclass Solution {\npublic:\n int minimumSum(vector<vector<int>>& grid) {\n int rowBits[30], colBits[30]{}, rowArea[30], colArea[30];\n i... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 3 | {
"code": "class Solution {\npublic:\n \n \n std::vector<std::vector<int>> rotate(std::vector<std::vector<int>>& grid) \n {\n const int n = grid.size();\n const int m = grid[0].size();\n \n std::vector<std::vector<int>> res(m, std::vector<int>(n));\n \n for(int i ... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 3 | {
"code": "#include <bits/stdc++.h>\nusing namespace std;\n\n/* Macros {{{ */\n/* A lot of this is from some of Benq's submissions\n [https://codeforces.com/profile/Benq]\n Ugly af to the eyes, but with vim fold its barable\n Hopefully c++20 concepts can make all this stuff must cleaner */\n\n/* Basics {{{ ... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 3 | {
"code": "#include <bits/stdc++.h>\nusing namespace std;\nstatic const int __ = []() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 0;\n}();\n\nstruct TwoDArray {\n size_t row;\n size_t col;\n std::vector<int> data;\n TwoDArray(int r, int c) : row(r), ... |
3,459 | <p>You are given a 2D <strong>binary</strong> array <code>grid</code>. You need to find 3 <strong>non-overlapping</strong> rectangles having <strong>non-zero</strong> areas with horizontal and vertical sides such that all the 1's in <code>grid</code> lie inside these rectangles.</p>
<p>Return the <strong>minimum</... | 3 | {
"code": "// Time: O(max(n, m)^2)\n// Space: O(max(n, m)^2)\n\n// dp\nclass Solution {\npublic:\n int minimumSum(vector<vector<int>>& grid) {\n const auto& cmp = [](int x, int y) {\n return x < y ? -1 : (x > y ? 1 : 0);\n };\n\n const auto& count = [&](int start1, int end1, int st... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.