---------------------------------------------------------
Alex. Gerbessiotis  CS 610 FALL   2025  EXAM 2 SOLKEY
(c) All rights reserved.      OCTOBER      2025.
---------------------------------------------------------
PROBLEM 1:  FALSE, FALSE, FALSE, FALSE,  TRUE, TRUE, TRUE, TRUE
PROBLEM 2                                 PROBLEM 3
---------                                 ---------
Part of the grade is writing down         Theta,Theta,omega,omega
T,C with the appropriate parameter.                   
1 T(n)=Theta(nlgn)                        PROBLEM 4
2 T(n)= O(n**2(lgn)**2)                   ------------
3 T(n)=O(n)                               1. Theta(n**3 )           
4 T(n)=Theta(n*lgn)                       2. Theta(n! )
                                          3. Theta(n (lgn)**2)
                                          4. Theta(n * lgn )
                                          PROBLEM 5
                                          ---------
                                          T(n) = 6nlgn - 10n.
PROBLEM 6
---------
   TTACG GGTTT WAACG GTTAA WTACA   ASCII Bits=25*8=200bits  (i.e. 25B)
  T=8 , A = 7 C = 3, G=5, W =2
              25
             /   \          Huffman bits
           10     \         = 2*3+3*3+5*2+7*2+8*2 = 55 bits  (in 7B)
          /  \     \
         5    \     15      We got from 200 down to 55 bits: savings 73%
        /  \   \    /  \    (or we got from 25B down to 7B : savings 72% .)
      W:2 C:3 G:5 A:7  T:8
      000 001  01 10   11

PROBLEM 7  
--------------------------------------------------------------------
We first perform a BinarySearch of all keys of $A$ into $B$ just
to count the number $d$ intersections i.e. keys $k$ such that 
$k \in A \cap B$.  This determines the cardinality $d$ of 
$D$ and the space for $D$ is  allocated. Obviously $d\leq n$.
We repeat the BinSearch to fill $D$ with the intersection $A \cap B$.
BinSearch returns a NOTFOUND(-1) or the index of the key in B that
is equal to $A[i]$. To avoid a 'third' BinSearch in line 6 we store
the index of the BinSearch of line 6 in variable indx; note that
in line 4 we reset $d=0$ and we use it as an index of D to fill D.
  Inter(A,B,n)
1. d=0; i=0;indx=0;
2. for(i=0;i<n;i++)
3.  if BinSearch(A[i],B)!=-1 d++;
4. D=allocate-d-space-for-D;      d=0;
5. for(i=0;i<n;i++)
6.  if ((indx=BinSearch(A[i],B))!=-1) D[d++]= B[indx];
7. return(D);


The running time of lines 1-3 is $O(n * \lg{(2**n)}) = O(n**2)$.
This is because we do a binary search over $A$ that has $n$
elements and on $B$ that has $2^n -1$ elements; thus the
BinSearch on $B$ is of time $O( \lg{(2^n -1 +1)} = O(n)$.
Likewise for the running time of lines 5-6. Line 4 is $Theta(|D|)$,
and $|D|$, the cardinality of $D$ is no more than $n$, the number
of elements of the smaller of the two sets i.e. $A$.


The algorithm is space efficient because we generate as 
much space for $D$ as needed and no more, and beyond that we 
use $THeta(1)$ space for variables d,i,indx. 
(We could save the space of indx but is not worthwhile though
as space asymptotics do not change.)
Space usage is $S(n)=|D|+Theta(1)$.

Note that D is at most A. Thus we could return D in A
as well; it will look a bit ugly and the statement of
the problem explicitly states D.

PROBLEM 8 
-------------------------------------------------------------------
Because it is a MaxHeap  prior to the operation, we need to 
make sure after the operation it is ALSO a MaxHeap.
The old value is A[i] but after the operation it will become v.
v can be smaller or larger than A[i] (original prior to the operation
value).
If $v>A[i]$
the larger value $v$ is propagated up similarly to
MaxHeapInsert.
If $v<A[i]$
the smaller value is propagated down by running
MaxDownHeap (recursively).
The running time is $O(\lg{n})$ by way of the running time
of MaxDownHeap or MaxHeapInsert.


PROBLEM 9 
-------------------------------------------------------------------
 Distinct(X,m) //X[0..m-1]  
1. HeapSort(X,m);
2. for(i=0;i<m-1;i++)
3.  if X[i]== X[i+1] 
4.     retun(print(NO ));
5  retun(print(YES));
Description & proof of correctness
We sort input X by using HeapSort which is space efficient 
(sorts in-place) and also time efficient among the algorithms for 
sorting in Subjects 1-5.  Then we linearly scan the output array 
to find two duplicate keys. In the sorted output after line 1, 
duplicate keys would appear next to each other.  
If no such pair is detected in lines 2-4, line 5 says that
the keys are distinct; otherwise
a duplicate existence is reported in line 4 by saying NO
(implied: the keys are NOT distinct), and the algorithm terminates.  
Running time analysis: 
T(m) for Distinct is T(m)=O(mlgm), though one can also write 
T(m)=Theta(mlgm). The time is determined by the HeapSort of 
line 1. Lines 2-4,5 are Theta(m) time. 
Space analysis. 
HeapSort sorts in-place. Beyond that we need one additional 
index for i. Space requirements are constant S(m)=Theta(1) 
excluding the space used by input X.  

------------------------------------------------------------
Alex. Gerbessiotis  CS 610 FALL   2025
(c) All rights reserved.      OCTOBER      2025.
Time Created:10/14/2025@14:45 Last Update: 10/30/2025@09:48 
------------------------------------------------------------