"<summary> How to use those notebooks</summary>\n",
" \n",
"For each of the following questions:\n",
"- In the `# YOUR CODE HERE` cell, remove `raise NotImplementedError()` to write your code\n",
"- Write an example of use of your code or make sure the given examples and tests pass\n",
"- Add extra tests in the `#Tests` cell\n",
" \n",
"</details>"
]
},
{
"cell_type": "markdown",
"id": "d2673591-dbe2-45f2-b24d-f21ae1186770",
"metadata": {},
"source": [
"## Exercise 1: Fibonacci\n",
"\n",
"Write the Fibonacci sequence $T(n) = T(n-1) + T(n-2)$ using dynamic programming, in particular the _memoization_ mechanism."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a0ca630b-5a69-4e32-8e89-91afaec02c3e",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "14bdfcbc0dce21040b0a18ceb499f6fa",
"grade": false,
"grade_id": "cell-c248cd22cc3ba06b",
"locked": false,
"schema_version": 3,
"solution": true,
"task": false
},
"tags": []
},
"outputs": [],
"source": [
"def fibonacci(n, memo = {}):\n",
" # YOUR CODE HERE\n",
" raise NotImplementedError()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c7baa400-bd44-4e35-a3cc-1d44e1711af5",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Example of use\n",
"fibonacci(10)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3b629a14-7c08-49e1-8cce-8ad320066eec",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# Tests\n",
"assert fibonacci(10) == 55"
]
},
{
"cell_type": "markdown",
"id": "a45c7015-d59b-4ab3-96f7-d5eaf26273fc",
"metadata": {},
"source": [
"## Exercise 2: Knapsack\n",
"\n",
"Propose a dynamic programming solution for the knapsack problem (as defined in the previous lab). Here is the general case (where the weights availability is 1, which means there can be any duplicate in the solution):\n",
"\n",
"$\n",
"dp[i][w] = \n",
"\\begin{cases}\n",
"0 & \\text{if } i = 0 \\text{ or } w = 0 \\\\\n",
"Given an array of integers, write a function to find the length of the longest increasing subsequence. For intance, given the sequence `[10, 9, 2, 5, 3, 7, 101, 18]` the result is `[2, 3, 7, 101]` (size `4`). Note that the increasing numbers are not necessarily immediately consecutive."
]
},
{
"cell_type": "markdown",
"id": "341924a7-5e56-4ead-8fb0-921cb7edf935",
"metadata": {},
"source": [
"Write a dynamic programming approach by following those steps:\n",
"\n",
"1. Create a `dp` array of size \\(n\\), where \\(dp[i]\\) represents the length of the longest incresing sequence ending at index \\(i\\)\n",
"2. Initialize all values in `dp` to 1, since the longest incresing sequence at each index is at least the element itself\n",
"3. For each pair of indices \\(i\\) and \\(j\\) where \\(j < i\\):\n",
"4. The length of the longest increasing sequence is the maximum value in the `dp` array"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e09b072d-78f3-4ce1-9203-c85cf0e464ae",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "f8e8fb911dc852a5217bd2927101c4ce",
"grade": false,
"grade_id": "cell-1b6f016aceaf66f0",
"locked": false,
"schema_version": 3,
"solution": true,
"task": false
},
"tags": []
},
"outputs": [],
"source": [
"def longest_dynprog(L):\n",
" # YOUR CODE HERE\n",
" raise NotImplementedError()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8d29b1e7-d541-4363-94cf-e928944d019f",
"metadata": {},
"outputs": [],
"source": [
"L = [10, 9, 2, 5, 3, 7, 101, 18]\n",
"assert longest_dynprog(L) == 4"
]
},
{
"cell_type": "markdown",
"id": "358e492b-9a9b-499f-a49b-6a90c530b0fa",
"metadata": {
"tags": []
},
"source": [
"Finally, you may implement a more efficient solution using binary search like explained [in this book](https://cp-algorithms.com/sequences/longest_increasing_subsequence.html).\n",
"Now write a function that uses the above binary search function to return the longest sequence:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "418a8882-8d04-4ef6-9718-307a4056d800",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "8dd94e438931ebb199550c584ab97802",
"grade": false,
"grade_id": "cell-1dea7220610c9dcb",
"locked": false,
"schema_version": 3,
"solution": true,
"task": false
},
"tags": []
},
"outputs": [],
"source": [
"def longest_binary(L):\n",
" # YOUR CODE HERE\n",
" raise NotImplementedError()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b6b27c2b-5758-496c-975b-a732e71d1791",
"metadata": {},
"outputs": [],
"source": [
"L = [10, 9, 2, 5, 3, 7, 101, 18]\n",
"assert longest_binary(nums) == 4\n"
]
},
{
"cell_type": "markdown",
"id": "46eedf29-dac1-4373-9f2c-98275cd749b2",
"metadata": {},
"source": [
"## Exercise 4: Find a target sum\n",
"\n",
"You are given a list of integers `L` and a target sum `t`. You need to return the number of different ways you can assign a + or - sign to each number in the list such that the sum equals target.\n",
"\n",
"\n",
"```\n",
"L = [1, 1, 1, 1, 1]\n",
"t = 3\n",
"```\n",
"\n",
"There are 5 possible solutions (`[1, 1, -1, 1, 1]`, etc)."
]
},
{
"cell_type": "markdown",
"id": "89555ffc-d9b1-4386-a278-4a583dca2bdc",
"metadata": {
"tags": []
},
"source": [
"Generate a brute force approach like in the previous lab by using the `product` method."
"Now write a dynamic programming solution by following the instructions below:\n",
"\n",
"Before proceeding, check for two conditions that would make it impossible to achieve the target:\n",
"\n",
"1. If the total sum \\( s \\) is less than the target, it's impossible to form a subset equal to the target\n",
"2. If \\( s - target \\) is odd, you cannot split the array into two subsets with integer sums that have the required difference\n",
"\n",
"Next, initialize a dynamic programming (dp) array of size \\( n + 1 \\) with all values set to zero, except for `dp[0]`, which is set to 1. This means there is one way to achieve a sum of zero (by choosing no number).\n",
"\n",
"Then, iterate through each number \\( v \\) in `L`. For each number, iterate backward through the dp array from \\( n \\) down to \\( v \\) to avoid recomputing values that rely on the current index. This ensures that we don't count the same combination more than once.\n",
"\n",
"Update the dp array by adding the number of ways to achieve a sum of \\( j \\) without including the current number \\( v \\) (i.e., `dp[j - v]`). This accumulates the number of ways to form a sum of \\( j \\) by either including or excluding the current number \\( v \\)."
Propose a dynamic programming solution for the knapsack problem (as defined in the previous lab). Here is the general case (where the weights availability is 1, which means there can be any duplicate in the solution):
Given an array of integers, write a function to find the length of the longest increasing subsequence. For intance, given the sequence `[10, 9, 2, 5, 3, 7, 101, 18]` the result is `[2, 3, 7, 101]` (size `4`). Note that the increasing numbers are not necessarily immediately consecutive.
Finally, you may implement a more efficient solution using binary search like explained [in this book](https://cp-algorithms.com/sequences/longest_increasing_subsequence.html).
You are given a list of integers `L` and a target sum `t`. You need to return the number of different ways you can assign a + or - sign to each number in the list such that the sum equals target.
```
L = [1, 1, 1, 1, 1]
t = 3
```
There are 5 possible solutions (`[1, 1, -1, 1, 1]`, etc).
Now write a dynamic programming solution by following the instructions below:
Before proceeding, check for two conditions that would make it impossible to achieve the target:
1. If the total sum \( s \) is less than the target, it's impossible to form a subset equal to the target
2. If \( s - target \) is odd, you cannot split the array into two subsets with integer sums that have the required difference
Next, initialize a dynamic programming (dp) array of size \( n + 1 \) with all values set to zero, except for `dp[0]`, which is set to 1. This means there is one way to achieve a sum of zero (by choosing no number).
Then, iterate through each number \( v \) in `L`. For each number, iterate backward through the dp array from \( n \) down to \( v \) to avoid recomputing values that rely on the current index. This ensures that we don't count the same combination more than once.
Update the dp array by adding the number of ways to achieve a sum of \( j \) without including the current number \( v \) (i.e., `dp[j - v]`). This accumulates the number of ways to form a sum of \( j \) by either including or excluding the current number \( v \).
