https://trayimurti.github.io/lcc/blog LCC Blog 2022-01-25T00:00:00.000Z https://github.com/jpmonette/feed LCC Blog https://trayimurti.github.io/lcc/img/favicon.ico <![CDATA[IOITC Day-1 Part-3]]> ioitc-day-1-part-3 2022-01-25T00:00:00.000Z Let's increase problem level further.

Problem​

Given a grid of integers L = [[A1,1, A1,2, A1,3, ..., A1,M], [A2,1, A2,1, A2,3, ..., A2,M], [A3,1, A3,2, A3,3, ..., A3,M], [..., ..., ..., ..., ...], [AN,1, AN,2, AN,3, ..., AN,M]]. Where Ai,j ≥ 0, 0 ≤ i ≤ N, 0 ≤ j ≤ M. You have to find the least perimeter of rectangle which adds up to a given integer K.

For example, If L = [[1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [1, 0, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 2], [1, 0, 0, 0, 0]] and K = 3, the answer would be 22, rectangles will be {(2, 3), (4, 4)}.

Rectangle Solution

Solution​

The first approach that comes to mind is calculating 2D prefix sum, and then finding the least perimeter rectangular field adding up to K. Calculating 2D prefix sum will take O(N⋅M)\cal{O}(N \cdot M) time. But, if we find rectangle adding up to K by taking every possible rectangle then it will take O(X)\cal{O}(X) time, where X = Number of possible rectangles. Let's calculate X. We will choose two indices of length, and two vertices of width, which will form a rectangle. Number of ways to choose two indices of length is (N2)N \choose 2 and of width is (M2)M \choose 2.

X=(N2)⋅(M2)X = {N \choose 2} \cdot {M \choose 2}
=N⋅(N+1)2⋅M⋅(M+1)2= \frac{N\cdot(N+1)}{2} \cdot \frac{M\cdot(M+1)}{2}
=(N2+N)⋅(M2+M)4= \frac{(N^2 + N)\cdot(M^2 + M)}{4}
X=N2⋅M2+N2⋅M+M2⋅N+M⋅N4X = \frac{N^2 \cdot M^2+N^2 \cdot M+M^2 \cdot N+M \cdot N}{4}

We can see that overall time complexity is O(N2⋅M2).\cal{O}(N^2 \cdot M^2). Can we optimize it? ... Yes, by using sliding window algorithm on 2D array. But, how we will apply sliding window algorithm on a 2D array?

For using sliding window algorithm, we have chosen two indices from either row or column as shown below and apply sliding window with fixed row or column.

Fix row and column

Using sliding window for a fixed rows or columns will take O(N)\cal{O}(N) or O(M)\cal{O}(M) time complexity accordingly. As we have to repeat it for others fixed rows or columns also. Which will result in O(N⋅M2)\cal{O}(N \cdot M^2) or O(M⋅N2)\cal{O}(M \cdot N^2) time complexity.

Sliding Window GIF

Code​

#include <bits/stdc++.h>
using namespace std;

#define INF INT_MAX

pair<int,int> ans[2];

void slidingWindow(vector<vector<int>>& l, int n, int m, int k){
    int st = -1,en = -1,perimeter = INF;
    vector<vector<int>> prefixL(n+1,vector<int>(m+1));
    for(int i=0;i<=n;i++)   prefixL[i][0] = 0;
    for(int j=0;j<=m;j++)   prefixL[0][j] = 0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            prefixL[i][j] = (l[i-1][j-1] + prefixL[i-1][j] + prefixL[i][j-1] - prefixL[i-1][j-1]);
    for(int i=0;i<n;i++){
        for(int j=i;j<n;j++){
            st = 0;en = 0;
            int cnt = prefixL[j+1][1] - prefixL[j+1][0] - prefixL[i][1] + prefixL[i][0];
            for(;k<m;){
                if(cnt > k){
                    if(st == en){   st++;en++;}
                    else            st++;
                }else if(cnt < k){
                    en++;
                }else{
                    while(prefixL[j+1][st+1] - prefixL[j+1][st] - prefixL[i][st+1] + prefixL[i][st] == 0)
                        st++;
                    if(perimeter > 2*((j-i+1)+(en-st+1))){
                        perimeter = 2*((j-i+1)+(en-st+1));
                        ans[0].first = i;ans[0].second = st;
                        ans[1].first = j;ans[0].second = en;
                    }
                    en++;
                }
                if(en == m) break;
                cnt = prefixL[j+1][en+1] - prefixL[j+1][st] - prefixL[i][en+1] + prefixL[i][st];
            }
        }
    }
}

int main() {
    int n,m,k;
    cin >> n >> m >> k;
    vector<vector<int>> l(n,vector<int>(m));
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin >> l[i][j];
    slidingWindow(l,n,m,k);
    cout << ans[0].first << " " << ans[0].second << endl
         << ans[1].first << " " << ans[1].second;
}

Problem : IOI, Garden, 2005​

Question summary:​

A rose garden in rectangular form is l meters long and w meters wide. We have to fence two rectangular fences inside the garden such that both are disjoint and the sum of their perimeter is minimal. So, we have to just output the sum of perimeter of those rectangles.

Solution​

We will divide the rectangle vertically and find both side rectangle with minimum perimeter. Doing this will ensure that rectangles are disjoint. Repeat the process now by dividing the rectangle horizontally. We have already discussed the process to find the rectangles with sum equals to K. So, how exactly we are going to find the minimum perimeter rectangle within the range?

To find the minimum perimeter rectangle in the range, we will have to take four arrays, two of size N (for rows) and two of size M (for columns).

Code​

#include <bits/stdc++.h>
using namespace std;

#define INF 10000000

int slidingWindow(vector<vector<int>>& roseGarden, int n, int m, int k){
    int st = -1,en = -1,perimeter = INF;
    vector<vector<int>> prefixL(n+1,vector<int>(m+1));
    vector<int> rowSt(n, INF), rowEn(n, INF), colSt(m, INF), colEn(m, INF);
    for(int i=0;i<=n;i++)   prefixL[i][0] = 0;
    for(int j=0;j<=m;j++)   prefixL[0][j] = 0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            prefixL[i][j] = (roseGarden[i-1][j-1] + prefixL[i-1][j] + prefixL[i][j-1] - prefixL[i-1][j-1]);
    for(int i=0;i<n;i++){
        for(int j=i;j<n;j++){
            st = 0;en = 0;
            int cnt = prefixL[j+1][1] - prefixL[j+1][0] - prefixL[i][1] + prefixL[i][0];
            for(;en < m;){
                if(cnt > k){
                    if(st == en){   st++;en++;}
                    else            st++;
                }else if(cnt < k){
                    en++;
                }else{
                    while(st < en && ((prefixL[j+1][st+1] + prefixL[i][st]) == (prefixL[j+1][st] + prefixL[i][st+1])))
                        st++;
                    perimeter = 2*((j-i+1)+(en-st+1));
                    rowSt[j] = min(rowSt[j], perimeter);
                    rowEn[i] = min(rowEn[i], perimeter);
                    colSt[en] = min(colSt[en], perimeter);
                    colEn[st] = min(colEn[st], perimeter);
                    en++;
                }
                if(en >= m) break;
                cnt = (prefixL[j+1][en+1] + prefixL[i][st]) - (prefixL[j+1][st] + prefixL[i][en+1]);
            }
        }
    }
    for(int i=1;i<n;i++)
        rowSt[i] = min(rowSt[i], rowSt[i-1]);
    for(int i=n-2;i>=0;i--)
        rowEn[i] = min(rowEn[i], rowEn[i+1]);
    for(int j=1;j<m;j++)
        colSt[j] = min(colSt[j], colSt[j-1]);
    for(int j=m-2;j>=0;j--)
        colEn[j] = min(colEn[j], colEn[j+1]);
    int ans = INF;
    for(int i=1;i<n;i++)
        ans = min(ans, rowSt[i-1] + rowEn[i]);
    for(int j=1;j<m;j++)
        ans = min(ans, colSt[j-1] + colEn[j]);
    return ans;
}

int main() {
    int l,w,n,k;
    cin >> l >> w
        >> n >> k;
    vector<vector<int>> roseGarden(l,vector<int>(w, 0));
    int x,y;
    while(n--){
        cin >> x >> y;
        x--;y--;
        roseGarden[x][y]++;
    }
    int ans = slidingWindow(roseGarden,l,w,k);
    if(ans == INF)  cout << "NO\n";
    else            cout << ans;
    return 0;
}
]]> Trayi Murti https://github.com/trayimurti <![CDATA[IOITC Day-1 Part-2]]> ioitc-day-1-part-2 2022-01-24T00:00:00.000Z So, What if the numbers can also be negative?

