Stanford Algorithms: Design and Analysis, Part 1[week 6]

Problem Set-6

Programming Question-6

Question 1

Download the text file here. (Right click and save link as).

The goal of this problem is to implement a variant of the 2-SUM algorithm (covered in the Week 6 lecture on hash table applications).

The file contains 1 million integers, both positive and negative (there might be some repetitions!).This is your array of integers, with the  ith  row of the file specifying the  ith  entry of the array.

Your task is to compute the number of target values  t  in the interval [-10000,10000] (inclusive) such that there are distinct numbers  x,y  in the input file that satisfy  x+y=t . (NOTE: ensuring distinctness requires a one-line addition to the algorithm from lecture.)

Write your numeric answer (an integer between 0 and 20001) in the space provided.

OPTIONAL CHALLENGE: If this problem is too easy for you, try implementing your own hash table for it. For example, you could compare performance under the chaining and open addressing approaches to resolving collisions.

#include <iostream>
#include <fstream>
#define MIN 10000
using namespace std;

int hash2[MIN + 1] = { 0 };
int count = 0;

void readData() 
{
	ifstream fin("2sum.txt");
	int temp = 0;
	while(fin>>temp) 
	{
		if(temp < MIN) 
			hash2[temp]++;
	}
}

bool hashMap(int n) 
{
	if(n > MIN) 
		return false;
	if(hash2[n]) 
		return true;
	else 
		return false;
}

int main() 
{
	readData();

	for(int i = -10000; i <= 10000; i++) 
	{
		for(int j = -10000; j <= 10000; j++) 
		{
			if(hashMap(j) && hashMap(i - j)) 
			{
				count++;
				break;
			}
		}
	}
	cout<<count<<endl;
	return 0;
}

Question 2

Download the text file here.

The goal of this problem is to implement the "Median Maintenance" algorithm (covered in the Week 5 lecture on heap applications). The text file contains a list of the integers from 1 to 10000 in unsorted order; you should treat this as a stream of numbers, arriving one by one. Letting  xi  denote the  i th number of the file, the  k th median  mk  is defined as the median of the numbers  x1,…,xk . (So, if  k  is odd, then  mk  is  ((k+1)/2) th smallest number among  x1,…,xk ; if  k  is even, then  mk  is the  (k/2) th smallest number among  x1,…,xk .)

In the box below you should type the sum of these 10000 medians, modulo 10000 (i.e., only the last 4 digits). That is, you should compute  (m1+m2+m3+⋯+m10000)mod10000 .

OPTIONAL EXERCISE: Compare the performance achieved by heap-based and search-tree-based implementations of the algorithm.

#ifndef _HEAP_H_
#define _HEAP_H_
//        MAX_HEAP
void MAX_HEAPIFY(short *A,short i)        {
        short left=2*i,right=2*i+1,larger,tmp;
        if ((left<=A[0])&&(A[left]>A[i]))
          larger = left;
        else
          larger = i;
        if ((right<=A[0])&&(A[right]>A[larger]))
          larger = right;
        if (larger != i)        {
          tmp = A[larger]; A[larger] = A[i]; A[i] = tmp;
          MAX_HEAPIFY(A,larger);
        }
}
short EXTRACT_MAX(short *A)        {
  short max = A[1];
  A[1] = A[A[0]--];
  MAX_HEAPIFY(A,1);
  return max;
}
void HEAP_INCREASE_KEY(short *A,short i,short key)        {
  short tmp;
  A[i] = key;
  while ((i>1)&&(A[i/2]<A[i]))        {
        tmp = A[i]; A[i] = A[i/2]; A[i/2] = tmp;
        i = i/2;
  }
}
void MAX_HEAP_INSERT(short *A,short key)        {
  A[0]++;
  HEAP_INCREASE_KEY(A,A[0],key);
}
//        MIN_HEAP
void MIN_HEAPIFY(short *A,short i)        {
        short left=2*i,right=2*i+1,smaller,tmp;
        if ((left<=A[0])&&(A[left]<A[i]))
          smaller = left;
        else
          smaller = i;
        if ((right<=A[0])&&(A[right]<A[smaller]))
          smaller = right;
        if (smaller != i)        {
          tmp = A[smaller]; A[smaller] = A[i]; A[i] = tmp;
          MIN_HEAPIFY(A,smaller);
        }
}
short EXTRACT_MIN(short *A)        {
  short min = A[1];
  A[1] = A[A[0]--];
  MIN_HEAPIFY(A,1);
  return min;
}
void HEAP_DECREASE_KEY(short *A,short i,short key)        {
  short tmp;
  A[i] = key;
  while ((i>1)&&(A[i/2]>A[i]))        {
        tmp = A[i]; A[i] = A[i/2]; A[i/2] = tmp;
        i = i/2;
  }
}
void MIN_HEAP_INSERT(short *A,short key)        {
  A[0]++;
  HEAP_DECREASE_KEY(A,A[0],key);
}
#endif

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include "heap.h"
const char INFILE[] = "Median.txt";
#define MAX        10000
short A1[10001],A2[10001];

short RETURN_MEDIAN(short *A1,short *A2,short x)        {
  if (x<A2[1])
        MAX_HEAP_INSERT(A1,x);
  else
        MIN_HEAP_INSERT(A2,x);
  if (A1[0]-A2[0]>1)        
        MIN_HEAP_INSERT(A2,EXTRACT_MAX(A1));
  if (A2[0]>A1[0])        
        MAX_HEAP_INSERT(A1,EXTRACT_MIN(A2));
  return A1[1];
}


void main()        {
  int m=0;
  A1[0] = 1; A1[1] = 0;
  A2[0] = 1; A2[1] = 20000;
  char line[10];
  FILE *fp = fopen(INFILE,"r");
  while (fgets(line,10,fp))        
        m = (m + RETURN_MEDIAN(A1,A2,atoi(line))) % 10000;
  printf("%d\n",m);
}