Imag$$ne that you are head of test$$ng department of a software house. In your department, there are several testing staff who design test$-$cases for different software modules. A module holds some $n$ number of lines of code and each test case may cover some of the code lines of the module.

For example, let our very simple module contains $10$ lines of code $($i$.$e$.n=10)$ and we have $k=6$ number of different test cases prepared for the testing the module. Table $1$ shows an example line numbers covered by each of $6$ different example test cases.

Table $1.$ Example test$-$case IDs and their code line coverage information.

$\backslash$table$[[$Test$-$Case,Covered Line Numbers$],[$T$\_(1),\{3,4,6,8\}],[$T$\_(2),\{1,2,4,9,10\}],[$T$\_(3),\{5,6,8,10\}],[$T$\_(4),\{2,5,8,9\}],[$T$\_(5),\{1,4,6,7,9,10\}],[$T$\_(6),\{1,2,3,5,8\}]]$

As the head of the testing department, you wish to minimize the number of applied test cases per

module in order to save testing time. On the other hand, the selected minimum number of test

cases among $k$ alternatives are required to cover all the lines of module under test together in

order to not to risk some of the module lines not being tested. In other words, the selected

minimum number of test cases should cover all the code lines of the module collectively. For

example for the above problem instance, you have to select the test cases $T_5$ and $T_6$ that covers all the $10$ module lines together. In your solution, assume that each line of the module under test

is covered by at least one test case.

In order to solve the problem, you decide to develop a software tool that uses Transform &

Conquer algorithm design technique. According to the approach, first you need to convert given

problem instance into an Integer Linear Programming $($ILP$)$ problem then solve the constructed ILP

problem by using a back$-$end solver $($namely IBM$-$Cplex Solver$)$ on the fly. Finally, display the

obtained result in a meaningful way. See Figure $1$ below.

Figure $1.$ A simple architectural view for your test case selection software.

SAMPLE INPUT:

$10//$ Number of lines of code of the module

$6//$ Number of test cases

$3468//$ Covered lines by test case number #$1$

$124910//$ Covered lines by test case number #$2$

$56810//$ Covered lines by test case number #$3$

$2589//$ Covered lines by test case number #$4$

$1467910//$ Covered lines by test case number #$5$

$12358//$ Covered lines by test case number #$6$

SAMPLE OUTPUT:

IDs of the minimum number of selected test cases that covers all the module lines: $56$

question part

Assume that we modify the above test case selection problem by introducing a cost value associated with each test case. Our new goal is to decide on minimum total cost subset that still covers all the module statements. This time, you are required to propose and implement an efficient greedy algorithm that solves the modified problem directly without any transformation as above.

Your bonus submission should include the following pieces:

i$.$ A report that explains your greedy choice$/$strategy$.$ Also, line by line cost analysis of your algorithm and its measured time complexity.

ii$.$ Source code of your greedy algorithm implementation.