We can't use sliding window algorithm then. First we will compute prefix sum and then sort it with their respective index (sort them as {prefixL[i],i}). Then we will apply binary search on it for every index i to look for an element whose index j is greater than index i and whose value is equal to prefixL[i] + K. This will take O(n⋅log⁡(n))\cal{O}(n \cdot \log(n)) time.

Problem​

Given a list of integers L = [A1, A2, A3, …, AN]. Where Ai ∈ I, 0 ≤ i ≤ N. You have to find the shortest contiguous segment in the list which adds up to a given integer K. If there are more than one such segments, print one of them.

For example, If L = [2, 1, 10, 1, 3, -4, -2, 20, 5, 5, 5, 1, 1] and K = 17, the answer would be {4, 7}.

Code​

struct keycompare {
   bool operator()(const pair<int, int>& v, const int& k) {
      return (v.first < k);
   }
   bool operator()(const int& k, const pair<int, int>& v) {
      return (k < v.first);
   }
};

pair<int,int> prefixSum(vector<int> l, int n, int k){
    int st,en,len = INF;
    vector<pair<int,int>> prefixL(n+1);
    prefixL[0].first = 0;
    prefixL[0].second = 0;
    for(int i=0;i<n;i++){
        prefixL[i+1].first = prefixL[i].first + l[i];
        prefixL[i+1].second = i+1;
    }
    for(int i=0;i<n;i++){
        int x = lower_bound(prefixL.begin(), prefixL.end(), prefixL[i].first + k, keycompare()) - prefixL.begin();
        if(x <= n && prefixL[x].first == prefixL[i].first + k && x-i < len && prefixL[x].second > prefixL[i].second){
            len = x-i;
            en = x-1;
            st = i;
        }
    }
    return {st,en};
}

