More practice problems

Author: AustinTSchaffer

OMSCS/Courses/GA/Practice Problems/6.2 - Hotel Stops.md

@@ -78,7 +78,7 @@ So for each hotel $A_i$, you need to calculate the penalty of stopping at that h
 - Is there a risk with using a greedy algorithm? You want to travel exactly 200 miles in a day. Sometimes it might be worth stopping early for a larger penalty to avoid a bigger penalty later. Does the math check out? The penalty is the distance squared.
 - Making the algorithm $n^2$ seems to account for possible greediness.
 
-$P(i)=min\{(200-A_i)^2,\frac{min}{0 \le j \lt i}\{P(j)+(200-(A_i-A_j))^2\}\}$
+$P(i)=min\bigg\{(200-A_i)^2,min\space\Big\{P(j)+\big(200-A_i+A_j\big)^2:0 \le j \lt i\Big\}\bigg\}$
 
 ## Code
 ```python

OMSCS/Courses/GA/Practice Problems/6.3 - Yuck Donald's.md

@@ -7,3 +7,76 @@ tags:
 # 6.3 - Yuck Donald's
 ![[Pasted image 20260114125811.png]]
 
+- Inputs:
+	- $\{M=m_1,m_2,...,m_n\}$
+		- An increasing sequence of positive integers indicating positions along QVH which can accept the placement of a single YD.
+		- Likely excludes $m_0=0$, the start of QVH, which doesn't support the placement of a YD on its own. That would require $m_1=0$.
+	- $\{P=p_1,p_2,...,p_n\}$ A sequence of profits, where $p_i$ is the expected profit for opening a YD at location $m_i$.
+	- $k$ - A positive integer indicating the minimum distance between YD locations. This is set by corporate, as part of the franchisee agreement.
+- Outputs:
+	- The max expected profit.
+	- The list of indices of M/P 
+
+## Step 1: Define the Subproblem in Words
+```
+Given
+	a list of mile-markers "M" of length n
+	a list of expected profits "P" of length n
+	an integer "k"
+for i=1 -> n
+
+TP(i) = the total max profit of the subsequence of YD locations in (m_1, p_1), ..., (m_i, p_i) which includes (m_i, p_i)
+```
+
+This definition is sloppy, but will probably work.
+
+## Step 2: Define the Recurrence Relation
+This is similar to [[6.2 - Hotel Stops]], in fact, I'm seeing now why the instructor said that practicing DP algorithms was important. 99% of the trick is "make sure that the subproblem you're solving always includes the last element in the input."
+
+- Base case, the total max profit for a given mile-marker $M(i)$ is just the potential profit of that mile-marker $P(i)$, assuming that no prior YD's can be built before it.
+- Assuming that there are mile-markers $M(j:1 \le j<i)$ with values at least $k$ less than $M(i)$, we need to take the maximum of $TP(j) + P(i)$, wrt the current best $P(i)$ (including the base-case).
+- If we initialize $TP$ to $P$, we can omit the outer $max$.
+$TP(i)=max\space \bigg\{P(i), \space max \space \Big\{ TP(j) + P(i) : \big(1 \le j \lt i\big) \text{ and } \big(M(i) \ge M(j) + k \big)\Big\} \bigg\}$
+## Code 
+```python
+def yuck_donalds_optimization(
+    mile_markers: tuple[int, ...],
+    expected_profits: tuple[int, ...],
+    min_distance_between: int,
+):
+    # Start by calculating the potential profits for opening only a single
+    # YD at each mile marker
+    potential_profits = [p for p in expected_profits]
+
+    # Keeps track of the index of the preceeding mile-marker that contains
+    # a YD location, allowing for an efficient reconstruction of the list
+    # of YD locations. -1 indicates mile-marker 0, which cannot inherently
+    # contain a YD location (unless MM_0 happens to be 0).
+    previous_yd_location = [-1 for _ in mile_markers]
+
+    max_profit = 0
+    max_profix_idx = -1
+
+    # Determine the maximum profit of opening a YD at 
+    for i in range(len(mile_markers)):
+        for j in range(i):
+            if (mile_markers[i] - min_distance_between) < mile_markers[j]:
+                break
+
+            potential_profit_i = potential_profits[j] + expected_profits[i]
+            if potential_profits[i] < potential_profit_i:
+                potential_profits[i] = potential_profit_i
+                previous_yd_location[i] = j
+
+        if potential_profits[i] > max_profit:
+            max_profit = potential_profits[i]
+            max_profix_idx = i
+
+    # Reconstruct the route.
+    yd_indices = [max_profix_idx]
+    while previous_yd_location[yd_indices[0]] != -1:
+        yd_indices.insert(0, previous_yd_location[yd_indices[0]])
+
+    return max_profit, yd_indices
+
+```

OMSCS/Courses/GA/Practice Problems/6.4 - String of Words.md

@@ -5,3 +5,114 @@ tags:
   - Practice
 ---
 # 6.4 - String of Words
+![[Pasted image 20260116141341.png]]
+
+## Exploration
+First, we need some examples. Specifically we need an example which will help identify how the DP algorithm performs backtracking. This will occur in cases where a word that is identified earlier needs to be broken up to form
+
+1. one whole word, and the beginning of the next word
+2. two or more whole words
+3. two or more whole words, and the beginning of the next word
+
+For case 2, this algorithm doesn't seek to identify grammatically correct sentences, just strings of whole words that exist in a given dictionary. Therefore, case 2 won't actually result in any backtracking.
+
+If we don't have such an example, then we may accidentally develop a greedy $O(n)$ algorithm, which runs forward collecting letters into the longest word available in the dictionary.
+
+### Greedy Algorithm Failure Example
+To avoid coming up with an example which uses real words, let's review this contrived one.
+
+- $dict(w)=w \in \{a, ab, bc\}$
+- $S=abc$
+
+In this example, a greedy forward-only DP algorithm with no backtracking would find the following substrings. How do we force $s(3)$ to find $T,\{a, bc\}$? In addition to $s(2)=T,\{ab\}$, we would also need to keep track of $s(2)=F,\{a,b\}$.
+
+- $s(1)=T,\{a\}$
+- $s(2)=T,\{ab\}$
+- $s(3)=F,\{ab,c\} \leftarrow \text{error}$
+
+### Ambiguity Example
+Note that there is possible ambiguity for a given dictionary and substring. In this contrived example below, there are many possible input word strings that can construct the given $S$.
+
+- $dict(w)=w \in \{a, b, c, d, ab, bc, cd, abc, bcd, abcd\}$
+- $S=abcdabcdabcd$
+
+Sample of possible results:
+- $\{a,b,c,d,a,b,c,d,a,b,c,d\}$
+- $\{ab,cd,ab,cd,ab,cd\}$
+- $\{abcd,abcd,abcd\}$
+- $\{abc,d,a,bcd,abcd\}$
+- $\{abc,d,a,bcd,ab,cd\}$
+- $\{a,b,c,d,abcd,abc,d\}$
+- ...
+
+This problem only asks whether a given string "can be reconstituted as a series of valid words." This allows for the solution to be less complicated, though it's likely possible to construct an algorithm which returns all possible results while staying within a DP solution space.
+
+## Step 1: Define the Subproblem in Words
+```
+Given
+	a function dict(S') which returns T or F for arbitrary length S'
+	a sequence of characters S of length n
+
+for i=1 -> n:
+	for j=1 -> i:
+		VS(i,j) contains T or F, indicating whether S_1, ..., S_j contains valid word strings.
+```
+
+Why does this need to be 2D? What am I using $i$ for? Let's simplify (I found an example solution online.)
+
+```
+Given
+	a sequence of characters S of length n
+	a function dict(S'), which returns T or F for arbitrary lengh contiguous subsequence (i.e. substring) S' of S
+
+for i=1 -> n:
+	VS(i) returns T or F, indicating whether S_1, ..., S_i only contains sequential valid word strings.
+	P(i) returns the ending index of the prior word.
+```
+
+## Step 2: Define the Recurrence Relation
+For $VS(i)$, we need to find a previous index $0\lt j \lt i$ for which there are only valid words ($VS(j)=True$). For convenience and completeness, we can assert that $VS(0)=True$, because an empty string contains no _invalid_ words. Then we need to check $dict(\{s_{j+1},\space ... \space,s_i\})$. If $True$, $VS(i)=T$ and $P(i)=j$. If there is no $j$ for which $dict(s_{j+1},\space ... \space, s_i)$, then $VS(i)=False$.
+
+It's unclear to me how you would convert this into a clean mathematical expression. Anyway, here's the code.
+## Code
+This code models `is_in_dict` as a function which takes $S$, along with the starting and ending indexes of a given substring. This allows for the dictionary to be modeled as a trie, or some other graph structure, as opposed to a hash-table with non-guaranteed $O(1)$ lookup performance. Even with guaranteed $O(1)$ lookup performance, you still need to build substrings from each given range.
+
+```python
+import typing
+
+character = int | str
+string = list[character] | tuple[character]
+
+def string_of_words(
+    S: string,
+    is_in_dict: typing.Callable[[string, int, int], bool]
+) -> tuple[bool, list[string] | None]:
+    VS: list[bool] = [False for _ in S]
+    P: list[int] = [-1 for _ in S]
+
+    for i in range(len(S)):
+        # Iterating j forward will tend to find longer words.
+        # Iterating j in reverse will tend to find shorter words.
+        # If we want to find all possible strings of words, we probably
+        # need to use 2D "VS" and "P" arrays.
+        for j in range(-1, i):
+            if j == -1 or VS[j]:
+                if is_in_dict(S, j+1, i):
+                    VS[i] = True
+                    P[i] = j
+                    break
+
+    if not VS[-1]:
+        return False, None
+
+    sentence: list[string] = []
+    current_end = len(P)
+    previous_end = P[-1]
+    while True:
+        sentence.insert(0, list(S[previous_end+1:current_end]))
+        current_end = previous_end+1
+        if previous_end == -1:
+            return True, sentence
+        previous_end = P[previous_end]
+
+```