Counting Distinct Arrays by Removal and Concatenation of Elements
Last Updated :
29 Feb, 2024
Given an array arr[] of length N, the task is to create an array res[] of length N where each element res[i] represents the count of distinct arrays obtained by applying the below operation on prefix arr[1, i] for (1 <= i <= N):
- Select three distinct indices let say i1, i2 and i3 such that (1 <= i1 < i2 < i3 <= i) and arr[i1] > arr[i2] < arr[i3]. Remove arr[i2] and concatenate the remaining elements without changing the order.
Note: Number of distinct arrays can be very large. Therefore, output it in modulo 998244353.
Examples:
Input: N = 4, arr[] = {4, 1, 3, 2}
Output: res[] = {1, 1, 2, 2}
Explanation: There are four possible prefixes are there for arr[], which are {4}, {4, 1}, {4, 1, 3} and {4, 1, 3, 2} respectively. Let us apply the given operation on each prefix then:
- 1st Prefix: arr[1, 1] = {4}
- As we need at least three indices to perform operations. Therefore, we can’t perform operation on this prefix. Distinct number of arrays for prefix arr[1, 1] is 1. Which is {4} itself.
- 2nd Prefix: arr[1, 2] = {4, 1}
- As we need at least three indices to perform operations. Therefore, we can’t perform operation on this prefix. Distinct number of arrays for prefix arr[1, 2] is 1. Which is {4, 1} itself.
- 3rd Prefix: arr[1, 3] = {4, 1, 3}
- Select i1, i2 and i3 as 1, 2 and 3 respectively. Then the condition of (1 <= i1 < i2 < i3 <= i) and arr[i1] > arr[i2] <a rr[i3] holds true for arr[1, 3] as (4 > 1 < 3). Therefore, remove arr[i2] = 1 and concatenate the remaining array, which will be {4, 3}. As no further operation can be applied on {4, 3}. Therefore, the distinct arrays that can be obtained by prefix arr[1, 3] are 2, {4, 1, 3} and {4, 3} respectively.
- 4th Prefix: arr[1, 4] = {4, 1, 3, 2}
- Select i1, i2 and i3 as 1, 2 and 3 respectively. Then the condition of (1 <= i1 < i2 < i3 <= i) and arr[i1] > arr[i2] < arr[i3] holds true for arr[1, 4] as (4 > 1 < 3). Therefore, remove arr[i2] = 1 and concatenate the remaining array, which will be {4, 3, 2}. As no further operation can be applied on {4, 3, 2}. Therefore, the distinct arrays that can be obtained by prefix arr[1, 4] are 2, {4, 1, 3, 2} and {4, 3, 2} respectively.
Total number of distinct arrays by each prefix are 1, 1, 2 and 2 respectively. Which stored in res[] as {1, 1, 2, 2}.
Input: N = 6, arr[] = {1, 2, 3, 4, 5, 6}
Output: res[] = {1, 1, 1, 1, 1, 1}
Explanation: It can be verified that for each prefix there will be only one distinct array, which will be the prefix itself.
Approach: Implement the idea below to solve the problem:
The problem is observation based. It must be noted that an element in the array can only be removed if it has both a previous and a next greater element. So, for each prefix of the array, we count the number of elements that meet this condition and calculate the number of distinct arrays that can be generated as 2 to the power of this count. This is because each of these elements can either be included or excluded from the array, giving us 2 choices for each element. The total number of distinct arrays is then the product of these choices for all elements.
So the approach boils down to finding the Next Greater and Previous Greater element for each index of arr[]. After that just keep finding number of elements let say X which have both next greater and previous greater within the current range. For each prefix, the result is simple 2X where X is number of such elements.
Steps-by-step approach:
- Initialize an array let say h
ave[] of size N to store the count of elements which have both a next greater and a previous greater element within the current range. Along with this initialize a counter variable let say Count.
- Declare two arrays let say Prev[] and Next[] and initialize both of them with -1s.
- Then calculate previous greater and next greater element for each element of arr[] in Prev[] and Next[] respectively.
- Run a loop for i = 0 to i < N and follow below mentioned steps:
- If (Prev[i] != -1 && Next[i] != -1)
- Count += Have[i]
- Output Power(2, Count).
Below is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;
const int mod = 998244353;
void Find_Distinct_Arrays(int N, vector<int>& arr);
vector<int> PrevGreater(const vector<int>& arr);
vector<int> NextGreater(const vector<int>& arr);
int binpow(int x, int y);
int main()
{
int N = 4;
vector<int> arr = { 3, 1, 4, 2 };
Find_Distinct_Arrays(N, arr);
return 0;
}
void Find_Distinct_Arrays(int N, vector<int>& arr)
{
vector<int> have(N, 0);
int cnt = 0;
vector<int> prev = PrevGreater(arr);
vector<int> next = NextGreater(arr);
for (int i = 0; i < N; i++) {
if (prev[i] != -1 && next[i] != -1) {
have[next[i]]++;
}
cnt += have[i];
cout << binpow(2, cnt) << " ";
}
}
vector<int> PrevGreater(const vector<int>& arr)
{
int N = arr.size();
stack<int> s;
vector<int> prev(N, -1);
for (int i = 0; i < N; i++) {
while (!s.empty() && arr[s.top()] < arr[i]) {
s.pop();
}
if (!s.empty()) {
prev[i] = s.top();
}
s.push(i);
}
return prev;
}
vector<int> NextGreater(const vector<int>& arr)
{
int N = arr.size();
stack<int> s;
vector<int> next(N, -1);
for (int i = N - 1; i >= 0; i--) {
while (!s.empty() && arr[s.top()] < arr[i]) {
s.pop();
}
if (!s.empty()) {
next[i] = s.top();
}
s.push(i);
}
return next;
}
int binpow(int x, int y)
{
int res = 1;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
|
Java
import java.io.*;
import java.util.*;
public class Main {
static int mod = 998244353;
public static void main(String[] args)
throws IOException
{
int N = 4;
int[] arr = { 3, 1, 4, 2 };
Find_Distinct_Arrays(N, arr);
}
public static void Find_Distinct_Arrays(int N,
int[] arr)
{
int[] have = new int[N];
int cnt = 0;
int[] prev = PrevGreater(arr);
int[] next = NextGreater(arr);
for (int i = 0; i < N; i++) {
if (prev[i] != -1 && next[i] != -1) {
have[next[i]]++;
}
cnt += have[i];
System.out.print(binpow(2, cnt) + " ");
}
}
public static int[] PrevGreater(int[] arr)
{
int N = arr.length;
Stack<Integer> s = new Stack<>();
int[] prev = new int[N];
Arrays.fill(prev, -1);
for (int i = 0; i < N; i++) {
while (!s.isEmpty() && arr[s.peek()] < arr[i]) {
s.pop();
}
if (!s.isEmpty()) {
prev[i] = s.peek();
}
s.push(i);
}
return prev;
}
public static int[] NextGreater(int[] arr)
{
int N = arr.length;
Stack<Integer> s = new Stack<>();
int[] next = new int[N];
Arrays.fill(next, -1);
for (int i = N - 1; i >= 0; i--) {
while (!s.isEmpty() && arr[s.peek()] < arr[i]) {
s.pop();
}
if (!s.isEmpty()) {
next[i] = s.peek();
}
s.push(i);
}
return next;
}
static int binpow(int x, int y)
{
int res = 1;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
}
|
Python
from __future__ import print_function
def find_distinct_arrays(N, arr):
have = [0] * N
cnt = 0
prev = prev_greater(arr)
next = next_greater(arr)
for i in range(N):
if prev[i] != -1 and next[i] != -1:
have[next[i]] += 1
cnt += have[i]
print(binpow(2, cnt) % 998244353),
def prev_greater(arr):
N = len(arr)
s = []
prev = [-1] * N
for i in range(N):
while s and arr[s[-1]] < arr[i]:
s.pop()
if s:
prev[i] = s[-1]
s.append(i)
return prev
def next_greater(arr):
N = len(arr)
s = []
next = [-1] * N
for i in range(N - 1, -1, -1):
while s and arr[s[-1]] < arr[i]:
s.pop()
if s:
next[i] = s[-1]
s.append(i)
return next
def binpow(x, y):
res = 1
while y > 0:
if y % 2 == 1:
res = (res * x) % 998244353
y //= 2
x = (x * x) % 998244353
return res
if __name__ == "__main__":
N = 4
arr = [3, 1, 4, 2]
find_distinct_arrays(N, arr)
|
C#
using System;
using System.Collections.Generic;
class Program
{
static int mod = 998244353;
static void Main()
{
int N = 4;
int[] arr = { 3, 1, 4, 2 };
FindDistinctArrays(N, arr);
}
static void FindDistinctArrays(int N, int[] arr)
{
int[] have = new int[N];
int cnt = 0;
int[] prev = PrevGreater(arr);
int[] next = NextGreater(arr);
for (int i = 0; i < N; i++)
{
if (prev[i] != -1 && next[i] != -1)
{
have[next[i]]++;
}
cnt += have[i];
Console.Write(BinPow(2, cnt) + " ");
}
}
static int[] PrevGreater(int[] arr)
{
int N = arr.Length;
Stack<int> s = new Stack<int>();
int[] prev = new int[N];
for (int i = 0; i < N; i++)
{
prev[i] = -1;
}
for (int i = 0; i < N; i++)
{
while (s.Count > 0 && arr[s.Peek()] < arr[i])
{
s.Pop();
}
if (s.Count > 0)
{
prev[i] = s.Peek();
}
s.Push(i);
}
return prev;
}
static int[] NextGreater(int[] arr)
{
int N = arr.Length;
Stack<int> s = new Stack<int>();
int[] next = new int[N];
for (int i = 0; i < N; i++)
{
next[i] = -1;
}
for (int i = N - 1; i >= 0; i--)
{
while (s.Count > 0 && arr[s.Peek()] < arr[i])
{
s.Pop();
}
if (s.Count > 0)
{
next[i] = s.Peek();
}
s.Push(i);
}
return next;
}
static int BinPow(int x, int y)
{
int res = 1;
while (y > 0)
{
if (y % 2 == 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
}
|
Javascript
function prevGreater(arr) {
const N = arr.length;
const prev = new Array(N).fill(-1);
const stack = [];
for (let i = 0; i < N; i++) {
while (stack.length && arr[stack[stack.length - 1]] < arr[i]) {
stack.pop();
}
if (stack.length) {
prev[i] = stack[stack.length - 1];
}
stack.push(i);
}
return prev;
}
function nextGreater(arr) {
const N = arr.length;
const next = new Array(N).fill(-1);
const stack = [];
for (let i = N - 1; i >= 0; i--) {
while (stack.length && arr[stack[stack.length - 1]] < arr[i]) {
stack.pop();
}
if (stack.length) {
next[i] = stack[stack.length - 1];
}
stack.push(i);
}
return next;
}
function binpow(x, y) {
let res = 1;
while (y > 0) {
if (y % 2 === 1) {
res = (res * x) % 998244353;
}
y = Math.floor(y / 2);
x = (x * x) % 998244353;
}
return res;
}
function findDistinctArrays(N, arr) {
const have = new Array(N).fill(0);
let cnt = 0;
const prev = prevGreater(arr);
const next = nextGreater(arr);
for (let i = 0; i < N; i++) {
if (prev[i] !== -1 && next[i] !== -1) {
have[next[i]] += 1;
}
cnt += have[i];
process.stdout.write(`${binpow(2, cnt) % 998244353} `);
}
}
const N = 4;
const arr = [3, 1, 4, 2];
findDistinctArrays(N, arr);
|
Time Complexity: O(N log N)
Auxiliary Space: O(N), As Stack and Prev[] and Next[] Arrays are used of Size N.
Share your thoughts in the comments
Please Login to comment...