// 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을 리턴해야 합니다.
}