Let's make the problem even more interesting.

Problem​

Given a list of integers L = [A1, A2, A3, …, AN]. Where Ai ≥ 0, 0 ≤ i ≤ N. You have to find a pair of the shortest disjoint contiguous segment in the list each adding up to a given integer K and sum of size of segment is minimum. If there are more than one such pair of segments, print one of such pair.

For example, If L = [2, 1, 3, 1, 4, 4, 1, 8, 1, 7] and K = 9, the answer would be {{3, 5}, {6, 7}}.

Solution​

Note that pairs of segments have to be disjoint. So, we can't simply say that the segments with least size will be the answer. Even in the given example {6, 7} and {7, 8} are two least size segments, but they have a common index which doesn't follow the condition of being disjoint. Then, what should we do?

Let us take an index i, for each i we will find the least size segment in range [0, i] and (i, N). Doing this will ensure that the segments are disjoint. As far as searching segment in the ranges concerned, we can find them by applying sliding window algorithm from both the sides.

Code​

void slidingWindow(vector<int> l, int n, int k){
    int st = -1,en = -1,len = INF;
    vector<pair<int,int>> s1(n,{-1,-1}),s2(n,{-1,-1});
    int sum = l[0];
    // sliding window from front
    for(int i=0,j=0;i<n && j<n;){
        s1[j] = {st, en};
        if(sum < k){
            j++;
            if(j < n)   sum += l[j];
            else        break;
            
        }else if(sum > k){
            sum -= l[i];
            if(i < j)   i++;
            else{
                i++;
                j++;
                sum += l[j];
            }
        }else{
            if(j-i+1 < len){
                st = i;
                en = j;
                len = j-i+1;
            }
            j++;
            s1[j] = {st, en};
            if(j < n)   sum += l[j];
            else        break;
        }
    }
    sum = l[n-1];
    len = INF;
    st = -1;en = -1;
    // sliding window from end
    for(int i=n-1,j=n-1;i>=0 && j>=0;){
        s2[i] = {st, en};
        if(sum < k){
            i--;
            if(i >= 0)   sum += l[i];
            else        break;
            
        }else if(sum > k){
            sum -= l[j];
            if(i < j)   j--;
            else{
                i--;
                j--;
                sum += l[i];
            }
        }else{
            if(j-i+1 < len){
                st = i;
                en = j;
                len = j-i+1;
            }
            s2[i] = {st, en};
            i--;
            if(i >= 0)   sum += l[i];
            else        break;
        }
    }
    len = INF;
    for(int i=0;i<n-1;i++){
        if(s1[i].first != -1 && s2[i+1].first != -1){
            if(((s1[i].second + s2[i+1].second + 2) - (s1[i].first + s2[i+1].first)) < len){
                ans[0] = s1[i];
                ans[1] = s2[i+1];
            }
        }
    }
}
]]> Trayi Murti https://github.com/trayimurti <![CDATA[IOITC Day-1 Part-1]]> ioitc-day-1-part-1 2022-01-23T00:00:00.000Z Let us start with a problem

