int main(void)
{
char lecture[100];
int val;
BinaryHeap * heap;
heap = Init(10);
fscanf(stdin,"%99s",lecture);
while (strcmp(lecture,"bye")!=0) {
if (strcmp(lecture,"insert")==0) {
fscanf(stdin,"%99s",lecture);
val = strtol(lecture,NULL,10);
InsertValue(heap,val);
} else if (strcmp(lecture,"extract")==0) {
if(ExtractMax(heap,&val))
{
printf("%d\r\n",val);
}
} else if (strcmp(lecture,"print")==0) {
printTab(heap);
}
fscanf(stdin,"%99s",lecture);
}
Destroy(heap);
return 0;
}
// Checkpoint algorithm.
// O(n^3) time
// O(n^2) space
score_t Phaser::partial_aligner(size_t i_ini,
size_t j_ini,
size_t k_ini,
size_t i_end,
size_t j_end,
size_t k_end,
size_t *i_med,
size_t *j_med,
size_t *k_med) {
assert(j_end >= j_ini || j_end + 1 == j_ini);
assert(i_end >= i_ini || i_end + 1 == i_ini);
assert(k_end >= k_ini);
score_t * prev_face[8];
score_t * curr_face[8];
my_pair * prev_check[8];
my_pair * curr_check[8];
// Obs: we will use local i (resp. j, k) from 0 to I_len (J_len, K_len).
// characters are stracted from i_ini+i (j, k resp.).
// checkpoint answer is shifted back at the end.
I_len = i_end - i_ini + 1;
J_len = j_end - j_ini + 1;
size_t K_len = k_end - k_ini + 1;
size_t mid_k = K_len/2;
for (size_t m = 0; m < 8; m++) {
prev_face[m] = new score_t[(I_len+1) * (J_len+1)];
prev_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
// 8 points:
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
prev_face[m][IJ(0, 0)] = 0;
prev_check[m][IJ(0, 0)] = my_pair(0, 0);
}
}
}
// 8 lines (j=0):
for (size_t i = 1; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
char m_char = mf ? M2[i_ini + i-1] : M1[i_ini + i-1];
prev_face[m][IJ(i, 0)] = std::max(prev_face[m_index(0, ff, cf)][IJ(i-1, 0)] + score(m_char, '-'), // NOLINT
prev_face[m_index(1, ff, cf)][IJ(i-1, 0)] + score(m_char, '-')); // NOLINT
prev_check[m][IJ(i, 0)] = my_pair(i, 0);
}
}
}
}
// 8 faces:
for (size_t j = 1; j <= J_len; j++) {
for (size_t i = 0; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
size_t m = m_index(mf, ff, cf);
char f_char = ff ? F2[j_ini + j-1] : F1[j_ini + j-1];
prev_face[m][IJ(i, j)] = std::max(prev_face[m_index(mf, 0, cf)][IJ(i, j-1)] + score(f_char, '-'), // NOLINT
prev_face[m_index(mf, 1, cf)][IJ(i, j-1)] + score(f_char, '-')); // NOLINT
prev_check[m][IJ(i, j)] = my_pair(i, j);
}
}
}
}
}
PrintFace(prev_face);
bool malloc_opt = true;
if (malloc_opt) {
for (size_t m = 0; m < 8; m++) {
curr_face[m] = new score_t[(I_len+1) * (J_len+1)];
curr_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
}
// the rest of the faces:
for (size_t k = 1; k <= K_len; k++) {
if (!malloc_opt) {
for (size_t m = 0; m < 8; m++) {
curr_face[m] = new score_t[(I_len+1) * (J_len+1)];
curr_check[m] = new my_pair[(I_len+1) * (J_len+1)];
}
}
for (size_t j = 0; j <= J_len; j++) {
for (size_t i = 0; i <= I_len; i++) {
for (bool cf : {false, true}) {
for (bool ff : {false, true}) {
for (bool mf : {false, true}) {
// m_char anf f_char should not be used, at least i > 0 (j > 0).
// If that is not the case, we initilize with a non-accepted character that
// will trig an error if used.
char m_char, f_char;
if (i > 0) {
m_char = mf ? M2[i_ini + i-1] : M1[i_ini + i-1];
} else {
m_char = 'J'; // Not in gen alphabet, will trigger an error if used.
}
if (j > 0) {
f_char = ff ? F2[j_ini + j-1] : F1[j_ini + j-1];
} else {
f_char = 'J'; // Not in gen alphabet, will trigger an error if used.
}
char c_1 = cf ? C2[k_ini + k-1] : C1[k_ini + k-1];
char c_2 = cf ? C1[k_ini + k-1] : C2[k_ini + k-1];
UpdateGeneral(curr_face,
prev_face,
curr_check,
prev_check,
i,
j,
k,
mid_k,
mf,
ff,
cf,
m_char,
f_char,
c_1,
c_2);
}
}
}
}
}
for (size_t m = 0; m < 8; m++) {
if (malloc_opt) {
score_t * tmp_face = prev_face[m];
my_pair * tmp_check = prev_check[m];
prev_face[m] = curr_face[m];
prev_check[m] = curr_check[m];
curr_face[m] = tmp_face;
curr_check[m] = tmp_check;
} else { delete[] (prev_face[m]);
delete[] (prev_check[m]);
prev_face[m] = curr_face[m];
prev_check[m] = curr_check[m];
}
}
if (k >= mid_k) {
// verbose = true;
}
PrintFace(prev_face);
PrintCheck(prev_check);
}
// we use char_i = M[i-1]
for (int i = 0; i < 8; i++) {
assert(prev_check[i][IJ(I_len, J_len)].first <= I_len);
assert(prev_check[i][IJ(I_len, J_len)].second <= J_len);
prev_check[i][IJ(I_len, J_len)].first--;
prev_check[i][IJ(I_len, J_len)].second--;
}
mid_k--;
// extract max:
score_t ans;
bool flip_ans;
ExtractMax(prev_face, prev_check, &ans, i_med, j_med, &flip_ans);
*k_med = k_ini + mid_k;
*i_med = i_ini + (*i_med);
*j_med = j_ini + (*j_med);
assert(CorrectIniMedEnd(i_ini, *i_med, i_end));
assert(CorrectIniMedEnd(j_ini, *j_med, j_end));
assert(CorrectIniMedEnd(k_ini, *k_med, k_end));
char phase_char = flip_ans ? '1' : '0';
if (phase_string[k_end] != '?') {
assert(phase_string[k_end] == phase_char);
}
if (phase_string[k_end] == '?') {
phase_string[k_end] = phase_char;
}
for (size_t m = 0; m < 8; m++) {
delete[] (prev_face[m]);
delete[] (prev_check[m]);
if (malloc_opt) {
delete[] (curr_face[m]);
delete[] (curr_check[m]);
}
}
return ans;
}
