結果

問題 No.5016 Worst Mayor
ユーザー FplusFplusFFplusFplusF
提出日時 2023-04-29 15:20:49
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 1,372 ms / 2,000 ms
コード長 6,831 bytes
コンパイル時間 3,286 ms
コンパイル使用メモリ 242,264 KB
実行使用メモリ 155,624 KB
スコア 17,830,929,042
平均クエリ数 400.00
最終ジャッジ日時 2023-04-29 15:21:56
合計ジャッジ時間 65,410 ms
ジャッジサーバーID
（参考情報） 		judge11 / judge14
純コード判定しない問題か言語
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1,228 ms
155,224 KB
testcase_01 AC 1,240 ms
155,368 KB
testcase_02 AC 1,183 ms
154,928 KB
testcase_03 AC 1,282 ms
154,824 KB
testcase_04 AC 1,149 ms
155,200 KB
testcase_05 AC 1,202 ms
155,480 KB
testcase_06 AC 1,181 ms
155,128 KB
testcase_07 AC 1,352 ms
155,428 KB
testcase_08 AC 1,005 ms
154,900 KB
testcase_09 AC 952 ms
155,252 KB
testcase_10 AC 1,116 ms
155,208 KB
testcase_11 AC 1,333 ms
155,248 KB
testcase_12 AC 951 ms
155,220 KB
testcase_13 AC 1,326 ms
155,148 KB
testcase_14 AC 1,203 ms
155,096 KB
testcase_15 AC 1,128 ms
155,544 KB
testcase_16 AC 1,061 ms
155,516 KB
testcase_17 AC 912 ms
154,784 KB
testcase_18 AC 876 ms
155,468 KB
testcase_19 AC 958 ms
155,420 KB
testcase_20 AC 1,182 ms
155,252 KB
testcase_21 AC 985 ms
155,304 KB
testcase_22 AC 1,263 ms
155,416 KB
testcase_23 AC 885 ms
154,968 KB
testcase_24 AC 1,142 ms
154,920 KB
testcase_25 AC 1,292 ms
155,328 KB
testcase_26 AC 1,284 ms
154,968 KB
testcase_27 AC 1,030 ms
155,624 KB
testcase_28 AC 993 ms
155,352 KB
testcase_29 AC 1,154 ms
155,112 KB
testcase_30 AC 1,231 ms
155,368 KB
testcase_31 AC 1,275 ms
155,368 KB
testcase_32 AC 1,244 ms
155,428 KB
testcase_33 AC 1,154 ms
154,780 KB
testcase_34 AC 1,225 ms
155,152 KB
testcase_35 AC 1,058 ms
155,000 KB
testcase_36 AC 1,104 ms
154,904 KB
testcase_37 AC 1,180 ms
155,140 KB
testcase_38 AC 1,236 ms
155,248 KB
testcase_39 AC 1,333 ms
155,452 KB
testcase_40 AC 1,330 ms
154,916 KB
testcase_41 AC 1,372 ms
155,288 KB
testcase_42 AC 1,362 ms
155,156 KB
testcase_43 AC 1,074 ms
155,096 KB
testcase_44 AC 1,132 ms
155,252 KB
testcase_45 AC 1,164 ms
155,064 KB
testcase_46 AC 874 ms
154,896 KB
testcase_47 AC 1,206 ms
155,164 KB
testcase_48 AC 1,053 ms
155,152 KB
testcase_49 AC 967 ms
155,532 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
const int INF=1e9;
using pii=pair<int,int>;
using tii=tuple<int,int,int>;
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define all(v) v.begin(),v.end()
template<class T> void chmin(T &a,T b){
    if(a>b){
        a=b;
    }
}
template<class T> void chmax(T &a,T b){
    if(a<b){
        a=b;
    }
}
vector<int> pi={0,1,0,-1},pj={1,0,-1,0};
int to(int i,int j){
    return i*14+j;
}
pii back(int x){
    return {x/14,x%14};
}
struct input{
    int n,t;
    vector<int> s,g;
    void input_cin(){
        cin >> n >> t;
        s.resize(n);
        g.resize(n);
        rep(i,n){
            int a,b,c,d;
            cin >> a >> b >> c >> d;
            a--;
            b--;
            c--;
            d--;
            s[i]=to(a,b);
            g[i]=to(c,d);
        }
    }
}input;
struct solver{
    vector<vector<int>> people;
    vector<vector<int>> root(vector<vector<pii>> &g){
        vector<vector<int>> ret(14*14,vector<int>(14*14,0));
        rep(i,14*14){
            vector<int> dist(14*14,INF);
            vector<int> prev(14*14);
            priority_queue<pii> pq;
            dist[i]=0;
            pq.push({i,i});
            while(!pq.empty()){
                int x,d;
                tie(x,d)=pq.top();
                pq.pop();
                for(auto &[to,w]:g[x]){
                    if(dist[x]+w<dist[to]){
                        dist[to]=dist[x]+w;
                        prev[to]=x;
                        pq.push({to,dist[x]+w});
                    }
                }
            }
            rep(j,14*14){
                if(people[i][j]==0) continue;
                int now=j;
                while(now!=i){
                    ret[prev[now]][now]++;
                    now=prev[now];
                }
            }
        }
        return ret;
    }
    int score(vector<vector<pii>> &g){
        int ret=0;
        rep(i,14*14){
            vector<int> dist(14*14,INF);
            vector<int> prev(14*14);
            priority_queue<pii> pq;
            dist[i]=0;
            pq.push({i,i});
            while(!pq.empty()){
                int x,d;
                tie(x,d)=pq.top();
                pq.pop();
                for(auto &[to,w]:g[x]){
                    if(dist[x]+w<dist[to]){
                        dist[to]=dist[x]+w;
                        prev[to]=x;
                        pq.push({to,dist[x]+w});
                    }
                }
            }
            rep(j,14*14){
                if(people[i][j]==0) continue;
                int now=j,cnt=0;
                while(now!=i){
                    if(dist[now]-dist[prev[now]]==223) cnt++;
                    now=prev[now];
                }
                ret+=60*cnt*people[i][j];
            }
        }
        return ret;
    }
    void solve(){
        vector<vector<pii>> g(14*14);
        rep(i,14){
            rep(j,14){
                rep(k,4){
                    int ti=i+pi[k],tj=j+pj[k];
                    if(ti<0||14<=ti||tj<0||14<=tj) continue;
                    g[to(i,j)].emplace_back(to(ti,tj),1000);
                }
            }
        }
        people.resize(14*14);
        rep(i,14*14) people[i].resize(14*14,0);
        rep(i,input.n){
            people[input.s[i]][input.g[i]]++;
        }
        
        int x=50;
        vector<int> score_sum(x+1,0);
        vector<pii> v(x);
        vector<vector<bool>> built(14*14,vector<bool>(14*14,false));
        int ns=-1,ng=-1;
        rep(r,x){
            vector<vector<int>> cnt=root(g);
            int max_cnt=0,ts=-1,tg=-1;
            rep(i,14*14){
                rep(j,14*14){
                    if(cnt[i][j]==0) continue;
                    if(built[i][j]) continue;
                    if(max_cnt<cnt[i][j]){
                        max_cnt=cnt[i][j];
                        ts=i;
                        tg=j;
                    }
                }
            }
            if(ts==-1||tg==-1) break;
            for(auto &[to,w]:g[ts]){
                if(to==tg) w=223;
            }
            for(auto &[to,w]:g[tg]){
                if(to==ts) w=223;
            }
            score_sum[r+1]=score(g);
            ns=ts;
            ng=tg;
            built[ns][ng]=true;
            built[ng][ns]=true;
            v[r]={ns,ng};
        }
        vector<vector<vector<int>>> dp(input.t+1,vector<vector<int>>(input.t+1,vector<int>(x,-INF)));
        vector<vector<vector<tii>>> prev(input.t+1,vector<vector<tii>>(input.t+1,vector<tii>(x)));
        dp[0][1][0]=1e6;
        rep(i,input.t){
            rep(j,input.t+1){
                rep(k,x){
                    if(dp[i][j][k]==-INF) continue;
                    if(0<j&&k+1<x){
                        int cost=1e7/sqrt(j);
                        if(cost<=dp[i][j][k]&&dp[i+1][j][k+1]<dp[i][j][k]-cost+score_sum[k+1]){
                            dp[i+1][j][k+1]=dp[i][j][k]-cost+score_sum[k];
                            prev[i+1][j][k+1]={i,j,k};
                        }
                    }
                    if(j+1<input.t){
                        if(dp[i+1][j+1][k]<dp[i][j][k]+score_sum[k]){
                            dp[i+1][j+1][k]=dp[i][j][k]+score_sum[k];
                            prev[i+1][j+1][k]={i,j,k};
                        }
                    }
                    if(dp[i+1][j][k]<dp[i][j][k]+50000+score_sum[k]){
                        dp[i+1][j][k]=dp[i][j][k]+50000+score_sum[k];
                        prev[i+1][j][k]={i,j,k};
                    }
                }
            }
        }
        int max_score=-INF,ni=input.t,nj=-1,nk=-1;
        rep(i,input.t+1){
            rep(j,x){
                if(max_score<dp[input.t][i][j]){
                    max_score=dp[input.t][i][j];
                    nj=i;
                    nk=j;
                }
            }
        }
        vector<int> ans;
        while(ni!=0){
            int ti,tj,tk;
            tie(ti,tj,tk)=prev[ni][nj][nk];
            if(tk!=nk){
                ans.push_back(0);
            }else if(tj!=nj){
                ans.push_back(1);
            }else{
                ans.push_back(2);
            }
            ni=ti;
            nj=tj;
            nk=tk;
        }
        reverse(all(ans));
        int now=0;
        rep(i,input.t){
            int cin_u,cin_v;
            cin >> cin_u >> cin_v;
            if(ans[i]==0){
                int s,t;
                tie(s,t)=v[now];
                int o,p,q,r;
                tie(o,p)=back(s);
                tie(q,r)=back(t);
                cout << ans[i]+1 << " " << o+1 << " " << p+1 << " " << q+1 << " " << r+1 << endl;
                now++;
            }else{
                cout << ans[i]+1 << endl;
            }
        }
    }
}solver;
int main(){
    input.input_cin();
    solver.solve();
}
0