// get minimal (max u) around (x,y) double get_around_u(int n, int k, double x, double y, int radius) { double step = 0.5; // start from the bottom-left corner double xi = x-step*radius; double yi = y-step*radius; int i; double min=999999999, cur; // to the right for (i=0; i<radius*2; i++) { cur = get_u(n, k, xi, yi); if (min > cur) min = cur; xi++; } // to the top for (i=0; i<radius*2; i++) { cur = get_u(n, k, xi, yi); if (min > cur) min = cur; yi++; } // to the left for (i=0; i<radius*2; i++) { cur = get_u(n, k, xi, yi); if (min > cur) min = cur; xi--; } // to the bottom for (i=0; i<radius*2; i++) { cur = get_u(n, k, xi, yi); if (min > cur) min = cur; xi--; } return min; }
// get x with optimal u double get_xu (int n, int k, double x, double y, double step) { double cur = get_u(n,k,x,y); double next = get_u(n,k,x+step,y); while(cur > next) { cur = next; x = x + step; next = get_u(n,k,x+step,y); } return x; }
double get_yu (int n, int k, double x, double y, double step) { double cur = get_u(n,k,x,y); double next = get_u(n,k,x,y+step); while(cur > next) { cur = next; y = y + step; next = get_u(n,k,x,y+step); } return y; }
int VFrame::copy_from(VFrame *frame) { int w = MIN(this->w, frame->get_w()); int h = MIN(this->h, frame->get_h()); timestamp = frame->timestamp; switch(frame->color_model) { case BC_COMPRESSED: allocate_compressed_data(frame->compressed_size); memcpy(data, frame->data, frame->compressed_size); this->compressed_size = frame->compressed_size; break; case BC_YUV410P: memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w / 4 * h / 4); memcpy(get_v(), frame->get_v(), w / 4 * h / 4); break; case BC_YUV420P: case BC_YUV411P: //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v()); memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w * h / 4); memcpy(get_v(), frame->get_v(), w * h / 4); break; case BC_YUV422P: //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v()); memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w * h / 2); memcpy(get_v(), frame->get_v(), w * h / 2); break; case BC_YUV444P: //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v()); memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w * h); memcpy(get_v(), frame->get_v(), w * h); break; default: // printf("VFrame::copy_from %d\n", calculate_data_size(w, // h, // -1, // frame->color_model)); // Copy without extra 4 bytes in case the source is a hardware device memmove(data, frame->data, get_data_size()); break; } return 0; }
/** * Description not yet available. * \param */ df1_two_variable& df1_two_variable::operator /= (const df1_two_variable& y) { /* df1_three_variable x=*this * inv(y); *this=x; return *this; */ // properly optimized code double tmp=1.0/value(y); *get_u()*=tmp; *get_u_x() = *get_u_x()*tmp- *get_u()*tmp* *y.get_u_x(); *get_u_y() = *get_u_y()*tmp- *get_u()*tmp* *y.get_u_y(); return *this; }
/** * Description not yet available. * \param */ df1_two_variable& df1_two_variable::operator += (const df1_two_variable& v) { *get_u() += *v.get_u(); *get_u_x() += *v.get_u_x(); *get_u_y() += *v.get_u_y(); return *this; }
df1_one_variable& df1_one_variable::operator+=(const df1_one_variable& _v) { *get_u() += *_v.get_u(); *get_u_x() += *_v.get_u_x(); return *this; }
/** * Description not yet available. * \param */ df1_two_variable& df1_two_variable::operator = (const df1_two_variable& x) { *get_u() = *x.get_u(); *get_u_x() = *x.get_u_x(); *get_u_y() = *x.get_u_y(); return *this; }
/** * Description not yet available. * \param */ init_df1_two_variable::init_df1_two_variable(const prevariable& _v) { if (num_ind_var > 1) { cerr << "can only have 2 independent_variables in df1_two_variable" " function" << endl; ad_exit(1); } else { ADUNCONST(prevariable,v) ind_var[num_ind_var++]=&v; *get_u() = value(v); switch(num_ind_var) { case 1: *get_u_x() = 1.0; *get_u_y() = 0.0; break; case 2: *get_u_x() = 0.0; *get_u_y() = 1.0; break; default: cerr << "illegal num_ind_var value of " << num_ind_var << " in df1_two_variable function" << endl; ad_exit(1); } } }
/** * Description not yet available. * \param */ df1_two_variable& df1_two_variable::operator = (double x) { *get_u() = x; *get_u_x() =0.0; *get_u_y() =0.0; return *this; }
static void ref_pic_lists_modification(struct h265_private *p) { int i; p->slice.ref_pic_list_modification_flag_l0 = get_u(p->regs, 1); if (p->slice.ref_pic_list_modification_flag_l0) for (i = 0; i <= p->slice.num_ref_idx_l0_active_minus1; i++) p->slice.list_entry_l0[i] = get_u(p->regs, ceil_log2(p->info->NumPocTotalCurr)); if (p->slice.slice_type == SLICE_B) { p->slice.ref_pic_list_modification_flag_l1 = get_u(p->regs, 1); if (p->slice.ref_pic_list_modification_flag_l1) for (i = 0; i <= p->slice.num_ref_idx_l1_active_minus1; i++) p->slice.list_entry_l1[i] = get_u(p->regs, ceil_log2(p->info->NumPocTotalCurr)); } }
int VFrame::copy_from(VFrame *frame) { int w = MIN(this->w, frame->get_w()); int h = MIN(this->h, frame->get_h()); switch(frame->color_model) { case BC_COMPRESSED: allocate_compressed_data(frame->compressed_size); memcpy(data, frame->data, frame->compressed_size); this->compressed_size = frame->compressed_size; break; case BC_YUV420P: //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v()); memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w * h / 4); memcpy(get_v(), frame->get_v(), w * h / 4); break; case BC_YUV422P: //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v()); memcpy(get_y(), frame->get_y(), w * h); memcpy(get_u(), frame->get_u(), w * h / 2); memcpy(get_v(), frame->get_v(), w * h / 2); break; default: // printf("VFrame::copy_from %d\n", calculate_data_size(w, // h, // -1, // frame->color_model)); memcpy(data, frame->data, calculate_data_size(w, h, -1, frame->color_model)); break; } return 0; }
df1_two_variable& df1_two_variable::operator *= (double v) { /* df1_three_variable x=*this * v; *this=x; return *this; */ *get_u()*=v; *get_u_x() = *get_u_x()*v; *get_u_y() = *get_u_y()*v; return *this; }
/** * Description not yet available. * \param */ local_dep_df1b2variable& local_dep_df1b2variable::operator = (const df1b2variable& x) { df1b2variable::operator = (x); *(p->get_u()) = *get_u(); local_init_var::dot_calcs_all(*this); /* int global_nvar=adpool_nvar_stack[adpool_stack_pointer-1]; if (p) { p->initialize(global_nvar); *(p->get_u()) = *get_u(); } */ return *this; }
static void pred_weight_table(struct h265_private *p) { int i, j; p->slice.luma_log2_weight_denom = get_ue(p->regs); if (p->info->chroma_format_idc != 0) p->slice.delta_chroma_log2_weight_denom = get_se(p->regs); for (i = 0; i <= p->slice.num_ref_idx_l0_active_minus1; i++) p->slice.luma_weight_l0_flag[i] = get_u(p->regs, 1); if (p->info->chroma_format_idc != 0) for (i = 0; i <= p->slice.num_ref_idx_l0_active_minus1; i++) p->slice.chroma_weight_l0_flag[i] = get_u(p->regs, 1); for (i = 0; i <= p->slice.num_ref_idx_l0_active_minus1; i++) { if (p->slice.luma_weight_l0_flag[i]) { p->slice.delta_luma_weight_l0[i] = get_se(p->regs); p->slice.luma_offset_l0[i] = get_se(p->regs); } if (p->slice.chroma_weight_l0_flag[i]) { for (j = 0; j < 2; j++) { p->slice.delta_chroma_weight_l0[i][j] = get_se(p->regs); p->slice.delta_chroma_offset_l0[i][j] = get_se(p->regs); } } } if (p->slice.slice_type == SLICE_B) { for (i = 0; i <= p->slice.num_ref_idx_l1_active_minus1; i++) p->slice.luma_weight_l1_flag[i] = get_u(p->regs, 1); if (p->info->chroma_format_idc != 0) for (i = 0; i <= p->slice.num_ref_idx_l1_active_minus1; i++) p->slice.chroma_weight_l1_flag[i] = get_u(p->regs, 1); for (i = 0; i <= p->slice.num_ref_idx_l1_active_minus1; i++) { if (p->slice.luma_weight_l1_flag[i]) { p->slice.delta_luma_weight_l1[i] = get_se(p->regs); p->slice.luma_offset_l1[i] = get_se(p->regs); } if (p->slice.chroma_weight_l1_flag[i]) { for (j = 0; j < 2; j++) { p->slice.delta_chroma_weight_l1[i][j] = get_se(p->regs); p->slice.delta_chroma_offset_l1[i][j] = get_se(p->regs); } } } } }
int VFrame::clear_frame() { int sz = w * h; //printf("VFrame::clear_frame %d\n", __LINE__); switch(color_model) { case BC_COMPRESSED: break; case BC_YUV410P: bzero(get_y(), sz); bzero(get_u(), w / 4 * h / 4); bzero(get_v(), w / 4 * h / 4); break; case BC_YUV411P: case BC_YUV420P: bzero(get_y(), sz); bzero(get_u(), sz / 4); bzero(get_v(), sz / 4); break; case BC_YUV422P: bzero(get_y(), sz); bzero(get_u(), sz / 2); bzero(get_v(), sz / 2); break; case BC_RGBA_FLOATP: if( a ) { float *ap = (float *)a; for( int i=sz; --i>=0; ++ap ) *ap = 1.f; } case BC_RGB_FLOATP: { float *rp = (float *)y; for( int i=sz; --i>=0; ++rp ) *rp = 0.f; float *gp = (float *)u; for( int i=sz; --i>=0; ++gp ) *gp = 0.f; float *bp = (float *)v; for( int i=sz; --i>=0; ++bp ) *bp = 0.f; break; } case BC_YUV444P: bzero(get_y(), sz); bzero(get_u(), sz); bzero(get_v(), sz); break; case BC_YUV888: ZERO_YUV(3, unsigned char, 0xff); break; case BC_YUVA8888: ZERO_YUV(4, unsigned char, 0xff); break; case BC_YUV161616: ZERO_YUV(3, uint16_t, 0xffff); break; case BC_YUVA16161616: ZERO_YUV(4, uint16_t, 0xffff); break; default: bzero(data, calculate_data_size(w, h, bytes_per_line, color_model)); break; } return 0; }
df1_one_variable& df1_one_variable::operator-=(double _v) { *get_u() -= _v; return *this; }
/** * Description not yet available. * \param */ df1_two_variable& df1_two_variable::operator -= (double v) { *get_u() -= v; return *this; }
/** * Description not yet available. * \param */ init_df1_two_variable::init_df1_two_variable(double v) { *get_u() = v; *get_u_x() = 0.0; *get_u_y() = 0.0; }
static void slice_header(struct h265_private *p) { int i; p->slice.first_slice_segment_in_pic_flag = get_u(p->regs, 1); if (p->nal_unit_type >= 16 && p->nal_unit_type <= 23) p->slice.no_output_of_prior_pics_flag = get_u(p->regs, 1); p->slice.slice_pic_parameter_set_id = get_ue(p->regs); if (!p->slice.first_slice_segment_in_pic_flag) { if (p->info->dependent_slice_segments_enabled_flag) p->slice.dependent_slice_segment_flag = get_u(p->regs, 1); p->slice.slice_segment_address = get_u(p->regs, ceil_log2(PicSizeInCtbsY)); } if (!p->slice.dependent_slice_segment_flag) { p->slice.pic_output_flag = 1; p->slice.num_ref_idx_l0_active_minus1 = p->info->num_ref_idx_l0_default_active_minus1; p->slice.num_ref_idx_l1_active_minus1 = p->info->num_ref_idx_l1_default_active_minus1; p->slice.collocated_from_l0_flag = 1; p->slice.slice_deblocking_filter_disabled_flag = p->info->pps_deblocking_filter_disabled_flag; p->slice.slice_beta_offset_div2 = p->info->pps_beta_offset_div2; p->slice.slice_tc_offset_div2 = p->info->pps_tc_offset_div2; p->slice.slice_loop_filter_across_slices_enabled_flag = p->info->pps_loop_filter_across_slices_enabled_flag; skip_bits(p->regs, p->info->num_extra_slice_header_bits); p->slice.slice_type = get_ue(p->regs); if (p->info->output_flag_present_flag) p->slice.pic_output_flag = get_u(p->regs, 1); if (p->info->separate_colour_plane_flag == 1) p->slice.colour_plane_id = get_u(p->regs, 2); if (p->nal_unit_type != 19 && p->nal_unit_type != 20) { p->slice.slice_pic_order_cnt_lsb = get_u(p->regs, p->info->log2_max_pic_order_cnt_lsb_minus4 + 4); p->slice.short_term_ref_pic_set_sps_flag = get_u(p->regs, 1); skip_bits(p->regs, p->info->NumShortTermPictureSliceHeaderBits); if (p->info->long_term_ref_pics_present_flag) skip_bits(p->regs, p->info->NumLongTermPictureSliceHeaderBits); if (p->info->sps_temporal_mvp_enabled_flag) p->slice.slice_temporal_mvp_enabled_flag = get_u(p->regs, 1); } if (p->info->sample_adaptive_offset_enabled_flag) { p->slice.slice_sao_luma_flag = get_u(p->regs, 1); p->slice.slice_sao_chroma_flag = get_u(p->regs, 1); } if (p->slice.slice_type == SLICE_P || p->slice.slice_type == SLICE_B) { p->slice.num_ref_idx_active_override_flag = get_u(p->regs, 1); if (p->slice.num_ref_idx_active_override_flag) { p->slice.num_ref_idx_l0_active_minus1 = get_ue(p->regs); if (p->slice.slice_type == SLICE_B) p->slice.num_ref_idx_l1_active_minus1 = get_ue(p->regs); } if (p->info->lists_modification_present_flag && p->info->NumPocTotalCurr > 1) ref_pic_lists_modification(p); if (p->slice.slice_type == SLICE_B) p->slice.mvd_l1_zero_flag = get_u(p->regs, 1); if (p->info->cabac_init_present_flag) p->slice.cabac_init_flag = get_u(p->regs, 1); if (p->slice.slice_temporal_mvp_enabled_flag) { if (p->slice.slice_type == SLICE_B) p->slice.collocated_from_l0_flag = get_u(p->regs, 1); if ((p->slice.collocated_from_l0_flag && p->slice.num_ref_idx_l0_active_minus1 > 0) || (!p->slice.collocated_from_l0_flag && p->slice.num_ref_idx_l1_active_minus1 > 0)) p->slice.collocated_ref_idx = get_ue(p->regs); } if ((p->info->weighted_pred_flag && p->slice.slice_type == SLICE_P) || (p->info->weighted_bipred_flag && p->slice.slice_type == SLICE_B)) pred_weight_table(p); p->slice.five_minus_max_num_merge_cand = get_ue(p->regs); } p->slice.slice_qp_delta = get_se(p->regs); if (p->info->pps_slice_chroma_qp_offsets_present_flag) { p->slice.slice_cb_qp_offset = get_se(p->regs); p->slice.slice_cr_qp_offset = get_se(p->regs); } if (p->info->deblocking_filter_override_enabled_flag) p->slice.deblocking_filter_override_flag = get_u(p->regs, 1); if (p->slice.deblocking_filter_override_flag) { p->slice.slice_deblocking_filter_disabled_flag = get_u(p->regs, 1); if (!p->slice.slice_deblocking_filter_disabled_flag) { p->slice.slice_beta_offset_div2 = get_se(p->regs); p->slice.slice_tc_offset_div2 = get_se(p->regs); } } if (p->info->pps_loop_filter_across_slices_enabled_flag && (p->slice.slice_sao_luma_flag || p->slice.slice_sao_chroma_flag || !p->slice.slice_deblocking_filter_disabled_flag)) p->slice.slice_loop_filter_across_slices_enabled_flag = get_u(p->regs, 1); } if (p->info->tiles_enabled_flag || p->info->entropy_coding_sync_enabled_flag) { p->slice.num_entry_point_offsets = get_ue(p->regs); if (p->slice.num_entry_point_offsets > 0) { p->slice.offset_len_minus1 = get_ue(p->regs); for (i = 0; i < p->slice.num_entry_point_offsets; i++) p->slice.entry_point_offset_minus1[i] = get_u(p->regs, p->slice.offset_len_minus1 + 1); } } if (p->info->slice_segment_header_extension_present_flag) skip_bits(p->regs, get_ue(p->regs) * 8); }
int main(void) { /* 아래 freopen 함수는 sample_input.txt를 read only 형식으로 열고, 표준입력(키보드) 대신 sample_input.txt 로 부터 읽어오겠다는 의미의 코드입니다. 만약 본인 PC 에서 테스트 할 때는, 입력값을 sample_input.txt에 저장한 후 freopen 함수를 사용하면 그 아래에서 scanf 함수를 사용하여 표준입력 대신 sample_input.txt 파일로 부터 입력값을 읽어 올 수 있습니다. 또한, 본인 PC에서 freopen 함수를 사용하지 않고 표준입력을 사용하여 테스트하셔도 무방합니다. 단, Codeground 시스템에서 "제출하기" 할 때에는 반드시 freopen 함수를 지우거나 주석(//) 처리 하셔야만 합니다. */ // freopen("sample_input.txt", "r", stdin); /* setbuf 함수를 사용하지 않으면, 본인의 프로그램이 제한 '시간 초과'로 강제 종료 되었을 때, printf로 출력한 내용이 채점되지 않고 '0점'이 될 수도 있습니다. 시간 초과 전까지 실행된 결과 점수를 받고자 하신다면 "setbuf(stdout, NULL);" 를 사용하시기 바랍니다. */ setbuf(stdout, NULL); int T; int test_case; double min_step = 0.5; scanf("%d", &T); for(test_case = 1; test_case <= T; test_case++) { // 이 부분에서 알고리즘 프로그램을 작성하십시오. 기본 제공된 코드를 수정 또는 삭제하고 본인이 코드를 사용하셔도 됩니다. /// n is the number of refugees, and k is the number of supplies int n,k,i,j; scanf("%d%d", &n, &k); for (i=0; i<n; i++) scanf("%lf%lf", &refugee[i][0], &refugee[i][1]); for (i=0; i<k; i++) scanf("%lf",&supply[i]); // sort supply quick_sort(supply, k); // guess the best position of avg double step = 50000; double x=0, y=0; /* while(step>=min_step) { x = get_x(n,x,y,step); x = get_x(n,x,y,-step); y = get_y(n,x,y,step); y = get_y(n,x,y,-step); step/=10; } */ // find the best position of avg step = 50000; while(step>=min_step) { x = get_xu(n,k,x,y,step); x = get_xu(n,k,x,y,-step); y = get_yu(n,k,x,y,step); y = get_yu(n,k,x,y,-step); step/=10; } // find the minimal around the best position double min = get_u(n,k,x,y); double cur; step = min_step; int max_iteration=10000; for (i=1; i<max_iteration; i++) { step = 0.5 * i; x = get_xu(n,k,x,y,step); x = get_xu(n,k,x,y,-step); y = get_yu(n,k,x,y,step); y = get_yu(n,k,x,y,-step); cur = get_u(n,k,x,y); if (min > cur) min = cur; else break; } double prev_min = min; int radius = 1; do { prev_min = min; for (i=1; i<300; i++) { cur = get_around_u(n,k,x,y,radius++); if (min > cur) min = cur; } } while(prev_min > min && radius < 3000); // 이 부분에서 정답을 출력하십시오. printf("Case #%d\n", test_case); printf("%.1f\n",min); } return 0; // 정상종료 시 반드시 0을 리턴해야 합니다. }