結果

問題 No.177 制作進行の宮森あおいです！
ユーザー sirogamichan1
提出日時 2021-03-05 00:19:09
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 3 ms / 2,000 ms
コード長 4,999 bytes
コンパイル時間 6,333 ms
コンパイル使用メモリ 359,860 KB
実行使用メモリ 6,820 KB
最終ジャッジ日時 2024-10-05 14:33:31
合計ジャッジ時間 4,857 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 13
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

//////////////////////////////
// Check before you submit.
// #define _ATCODER_LIBRARY
const long long MOD = 1e9+7;
// const long long MOD = 998244353;
/////////////////////////////
#include <bits/stdc++.h>
using namespace std;
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
#ifdef _ATCODER_LIBRARY
#include <atcoder/all>
using namespace atcoder;
#endif
// _ATCODER_LIBRARY
const long long INF = 1LL << 60;
const double PI = acos(-1);
using ll = long long;
using P = array<ll, 2>;
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define SUM(v) accumulate(ALL(v),0ll)
template<typename T>istream& operator>>(istream&i,vector<T>&v){REP(j,v.size())i>>v[j];return i;}
template<typename T>string join(vector<T>&v){stringstream s;REP(i,v.size())s<<' '<<v[i];return s.str().substr(1);}
template<typename T>ostream& operator<<(ostream&o,vector<T>&v){if(v.size())o<<join(v);return o;}
template<typename T>string join(vector<vector<T>>&vv){string s="\n";REP(i,vv.size())s+=join(vv[i])+"\n";return s;}
template<typename T>ostream& operator<<(ostream&o,vector<vector<T>>&vv){if(vv.size())o<<join(vv);return o;}
template<typename T1,typename T2>istream& operator>>(istream&i,pair<T1,T2>&v){return i>>v.first>>v.second;}
template<typename T1,typename T2>ostream& operator<<(ostream&o,pair<T1,T2>&v){return o<<"("<<v.first<<","<<v.second<<")";}
template<typename T>istream& operator>>(istream&i,array<T,2>&v){i>>v[0]>>v[1]; return i;}
template<typename T>ostream& operator<<(ostream&o,array<T,2>&v){return o<<"("<<v[0]<<","<<v[1]<<")"; return o;}
#define DEBUG(x);
#ifdef _DEBUG
#define DEBUG(x) std::cerr << #x << " : " << (x) << std::endl;
#define GLIBCXX_DEBUG
#define GLIBCXX_DEBUG_PEDANTIC
#endif
// _DEBUG
int dx[4]{0, 1, 0, -1};
int dy[4]{1, 0, -1, 0};
void init_init_init() {ios_base::sync_with_stdio(false);cin.tie(NULL);std::cout<<fixed<<setprecision(10);}
template<class T>T up(T a, T b){assert(b);return (a+b-1)/b;}
template<typename... A>bool eq(A const&... a){auto t={a...};assert(t.size());auto tar=*t.begin();for(const auto&e:t)if(tar!=e)return false;return 
    true;}
template<class T>bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<class T>bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmax(T &a, initializer_list<T>l){return chmax(a,max(l));}
template<class T>bool chmin(T &a, initializer_list<T>l){return chmin(a,min(l));}
//////////////////////////////////////////////////////////////////
// My Library
//////////////////////////////////////////////////////////////////
template<typename T> class Dinic {
private:
    int V;
    vector<int> level,iter;
    void bfs(int s) {
        fill(level.begin(),level.end(),-1);
        queue<int> que;
        level[s] = 0;
        que.push(s);
        while(!que.empty()){
            int v = que.front();
            que.pop();
            for(auto& e : G[v]){
                if(e.cap > 0 && level[e.to] < 0){
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
        }
    }
    T dfs(int v,int t,T f) {
        if(v==t){
            return f;
        }
        for(int& i = iter[v]; i < (int)G[v].size(); i++){
            edge& e = G[v][i];
            if(e.cap > 0 && level[v] < level[e.to]){
                T d = dfs(e.to,t,min(f,e.cap));
                if(d > 0){
                    e.cap -= d;
                    G[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }
     
public:
    struct edge{
        int to;
        T cap;
        int rev;
    };
    vector<vector<edge> > G;
     
    Dinic(int node_size) : V(node_size), level(V), iter(V), G(V){}
    // Adding edge on a node.
    void add_edge(int from,int to,T cap) {
        G[from].push_back((edge){to,cap,(int)G[to].size()});
        G[to].push_back((edge){from,(T)0,(int)G[from].size()-1});
    }
    // Calculate the maximum flow.
    T solve(int s,int t) {
        T flow = 0;
        for(;;){
            bfs(s);
            if(level[t] < 0) return flow;
            fill(iter.begin(),iter.end(),0);
            T f;
            while((f=dfs(s,t,numeric_limits<T>::max())) > 0){
                flow += f;
            }
        }
    }
};
//////////////////////////////////////////////////////////////////
// Contest Code
//////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
    init_init_init();
    ll W, N; cin >> W >> N;
    vector<ll> J(N); cin >> J;
    ll M; cin >> M;
    vector<ll> C(M); cin >> C;
    vector<set<ll>> X(M);
    vector<ll> Q(M);
    REP(i, M)
    {
            cin >> Q[i];
            REP(j, Q[i])
            {
                    ll a; cin >> a;
                    --a;
                    X[i].insert(a);
            }
    }
    ll start = N*2 + M*2;
    ll goal = start + 1;
    Dinic<ll> max_flow(N*2+M*2+10);
    REP(i, N)
    {
            max_flow.add_edge(start, i, INF);
            max_flow.add_edge(i, i+N, J[i]);
    }
    DEBUG("pass");
    REP(i, N)
    {
            ll i2 = i+N;
            REP(j, M)
            {
                    if (X[j].count(i)) continue;
                    max_flow.add_edge(i2, 2*N+j, INF);
            }
    }
    DEBUG("pass2");
    REP(j, M)
    {
            ll to = 2*N+M+j;
            max_flow.add_edge(2*N+j, to, C[j]);
            max_flow.add_edge(to, goal, INF);
    }
    DEBUG("pass3");
    if (max_flow.solve(start, goal) >= W)
            std::cout << "SHIROBAKO"<< std::endl;
    else
            std::cout << "BANSAKUTSUKITA"<< std::endl;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0