## Step-by-step Guides to reach Dynamic Programming Solution The following are ste

Step-by-step Guides to reach Dynamic Programming Solution
The following are step-by-step guides to finish this lab. Answer all questions in red in this document, and modify/extend the code as instructed. In the end, submit this document on Blackboard, and the coin_change.cpp on autograder.
Compile and run the starter code first, and understand the solutions given for UnlimitedCoinChange( ).
To investigate whether dynamic programming can be used to improve its performance, we check if it has two characteristics: overlapping optimal substructure and overlapping subproblems. (Ref: CLR textbook, see the RodCuttingExplained reading posted on the weekly schedule page).
* Optimal substructure refers to the fact that (optimal) solutions to a problem incorporate (optimal) solutions to related subproblems, which we may solve independently. Another way to put it is that the problem has a recursive solution.
Can you write a formula for the mv, which denotes the minimum number of coins required to make value v with the given set of coins? If v cannot be expressed with the set of coins, mv is infinite.
* Overlapping subproblem: Add cout statement to the function, to display a line such as the following whenever the function is called:
UnlimitedCoinChange (value=14) called
Compile and run your program, and note all instances where UnlimitedCoinChange is called to solve a problem multiple times (a.k.a., overlapping subproblems) below:
What are the overlapping subproblems you found?
2. To avoid recomputing overlapping subproblems, we will use a table to store subproblem solutions.
Analyze the UnlimitedCoinChange( ) function, as an algorithm, what are its input and output? Which input parameter(s) are not changed, and which input parameters are varying during the recursive calls?
int UnlimitedCoinChange (const vector & coins, int value)
b. Design the table to use following the guideline:
The table used by dynamic programming provides a lookup: given a subproblem’s input, it tells us the subproblem’s solution.
We typically use array or vector, where the index is the subproblem’s input, and the value of the array/vector element is the subproblem solution.
vector subProblemSolutions; //subProblemSolutions[i] tells us the minimum number of coins that we can make value=i with; if a certain value cannot be expressed with the coins, its entry should be set to INT_MAX
Draw the subProblemSolution table used for UnlimitedCoinChange(…, value=31,..) below. Show the size of the table, what’s stored in the table entry. Note that you don’t need to fill in the table’s entries, just illustrate using an example or two.
vector coins{3, 5, 6, 10};
3. Tabulation version:
Write a new function, unlimitedCoinChange_Tabulation() that solves the problem using the tabulation approach. The following is the pseudocode:
//Return the minimum number of coins we need to use to make the given @value, assuming there are unlimited supplies for each type of coins given by @coins.
int UnlimitedCoinChange_Tabulation (const vector & coins, int value)
{
//1. Declare the table (see step 2 above)
//2. Based upon the base cases from UnlimitedCoinChange, fill out the initial entries of the table
//3. Write a for loop to solve all problems, from smallest (1) to largest (value)
For (int cur_v=2; cur_v<=value; cur_v++)
{ // solve subproblem cur_v, and store the solution in the table
//Note: use the optimal substructure found in step 1
}
//4. Return solution stored in table for @value
}
4. Develop a Memoization approach following the instruction below
Write a wrapper function, in which we declare and initialize the table, and then call the recursive function
Int UnlimitedCoinChange_Wrapper (const & coins, int value)
{
//1. Declare and initialize all entries to -1, meaning all problems are not yet solved
//2. Call memoized recursive solution, and return what’s returned by the function
}
Extend UnlimitedCoinChange to the following memoized version:
int UnlimitedCoinChange_Memoized (const vector & coins, int value, vector & subProblemSolutions)
Note that to memoized a recursive function, do the following:
At the entry to the function, check the table to see the current problem has been solved before or not. If so, return the table entry; if not, proceed.
At the exit point of the function (i.e., before each return statement), stores the result in the table.
5. How are the optimal solutions achieved?
Now, consider how to extend dynamic programming solutions above so that we not only report a) The minimum number of coins required, but also b) the coins used to make a given value.
a). In pure recursive solution given, this is done by taking best subproblem solution and append to it the branch that leads to the subproblem (the i-th coin)
//General case of UnlimitedCoinChange
int curMin = INT_MAX; //we don't have a solution yet
//used to save “current subproblem solution”
vector curBest;
int curSol;
for (int i=0;i coins{3, 5, 6, 10};
1). Only draw two levels of the tree (root node, and its child nodes).
2). Label what’s returned by each child node (both the int value, and the value of curBest vector)
Note: you don’t need to trace each recursive call to the base case.
3). Follow logic of the above general case, to find out what’s returned by the root.
4). Mark which branch of the root node yields the best solution
b).(Extra Credit) In Dynamic Programming, we just store the current option (the branch in the decision tree) taken at each subproblem in a second table:
vector subProblemSolution; //as before
vector firstCoinUsed; //which branch (as in recursion solution) leads to optimal solution?
The second table provides a lookup: for a value to make it maps to the first coin to use (that leads to an optimal solution eventually) in the decision tree.
Based upon your work in step a) above, show the content of subProblemCoinUsed, I.e., what’s the first coin to use in the decision tree that leads to optimal solution?
c). (Extra Credit) Extend your memorized solution so that the subProblemCoinUsed table is used to store all “first coin” used.
int UnlimitedCoinChange_WrapperExtended (const & coins, int value)
{
//1. Declare and initialize both tables: all entries to -1, meaning all problems are not yet solved
//2. Call memoized recursive solution, and return what’s returned by the function
//3. Use the firstCoinUsed table to output all coins used
}
int UnlimitedCoinChange_MemoizedExtended (const vector & coins, int value, vector & subProblemSolutions, vector & firstCoinUsed)

