結果
| 問題 | No.2596 Christmas Eve (Heuristic ver.) |
| ユーザー |
 bin101
|
| 提出日時 | 2023-12-24 16:58:40 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 15,950 bytes |
| コンパイル時間 | 4,011 ms |
| コンパイル使用メモリ | 248,412 KB |
| 実行使用メモリ | 6,676 KB |
| スコア | 0 |
| 最終ジャッジ日時 | 2023-12-24 16:58:57 |
| 合計ジャッジ時間 | 16,851 ms |
|
ジャッジサーバーID （参考情報） |
judge15 / judge11 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | WA | - |
| testcase_01 | WA | - |
| testcase_02 | WA | - |
| testcase_03 | WA | - |
| testcase_04 | WA | - |
| testcase_05 | WA | - |
| testcase_06 | WA | - |
| testcase_07 | WA | - |
| testcase_08 | WA | - |
| testcase_09 | WA | - |
| testcase_10 | WA | - |
| testcase_11 | WA | - |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | WA | - |
| testcase_15 | WA | - |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | WA | - |
| testcase_20 | WA | - |
| testcase_21 | WA | - |
| testcase_22 | WA | - |
| testcase_23 | WA | - |
| testcase_24 | WA | - |
| testcase_25 | WA | - |
| testcase_26 | WA | - |
| testcase_27 | WA | - |
| testcase_28 | WA | - |
| testcase_29 | WA | - |
| testcase_30 | WA | - |
| testcase_31 | WA | - |
| testcase_32 | WA | - |
| testcase_33 | WA | - |
| testcase_34 | WA | - |
| testcase_35 | WA | - |
| testcase_36 | WA | - |
| testcase_37 | WA | - |
| testcase_38 | WA | - |
| testcase_39 | WA | - |
| testcase_40 | WA | - |
| testcase_41 | WA | - |
| testcase_42 | WA | - |
| testcase_43 | WA | - |
| testcase_44 | WA | - |
| testcase_45 | WA | - |
| testcase_46 | WA | - |
| testcase_47 | WA | - |
| testcase_48 | WA | - |
| testcase_49 | WA | - |
| testcase_50 | WA | - |
| testcase_51 | WA | - |
| testcase_52 | WA | - |
| testcase_53 | WA | - |
| testcase_54 | WA | - |
| testcase_55 | WA | - |
| testcase_56 | WA | - |
| testcase_57 | WA | - |
| testcase_58 | WA | - |
| testcase_59 | WA | - |
| testcase_60 | WA | - |
| testcase_61 | WA | - |
| testcase_62 | WA | - |
| testcase_63 | WA | - |
| testcase_64 | WA | - |
| testcase_65 | WA | - |
| testcase_66 | WA | - |
| testcase_67 | WA | - |
| testcase_68 | WA | - |
| testcase_69 | WA | - |
| testcase_70 | WA | - |
| testcase_71 | WA | - |
| testcase_72 | WA | - |
| testcase_73 | WA | - |
| testcase_74 | WA | - |
| testcase_75 | WA | - |
| testcase_76 | WA | - |
| testcase_77 | WA | - |
| testcase_78 | WA | - |
| testcase_79 | WA | - |
| testcase_80 | WA | - |
| testcase_81 | WA | - |
| testcase_82 | WA | - |
| testcase_83 | WA | - |
| testcase_84 | WA | - |
| testcase_85 | WA | - |
| testcase_86 | WA | - |
| testcase_87 | WA | - |
| testcase_88 | WA | - |
| testcase_89 | WA | - |
| testcase_90 | WA | - |
| testcase_91 | WA | - |
| testcase_92 | WA | - |
| testcase_93 | WA | - |
| testcase_94 | WA | - |
| testcase_95 | WA | - |
| testcase_96 | WA | - |
| testcase_97 | WA | - |
| testcase_98 | WA | - |
| testcase_99 | WA | - |
| testcase_100 | WA | - |
| testcase_101 | WA | - |
| testcase_102 | WA | - |
| testcase_103 | WA | - |
| testcase_104 | WA | - |
| testcase_105 | WA | - |
| testcase_106 | WA | - |
| testcase_107 | WA | - |
| testcase_108 | WA | - |
| testcase_109 | WA | - |
| testcase_110 | WA | - |
| testcase_111 | WA | - |
| testcase_112 | WA | - |
| testcase_113 | WA | - |
| testcase_114 | WA | - |
| testcase_115 | WA | - |
| testcase_116 | WA | - |
| testcase_117 | WA | - |
| testcase_118 | WA | - |
| testcase_119 | WA | - |
| testcase_120 | WA | - |
| testcase_121 | WA | - |
| testcase_122 | WA | - |
| testcase_123 | WA | - |
| testcase_124 | WA | - |
ソースコード
/*
TODO:
*/
//#define NDEBUG
//#define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
//#define OPTUNA
#endif
#ifdef ONLINE_JUDGE
#define NDEBUG
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
//using Int=__int128;
#define mask(x) ((1LL<<x)-1)
#define ALL(A) A.begin(),A.end()
template<typename T1,typename T2> bool chmin(T1 &a,T2 b){if(a<=b)return 0; a=b; return 1;}
template<typename T1,typename T2> bool chmax(T1 &a,T2 b){if(a>=b)return 0; a=b; return 1;}
template<typename T> int bitUP(T x,int a){return (x>>a)&1;}
enum Dir{
Right,
Down,
Left,
Up
};
//→ ↓ ← ↑
int dh[4]={0,1,0,-1}, dw[4]={1,0,-1,0};
//上から時計回り
//int dx[8]={0,1,1,1,0,-1,-1,-1}, dy[8]={1,1,0,-1,-1,-1,0,1};
long double EPS = 1e-6;
const ll INF=(1LL<<62);
const int MAX=(1<<30);
using pii=pair<int,int>;
using pil=pair<int,ll>;
using pli=pair<ll,int>;
using pll=pair<ll,ll>;
using psi=pair<string,int>;
using pis=pair<int,string>;
using psl=pair<string,ll>;
using pls=pair<ll,string>;
using pss=pair<string,string>;
template<class T>
using minimum_queue=priority_queue<T,vector<T>,greater<T>>;
using Graph=vector<vector<int>>;
using i8=int8_t;
using i16=int16_t;
using i32=int32_t;
using i64=int64_t;
using u8=uint8_t;
using u16=uint16_t;
using u32=uint32_t;
using u64=uint64_t;
void FastIO(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
}
//0-indexed vector cin
template<typename T>
inline istream &operator>>(istream &is,vector<T> &v) {
for(size_t i=0;i<v.size();i++) is>>v[i];
return is;
}
//0-indexed vector cin
template<typename T>
inline istream &operator>>(istream &is,vector<vector<T>> &v) {
for(size_t i=0;i<v.size();i++){
is>>v[i];
}
return is;
}
struct Xor32{
using u32=uint32_t;
u32 x=1234567;
inline u32 rnd_make(){
x^=(x<<13);
x=x^(x>>17);
return x=x^(x<<5);
}
inline u32 operator()(){
return rnd_make();
}
//[a,b)
inline int operator()(int a,int b){
int dis=b-a;
int add=rnd_make()%dis;
return a+add;
}
//[0,b)
inline int operator()(int b){
return rnd_make()%b;
}
//http://web.archive.org/web/20200105011004/https://topcoder.g.hatena.ne.jp/tomerun/20171216/
//[0,b)の中から異なる2つを選ぶ first<second
inline pair<int,int> two(int b){
assert(b>=2);
int v1=rnd_make()%b;
int v2=rnd_make()%(b-1);
if (v2>=v1) return {v1,v2+1};
else return {v2,v1};
}
};
struct Xor64{
u64 x=1234567;
inline u64 rnd_make(){
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return x;
}
inline u64 operator()(){
return rnd_make();
}
};
struct Timer{
chrono::high_resolution_clock::time_point st;
float local;
Timer(){
#ifndef ONLINE_JUDGE
local=1.0;
#endif
start();
}
void start(){
st=chrono::high_resolution_clock::now();
}
int span()const{
auto now=chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(now-st).count();
}
};
struct TestTimer{
chrono::high_resolution_clock::time_point st;
unordered_map<string,ll> sum_time;
unordered_map<string,chrono::high_resolution_clock::time_point> start_time;
TestTimer(){}
void start(const string &s){
#ifndef ONLINE_JUDGE
start_time[s]=chrono::high_resolution_clock::now();
#endif
}
void end(const string &s){
#ifndef ONLINE_JUDGE
auto now=chrono::high_resolution_clock::now();
sum_time[s]+=chrono::duration_cast<chrono::nanoseconds>(now-start_time[s]).count();
#endif
}
void output()const{
#ifndef ONLINE_JUDGE
for(auto m:sum_time){
cerr<<m.first<<": "<<m.second/1e6<<"ms"<<endl;
}
#endif
}
};
struct TestCounter{
unordered_map<string,ll> cnt;
TestCounter(){}
void count(const string &s){
#ifndef ONLINE_JUDGE
cnt[s]++;
#endif
}
void output()const{
#ifndef ONLINE_JUDGE
for(auto m:cnt){
cerr<<m.first<<": "<<m.second<<endl;
}
#endif
}
};
Timer TIME;
Xor32 Rand32;
Xor64 Rand64;
TestTimer testTimer;
TestCounter testCounter;
//https://atcoder.jp/contests/asprocon9/submissions/34659956
template<class T,int CAPACITY>
class DynamicArray{
public:
array<T,CAPACITY> array_={};
int size_=0;
DynamicArray(){}
DynamicArray(int n){
resize(n);
}
void push_back(const T &e){
array_[size_++]=e;
}
//ソートされた状態を保つように挿入
void insert(const T &e){
int ng=-1,ok=size_;
while(ok-ng!=1){
int mid=(ok+ng)/2;
if(array_[mid]>e) ok=mid;
else ng=mid;
}
for(int i=size_;i>ok;i--){
array_[i]=array_[i-1];
}
array_[ok]=e;
size_++;
}
//eをこえる一番左の添字
int find_binary_search(const T &e)const{
int ng=-1,ok=size_;
while(ok-ng!=1){
int mid=(ok+ng)/2;
if(array_[mid]>=e) ok=mid;
else ng=mid;
}
return ok;
}
void pop_back(){
size_--;
}
inline T& operator[](int index){
return array_[index];
}
inline const T& operator[](int index) const {
return array_[index];
}
inline int size()const{
return size_;
}
inline T& back(){
return array_[size_-1];
}
const inline T& back()const{
return array_[size_-1];
}
inline auto begin() -> decltype(array_.begin()) {
return array_.begin();
}
inline auto end() -> decltype(array_.begin()) {
return array_.begin() + size_;
}
inline auto begin() const -> decltype(array_.begin()) {
return array_.begin();
}
inline auto end() const -> decltype(array_.begin()) {
return array_.begin() + size_;
}
inline void resize(int new_size){
size_=new_size;
}
void operator=(const DynamicArray &e){
for(int i=0;i<e.size_;i++){
array_[i]=e[i];
}
size_=e.size_;
}
bool operator==(const DynamicArray &v){
if(size_!=v.size_) return false;
for(int i=0;i<size_;i++){
if(array_[i]!=v[i]){
return false;
}
}
return true;
}
bool operator==(const vector<T> &v){
if(size_!=v.size()) return false;
for(int i=0;i<size_;i++){
if(array_[i]!=v[i]){
return false;
}
}
return true;
}
void clear(){
size_=0;
}
//O(1)
//末尾と入れ替える。順序が保持されないが高速
void swap_remove(int idx){
array_[idx]=array_[size_-1];
size_--;
}
//最初から見ていき、一致したものを削除(remove)
bool erase(T value){
for(int i=0;i<size_;i++){
if(array_[i]==value){
remove(i);
return true;
}
}
return false;
}
void reverse(){
for(int i=0;i<size_/2;i++){
swap(array_[i],array_[size_-1-i]);
}
}
//O(size)
//順序を気にしない場合、swap_removeの方がいい
void remove(int idx){
for(int i=idx;i<size_-1;i++){
array_[i]=array_[i+1];
}
size_--;
}
void fill(T x){
for(int i=0;i<size_;i++){
array_[i]=x;
}
}
};
//ソート
template<typename T>
inline void vsort(vector<T> &v){
sort(v.begin(),v.end());
}
//逆順ソート
template<typename T>
inline void rvsort(vector<T> &v){
sort(v.rbegin(),v.rend());
}
//1ビットの数を返す
inline int popcount(int x){
return __builtin_popcount(x);
}
//1ビットの数を返す
inline int popcount(ll x){
return __builtin_popcountll(x);
}
template<typename T>
inline void Compress(vector<T> &C){
sort(C.begin(),C.end());
C.erase(unique(C.begin(),C.end()),C.end());
}
//要素数n 初期値x
template<typename T>
inline vector<T> vmake(size_t n,T x){
return vector<T>(n,x);
}
//a,b,c,x data[a][b][c] 初期値x
template<typename... Args>
auto vmake(size_t n,Args... args){
auto v=vmake(args...);
return vector<decltype(v)>(n,move(v));
}
//vは昇順
bool is_in(const vector<int> &v,int x){
int n=v.size();
if(n==0) return false;
int ng=-1,ok=n-1;
while(ok-ng!=1){
int mid=(ok+ng)/2;
if(v[mid]<x) ng=mid;
else ok=mid;
}
if(v[ok]==x) return true;
return false;
}
template<typename T >
struct edge {
int to;
T cost;
int id;
edge()=default;
edge(int to, T cost,int id) : to(to), cost(cost), id(id) {}
};
template<class T >
struct Edge {
int from, to,id;
T cost;
Edge(int from,int to,T cost,int id):from(from),to(to),cost(cost),id(id){}
Edge()=default;
bool operator<(const Edge<T> &e){
return cost<e.cost;
}
bool operator<=(const Edge<T> &e){
return cost<=e.cost;
}
};
template<typename T>
using WeightGraph=vector<vector<edge<T>>>;
//vector cout
template<typename T>
inline ostream &operator<<(ostream &os,const vector<T> &v) {
bool sp=true;
if(string(typeid(T).name())=="c") sp=false;
for(size_t i=0;i<v.size();i++){
if(i and sp) os<<" ";
os<<v[i];
}
return os;
}
//vector<vector> cout
template<typename T>
inline ostream &operator<<(ostream &os,const vector<vector<T>> &v) {
for(size_t i=0;i<v.size();i++){
os<<v[i];
if(i+1!=v.size()) os<<"\n";
}
return os;
}
//pair cout
template<typename T, typename U>
inline ostream &operator<<(ostream &os,const pair<T,U> &p) {
os<<p.first<<" "<<p.second;
return os;
}
//map cout
template<typename F, typename S>
inline ostream &operator<<(ostream &os,const map<F,S> &M) {
bool first=false;
for(auto x:M){
if(first) os<<endl;
first=true;
os<<x;
}
return os;
}
//set cout
template<typename T>
inline ostream &operator<<(ostream &os,const set<T> &S) {
bool first=false;
for(auto x:S){
if(first) os<<endl;
first=true;
os<<x;
}
return os;
}
//pair cin
template<typename T, typename U>
inline istream &operator>>(istream &is,pair<T,U> &p) {
is>>p.first>>p.second;
return is;
}
template<typename T>
void append(vector<T> &v,const vector<T> &vp){
for(auto p:vp){
v.push_back(p);
}
}
//Fisher–Yatesアルゴリズム
template<typename T>
void shuffle(vector<T> &v){
int sz=v.size();
for(int i=sz-1;i>0;i--){
swap(v[Rand32()%(i+1)],v[i]);
}
}
template<class T,class U>
T linear_function(U x,U start_x,U end_x,T start_value,T end_value){
if(x>=end_x) return end_value;
if(x<=start_x) return start_value;
return start_value+(end_value-start_value)*(x-start_x)/(end_x-start_x);
}
///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//https://atcoder.jp/contests/asprocon9/submissions/34659956
#ifndef OPTUNA
#define REGIST_PARAM(name, type, defaultValue) constexpr type name = defaultValue
#else
#define REGIST_PARAM(name, type, defaultValue) type name = defaultValue
#endif
namespace OP{
REGIST_PARAM(yama,bool,false);
REGIST_PARAM(startTemp,double,500000);
REGIST_PARAM(endTemp,float,0);
REGIST_PARAM(TIME_END,int,1900);
};
constexpr int num_parts=500;
int num_tree;
struct Parts{
int width;
int height;
int id;
bool used=false;
};
vector<Parts> bases_input(num_parts*2);
vector<Parts> middles_input(num_parts);
vector<Parts> tops_input(num_parts);
void input(){
int dummy;
cin>>dummy;
cin>>num_tree;
for(int i=0;i<num_parts;i++){
cin>>middles_input[i].width;
middles_input[i].id=i;
}
for(int i=0;i<num_parts;i++){
cin>>middles_input[i].height;
}
for(int i=0;i<num_parts*2;i++){
cin>>bases_input[i].width;
bases_input[i].id=i;
}
for(int i=0;i<num_parts*2;i++){
cin>>bases_input[i].width;
}
for(int i=0;i<num_parts;i++){
cin>>tops_input[i].width;
tops_input[i].id=i;
}
for(int i=0;i<num_parts;i++){
cin>>tops_input[i].width;
}
}
struct Ans{
array<Parts,2> bases;
Parts middle;
Parts top;
bool is_valid(){
if(min(bases[0].width,bases[1].width)<middle.width) return false;
if(middle.width<top.width) return false;
return true;
}
int height(){
int h=0;
h+=bases[0].height;
h+=bases[1].height;
h+=middle.height;
h+=top.height;
return h;
}
};
vector<Ans> ans;
vector<Parts> bases_res;
vector<Parts> middles_res;
vector<Parts> tops_res;
void make_valid_ans(){
auto bases=bases_input;
auto middles=middles_input;
auto tops=tops_input;
sort(bases.begin(),bases.end(),
[&](Parts a,Parts b){
return a.width>b.width;
});
sort(middles.begin(),middles.end(),
[&](Parts a,Parts b){
return a.width>b.width;
});
sort(tops.begin(),tops.end(),
[&](Parts a,Parts b){
return a.width>b.width;
});
vector<int> now(3,0);
while(ans.size()!=num_tree){
Ans a;
a.bases[0]=bases[now[0]];
a.bases[1]=bases[now[0]+1];
now[0]+=2;
int w=a.bases[1].width;
for(int i=now[1];;i++){
if(w>middles[i].width){
now[1]=i+1;
a.middle=middles[i];
w=middles[i].width;
break;
}
middles_res.push_back(middles[i]);
}
for(int i=now[2];;i++){
if(w>tops[i].width){
now[2]=i+1;
a.top=tops[i];
break;
}
tops_res.push_back(tops[i]);
}
ans.push_back(a);
}
for(int i=now[0];i<num_parts*2;i++){
bases_res.push_back(bases[i]);
}
for(int i=now[1];i<num_parts;i++){
middles_res.push_back(middles[i]);
}
for(int i=now[2];i<num_parts;i++){
tops_res.push_back(tops[i]);
}
}
ll evaluate(vector<Ans> &ans){
int min_h=MAX;
int max_h=-1;
ll error_value=0;
for(auto a:ans){
chmin(min_h,a.height());
chmax(max_h,a.height());
if(a.is_valid()==false) error_value+=1e5;
}
return error_value+(max_h-min_h);
}
void output(vector<Ans> ans){
for(auto a:ans){
cout<<a.middle.id+1<<" "<<a.bases[0].id+1<<" "<<a.bases[1].id+1<<" "<<a.top.id+1<<endl;
}
}
/*
1. validな解を作る
2. 最小(最大)の木を大きく(小さく)する近傍で遷移
*/
void solve(){
input();
make_valid_ans();
auto best_ans=ans;
auto best_score=evaluate(ans);
/*while(TIME.span()<1100){
auto ans=best_ans;
auto ids=Rand32.two(num_tree);
int type=Rand32(3);
if(type==0){
swap(ans[ids.first].bases,ans[ids.second].bases);
}else if(type==1){
swap(ans[ids.first].middle,ans[ids.second].middle);
}else{
swap(ans[ids.first].top,ans[ids.second].top);
}
int score=evaluate(ans);
if(score<best_score){
cerr<<best_score<<endl;
best_score=score;
best_ans=ans;
}
}*/
output(best_ans);
#ifndef ONLINE_JUDGE
testTimer.output();
testCounter.output();
cerr<<TIME.span()<<"ms"<<endl;
cerr<<"score: "<<evaluate(best_ans)<<endl;
#endif
}
int main(const int argc,const char** argv){
#ifndef OPTUNA
if(argc!=1){
}
#endif
FastIO();
int T=1;
//cin>>T;
while(T--) solve();
}