# Solution For Construct The Lexicographically Largest Valid Sequence

Problem statement:

Given an integer n, find a sequence that satisfies all of the following constraints:

1. The integer 1 occurs once in the sequence.
2. Each integer between 2 and n occurs twice in the sequence.
3. For every integer i between 2 and n, the distance between the two occurrences of i is exactly i.
4. The sequence is lexicographically largest.

Return the lexicographically largest valid sequence. It is guaranteed that under the given constraints, there is always a valid sequence.

Solution:

To construct the lexicographically largest valid sequence, we can start with the largest numbers and work our way down. We can start with the largest number n and place it in the first position. Then, we can place the next largest number n-1 in the position that is i+d, where i is the current position and d is the distance required by the problem (which is i itself). Then we can place n-2 in the next position, and so on. In this way, we can construct a valid sequence that is also lexicographically largest.

Here is a step-by-step algorithm to solve this problem:

1. Create an empty result array of size 2n-1.
2. Initialize the first element of the result array to 1.
3. Initialize two pointers l and r to 0 and 1 respectively.
4. For each number i from n to 2, do the following:
a. If i is even, set result[r+i-1] = i, result[l+i-1] = i-1.
b. If i is odd, set result[r+i-1] = i-1, result[l+i-1] = i.
c. Increment l by i-1 and r by i.
5. Return the result array.

Explanation:

We start with the number n and place it in the first position (i.e., result = n). Then, we need to place the number n-1 at a distance of 2 from the current position. Since the distance required is i itself (i.e., 2), we can place n-1 at index 1, which is i-1 away from the current position. Similarly, we can place n-2 at a distance of 3 from the current position, n-3 at a distance of 4, and so on. We keep track of two pointers l and r, which represent the left and right ends of the current sequence. By incrementing l by i-1 and r by i, we are ensuring that the next pair of values (i.e., i-1 and i) are placed at the required distance from each other.

For example, let’s say n=5. We start with the first element as 5 (i.e., result=5). Then, we need to place 4 and 3 at a distance of 2 and 3 respectively from the first element. Therefore, we can place 4 at index 1 (i.e., result=4) and 3 at index 4 (i.e., result=3). Similarly, we can place 2 and 1 at indices 2 and 6 respectively.

The resulting array would be [5,4,2,3,1,4,5], which satisfies all the constraints of the problem and is also the lexicographically largest sequence possible.

Time Complexity:

The time complexity of the above algorithm is O(n), since we are iterating over all numbers from n to 2 and performing constant time operations inside the loop. Therefore, the algorithm is efficient and can handle large values of n without any issues.

## Step by Step Implementation For Construct The Lexicographically Largest Valid Sequence

```public class Solution {
public String largestValidSequence(String s) {
StringBuilder sb = new StringBuilder();
int open = 0, close = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(') {
open++;
} else {
close++;
}
if (open == close) {
sb.append(s.substring(0, i + 1));
sb.append(largestValidSequence(s.substring(i + 1)));
break;
} else if (open < close) {
return "";
}
}
return sb.toString();
}
}```
```Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies:

Si % Sj = 0 or Sj % Si = 0.

If there are multiple solutions, return any subset is fine.

def largestDivisibleSubset(self, nums):
if not nums: return []
nums.sort()
dp = [[num] for num in nums]
for i in range(len(nums)):
for j in range(i):
if nums[i] % nums[j] == 0 and len(dp[i]) < len(dp[j]) + 1:
dp[i] = dp[j] + [nums[i]]
return max(dp, key = len)```
```var constructLargest = function(s) {
// sort the string in reverse order
var sorted = s.split('').sort((a, b) => b.charCodeAt(0) - a.charCodeAt(0));

// initialize our stack and result string
var stack = [];
var result = '';

// iterate through the sorted string
for (var i = 0; i < sorted.length; i++) {
// if the current character is less than the last character in the stack
// we pop it off and add it to the result string
if (sorted[i] < stack[stack.length - 1]) {
result += stack.pop();
}
// otherwise, we push the current character onto the stack
else {
stack.push(sorted[i]);
}
}

// return the result string + the remaining characters in the stack
// (in reverse order)
return result + stack.reverse().join('');
};```
```The following is a C++ solution for the leetcode problem construct-the-lexicographically-largest-valid-sequence:

#include
#include
#include

using namespace std;

string constructLargestValidSequence(string s) {
// sort the string in reverse lexicographical order
sort(s.rbegin(), s.rend());

// initialize an empty string to store the largest valid sequence
string largestValidSeq = "";

// go through each character in the sorted string
for (char c : s) {
// if the character is a '(', we need to find its corresponding ')'
if (c == '(') {
// search for the first ')' after the current '(',
// and if found, add the two parentheses to the largest valid sequence
int pos = s.find(')', largestValidSeq.size());
if (pos != string::npos) {
largestValidSeq += c;
largestValidSeq += s[pos];
}
}
// if the character is a ')', we can simply ignore it
else if (c == ')') {
continue;
}
// otherwise, we can add the character to the largest valid sequence
else {
largestValidSeq += c;
}
}

return largestValidSeq;
}

int main() {
string s = "()(()(((";
cout << constructLargestValidSequence(s) << endl;
return 0;
}```
```Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies:

Si % Sj = 0 or Sj % Si = 0.

If there are multiple solutions, return any subset is fine.

class Solution {
public IList LargestDivisibleSubset(int[] nums) {
// sort the array first
Array.Sort(nums);

// create an array to track the length of the largest divisible subset at each index
int[] dp = new int[nums.Length];

// create an array to track the index of the previous element in the largest divisible subset at each index
int[] prev = new int[nums.Length];

// initialize the first element in both arrays
dp = 1;
prev = -1;

// track the overall largest divisible subset
int maxIndex = 0;
int max = 1;

// iterate through the array, starting at the second element
for (int i = 1; i < nums.Length; i++) {
// iterate through all previous elements
for (int j = 0; j < i; j++) {
// check if the current element is divisible by the previous element
if (nums[i] % nums[j] == 0 && dp[j] + 1 > dp[i]) {
// update the length of the largest divisible subset at the current index
dp[i] = dp[j] + 1;

// update the index of the previous element in the largest divisible subset at the current index
prev[i] = j;
}
}

// check if the current largest divisible subset is larger than the overall largest divisible subset
if (dp[i] > max) {
// update the overall largest divisible subset
max = dp[i];
maxIndex = i;
}
}

// create a list to store the elements in the overall largest divisible subset
List result = new List();

// iterate through the overall largest divisible subset, starting at the last element
while (maxIndex != -1) {
// add the current element to the list

// move to the previous element in the subset
maxIndex = prev[maxIndex];
}

// return the list of elements in the overall largest divisible subset
return result;
}
}```

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]