## Assignment 3 2D Array Manipulation (Console Program) Due Date: 4/12/2022 midnigh

Assignment 3
2D Array Manipulation (Console Program)
Due Date: 4/12/2022 midnight
The purpose of
this program is to write a series of function to manipulate a two-dimension
array.
ArrayData method: It will allocate a
block of memory which represents a two-dimension array based on the input
values supplied by the user. Ask the
user to enter the number of rows and column for 2D array that the user want to
manipulate. The number of rows and
columns that the user enters may or may not define a square matrix (when the
number of rows equals the number of columns).
The array will have exactly rows time columns (m * n) elements. It will not contain any extra or empty cells. Initialize the “matrix” by rows with random
number between 1 to 100. Pass two
arguments by out reference so that you can assign the number of row and columns
of data to the first and second arguments. This is return 2D array method after
allocating new memory for 2D array and initialize it with random value. Generate random number code in C# as
following: Random randNum
= new Random( );
int num = randNum.Next
(1, 101);
SwapRow method: it will rotate
the data in the matrix in an up/down method such that the first row is
exchanged with last row (swap row 0 and row m-1, swap row 1 and row m-2, etc.).
SwapColumn method:
it
will rotate the data in the matrix in a left/right method such that the first
column is exchanged with the last column (swap column 0 and column n-1, swap
column1 and column n-2, etc.)
RotateLeftDiagonal
method:
it will rotate the data in the matrix by the left diagonal. This operation is usually referred to as a matrix
transpose. This is done by exchanging
element [i, j] with element [j, i]. The
values on the left diagonal do not move for a square matrix. Do not forget to swap the values for the
number of rows and columns. Pass these
two arguments by reference so that you can change their values.
RotateRightDiagonal
method:
it will rotate the data in the matrix by the right diagonal. This operation will require that you exchange
element [0, 0] with element [m-1, n-1].
The values on the right diagonal do not move for a square matrix. Do not forget to swap the values of the
number of rows and columns. Pass these
two arguments by reference so that you can change their values.
DisplayArray
method:
it will print the array in a two-dimension format with rows and columns as you
would normally print a compile time defined two-dimension array. Be sure that the columns are aligned
correctly for display purposes.
Use type integer
(int) for the array. In the main, program
call methods in following order: ArrayData, SwapRow, SwapColumn, RotateLeftDiagonal,
RotateRightDiagonal. After each method
has been called you must print the matrix, which is calling DisplayArray
method, and pause the program so that the result of the operation can be
viewed. After the results of the
operation of 4 methods has been printed, then continue running the program
until the user want to quit. Clearly
label each matrix with the operation that was performed on the matrix.
// IST 211 A3 note:
Main():
1. Declare variable for two-dimension array, row, colums
Example: int[,] twoDarray;
2. Use do…while to run the program until the user want to stop.
Example:
do
{
….
}while (condition check)
3. call ArrayData method with return two-dimension array.
Example: twoDarray = ArrayData(out int row, out int col);
4. write proper messge for print array data.
Example: “The Original Two Dimension Array Data:”
5. Call DisplayArray method to print two-dimension array data
Example: PrintArray(twoDarray, rows, columns);
6. Pause the program:
7. Call SwapRow method to flip the rows upside down.
Example: SwapRow(twoDarray, rows, columns);
8. Repeat step 4 ~ step 6
9. Call SwapColumn method to flip the column lef to right.
Example: SwapColumn(twoDrray, rows, columns);
10. Repeat step 4 ~ step 6
11. Call RotatsLeftDiagnoal method with return new two-dimension array.
Example: twoDarray = RotateLeftDiagnoal(twoDarray, ref rows, ref columns);
12. Repeat step 4 ~ step 6
}
Methods:
ArrayData Method:
static in[,] ArrayDate(out int row, out int col)
{
1. This method will ask the user to enter row and column size
for the two-dimension array.
2. Declared two-dimension array with the user input row size and olumn size.
3. Initialized two-dimension array data with random number between 1 to 100.
Single-dimension array with random number initialization example:
Random randNum = new Random();
int[] array = new int[size];
for(int x = 0; x < array.Length; ++x)
{
array[x] = randNum.next(1, 101); // random number is between 1 and 100
}
4. return two-dimension array
}
DisplayArray method:
static void DisplayArray(int[,] array, int row, int col)
{
print array data with two-dimension table like format
your need to figure out when to write("n"); statement in two-dimension array
when each row finished.
Example for single-dimension array:
for(int x = 0; x [1, 0] [1, 1] [1, 2]
7 8 9 [2, 0] [2, 1] [2, 2]
leftDiagonal
1 4 7 [0, 0] [1, 0] [2, 0]
2 5 8 => [0, 1] [1, 1] [2, 1]
3 6 9 [0, 2] [1, 2] [2, 2]
temp = array[i];
array[i] = array[i+1];
array[i+1] = temp;
RotateRightDiagonal method:
static int[,] RotateRightDiagonal(int[,] array, ref int row, ref int col)
{
1. check row size is same as column size, if their are not equal then
swap row size column size.
2. create new two-dimension array with current row and column.
(if their are same size, you do not need to create new two-dimension array.)
3. This operation will require that you exhange row and column element [0, 0] with
new array element [m-1, n-1]. The values on the right diagonal do not move for
a square array.
4. return new two-dimension array.
}

## Learning Goal: I’m working on a c++ project and need an explanation and answer t

Learning Goal: I’m working on a c++ project and need an explanation and answer to help me learn.Write a Program using any one or combination of the following:Array
Vector