Problem​

Given a list of integers L = [A1, A2, A3, …, AN]. Where Ai ≥ 0, 0 ≤ i ≤ N. You have to find the shortest contiguous segment in the list which adds up to a given integer K. If there are more than one such segment, print one of them.

For example, If L = [2, 1, 3, 1, 4, 4, 1, 8, 1, 7] and K = 9, the answer would be {6, 7}.

By Naive Approach​

Find every possible segment and sum up elements present in it. This will have O(n2)\cal{O}(n^2) time complexity.

Code​

pair<int,int> naive(vector<int> l, int n, int k){
    int st,en,len = INF;
    for(int i=0;i<n;i++){
        int sum = 0;
        for(int j=i;j<n;j++){
            sum += l[j];
            if(sum == k && j-i+1 < len){
                len = j-i+1;
                st = i;
                en = j;
                break;
            }
            if(sum > k){
                break;
            }
        }
    }
    return {st,en};
}

Can we do better?

By Prefix Sum​

Compute the prefix sum of array L into another array prefixL (make sure to add an extra element "0" before the list) , for every index i in prefixL, search if an element exists with value prefixL[i] + K and return the indices of the segment with minimum length. We can search for elements with the help of Binary Search, which will take O(log⁡(n))\cal{O}(\log(n)) time. So, overall it will have O(n⋅log⁡(n))\cal{O}(n \cdot \log(n)) time complexity.

Code​

pair<int,int> prefixSum(vector<int> l, int n, int k){
    int st,en,len = INF;
    vector<int> prefixL(n+1);
    prefixL[0] = 0;
    for(int i=0;i<n;i++)
        prefixL[i+1] = prefixL[i] + l[i];
    for(int i=0;i<n;i++){
        int x = lower_bound(prefixL.begin(), prefixL.end(), prefixL[i] + k) - prefixL.begin();
        if(x <= n && prefixL[x] == prefixL[i] + k && x-i < len){
            len = x-i;
            en = x-1;
            st = i;
        }
    }
    return {st,en};
}

Can we still do better?

By Sliding Window Algorithm​

As the name suggests, we will use two vectors i and j to point at starting and ending elements of the segment respectively. If the current sum of the segment is less than K then increase the index j and include the element in the sum. If the current sum of the segment is greater than K then increase the index i and exclude the from the sum. When the current segment sum is equal to K, store the indices if the segment length is less than the previous one. As the array is iterated once, So, time complexity will be O(n)\cal{O}(n).

Code​

pair<int,int> slidingWindow(vector<int> l, int n, int k){
    int st,en,len = INF;
    int sum = l[0];
    for(int i=0,j=0;i<n && j<n;){
        if(sum < k){
            j++;
            if(j < n)   sum += l[j];
            else        break;
        }else if(sum > k){
            sum -= l[i];
            if(i < j)   i++;
            else{
                j++;
                sum += l[j];
            }
        }else{
            if(j-i+1 < len){
                st = i;
                en = j;
                len = j-i+1;
            }
            j++;
            if(j < n)   sum += l[j];
            else        break;
        }
    }
    return {st,en};
}
Note

Some conditions were added in the code to ensure that i ≤ j and j < n.

What if the numbers can also be negative?

]]> Trayi Murti https://github.com/trayimurti <![CDATA[Welcome]]> welcome 2022-01-23T00:00:00.000Z This blog contains things which are different from straight data structures and algorithms, but useful for others.

LCC (Learn . Code . Contribute) is a website that helps coders to achieve their goal.

]]> Trayi Murti https://github.com/trayimurti