#1182504 (C++23) No.3668 Minimum Cut

• 問題: No.3668 Minimum Cut
• ユーザー: Taiki0715
• 提出日時: 2026-09-04 22:49:34
• 言語: C++23 (gcc 15.3.0 + boost 1.92.0)
• 結果: TLE
• 実行時間: -
• コード長: 12,088 bytes
• コンパイル時間: 5,351 ms
• コンパイル使用メモリ: 348,592 KB
• 実行使用メモリ: 9,764 KB
• 最終ジャッジ日時: 2026-09-04 23:01:04
• 合計ジャッジ時間: 8,075 ms
• ジャッジサーバーID （参考情報）: judge5_0 / judge1_1

ファイルパターン	結果
sample	AC * 3
other	AC * 21 TLE * 1 -- * 17

ソースコード

#include <bits/stdc++.h>
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream&,pair<T1,T2>&);
template<typename...Args>istream &operator>>(istream&,tuple<Args...>&a);
template<typename T>istream &operator>>(istream&is,vector<T>&a);
template<typename T,size_t N>istream &operator>>(istream&is,array<T,N>&a);
template<typename T1,typename T2>
istream &operator>>(istream&is,pair<T1,T2>&a){
  is>>a.first>>a.second;
  return is;
}
template<size_t pos,typename...Args>
void read_tuple(istream&is,tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    is>>get<pos>(a);
    read_tuple<pos+1>(is,a);
  }
}
template<typename...Args>
istream &operator>>(istream&is,tuple<Args...>&a){
  read_tuple<0>(is,a);
  return is;
}
template<typename T>
istream &operator>>(istream&is,vector<T>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T,size_t N>
istream &operator>>(istream&is,array<T,N>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T1,typename T2>ostream &operator<<(ostream&os,const pair<T1,T2>&);
template<typename...Args>ostream &operator<<(ostream&os,const tuple<Args...>&);
template<typename T>ostream &operator<<(ostream&os,const vector<T>&);
template<typename T,typename Seq,typename Comp>ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>);
template<typename T>ostream &operator<<(ostream&os,queue<T>);
template<typename T>ostream &operator<<(ostream&os,deque<T>);
template<typename T>ostream &operator<<(ostream&os,stack<T>);
template<typename T,size_t N>ostream &operator<<(ostream&os,const array<T,N>&);
template<typename Key,typename Val,typename Comp>ostream &operator<<(ostream&os,const map<Key,Val,Comp>&);
template<typename Key,typename Val,typename Hash>ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const set<T,Comp>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const multiset<T,Comp>&);
template<typename T,typename Hash>ostream &operator<<(ostream&os,const unordered_set<T,Hash>&);
template<typename T1,typename T2>
ostream &operator<<(ostream&os,const pair<T1,T2>&a){
  os<<a.first<<' '<<a.second;
  return os;
}
template<size_t pos,typename...Args>
void write_tuple(ostream&os,const tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    if constexpr(pos>0)os<<' ';
    os<<get<pos>(a);
    write_tuple<pos+1>(os,a);
  }
}
template<typename...Args>
ostream &operator<<(ostream&os,const tuple<Args...>&a){
  write_tuple<0>(os,a);
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,const vector<T>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename T,typename Seq,typename Comp>
ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,queue<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,deque<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop_front();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop_front();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,stack<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T,size_t N>
ostream &operator<<(ostream&os,const array<T,N>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Comp>
ostream &operator<<(ostream&os,const map<Key,Val,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Hash>
ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const set<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const multiset<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Hash>
ostream &operator<<(ostream&os,const unordered_set<T,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
using namespace std;
using ll=long long;
using ull=unsigned long long;
using P=pair<ll,ll>;
template<typename T>using minque=priority_queue<T,vector<T>,greater<T>>;
template<typename T>bool chmax(T &a,const T &b){return (a<b?(a=b,true):false);}
template<typename T>bool chmin(T &a,const T &b){return (a>b?(a=b,true):false);}
template<typename T1,typename T2>void operator++(pair<T1,T2>&a,int){a.first++,a.second++;}
template<typename T1,typename T2>void operator--(pair<T1,T2>&a,int){a.first--,a.second--;}
template<typename T>void operator++(vector<T>&a,int){for(auto &i:a)i++;}
template<typename T>void operator--(vector<T>&a,int){for(auto &i:a)i--;}
#define overload3(_1,_2,_3,name,...) name
#define rep1(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,l,r) for(int i=(int)(l);i<(int)(r);i++)
#define rep(...) overload3(__VA_ARGS__,rep2,rep1)(__VA_ARGS__)
#define reps(i,l,r) rep2(i,l,r)
#define all(x) x.begin(),x.end()
#define pcnt(x) __builtin_popcountll(x)
#define fin(x) return cout<<(x)<<'\n',static_cast<void>(0)
#define yn(x) cout<<((x)?"Yes\n":"No\n")
#define uniq(x) sort(all(x)),x.erase(unique(all(x)),x.end())
template<typename T>
inline int fkey(vector<T>&z,T key){return lower_bound(z.begin(),z.end(),key)-z.begin();}
ll myceil(ll a,ll b){return (a+b-1)/b;}
template<typename T,size_t n,size_t id=0>
auto vec(const int (&d)[n],const T &init=T()){
  if constexpr (id<n)return vector(d[id],vec<T,n,id+1>(d,init));
  else return init;
}
#ifdef LOCAL
#include<debug.h>
#define SWITCH(a,b) (a)
#else
#define debug(...) static_cast<void>(0)
#define debugg(...) static_cast<void>(0)
#define SWITCH(a,b) (b)
#endif
struct Timer{
  clock_t start;
  Timer(){
    start=clock();
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout<<fixed<<setprecision(16);
  }
  inline double now(){return (double)(clock()-start)/1000;}
  #ifdef LOCAL
  ~Timer(){
    cerr<<"time:";
    cerr<<now();
    cerr<<"ms\n";
  }
  #endif
}timer;
void SOLVE();
int main(){
  int testcase=1;
  //cin>>testcase;
  for(int i=0;i<testcase;i++){
    SOLVE();
  }
}
#include<type_traits>
template<typename T>
struct csr_array{
private:
  std::vector<int>ptr;
  std::vector<T>dat;
public:
  using iterator=typename std::vector<T>::iterator;
  using const_iterator=typename std::vector<T>::const_iterator;
  struct csr{
    iterator l,r;
    iterator begin(){return l;}
    iterator end(){return r;}
    int size()const{return r-l;}
    T &operator[](int i)const{return l[i];}
  };
  struct const_csr{
    const_iterator l,r;
    const_iterator begin(){return l;}
    const_iterator end(){return r;}
    int size()const{return r-l;}
    const T &operator[](int i)const{return l[i];}
  };
  csr_array():ptr{0}{}
  csr_array(int n,const std::vector<std::pair<int,T>>&a):ptr(n+1),dat(a.size()){
    for(const auto&[k,v]:a)ptr[k]++;
    for(int i=1;i<=n;i++)ptr[i]+=ptr[i-1];
    for(int i=std::ssize(a);i--;)dat[--ptr[a[i].first]]=a[i].second;
  }
  explicit csr_array(int n,const std::vector<int>&a):ptr(n+1),dat(a.size()){
    static_assert(std::is_same_v<T,int>);
    for(const int&x:a)ptr[x]++;
    for(int i=1;i<=n;i++)ptr[i]+=ptr[i-1];
    for(int i=std::ssize(a);i--;)dat[--ptr[a[i]]]=i;
  }
  csr operator[](int i){return csr{dat.begin()+ptr[i],dat.begin()+ptr[i+1]};}
  const_csr operator[](int i)const{return const_csr{dat.begin()+ptr[i],dat.begin()+ptr[i+1]};}
  iterator begin(){return dat.begin();}
  iterator end(){return dat.end();}
  const_iterator begin()const{return dat.begin();}
  const_iterator end()const{return dat.end();}
  int size()const{return std::ssize(ptr)-1;}
};
template<typename T>
struct Dinic{
private:
  struct edge{
    int to,rev;
    T cap;
  };
  int n;
  csr_array<edge>g;
  std::vector<std::pair<int,edge>>init_csr;
  std::vector<std::pair<int,int>>pos;
  std::vector<int>deg;
  template<typename T2>
  struct Q{
    std::vector<T2>data;
    int p;
    Q():p(0){}
    void push(T2 x){
      data.push_back(x);
    }
    int front()const{
      return data[p];
    }
    void pop(){p++;}
    void clear(){
      data.clear();
      p=0;
    }
    bool empty()const{
      return p==data.size();
    }
  };
public:
  Dinic():n(0){}
  Dinic(int n):n(n),deg(n){}
  void add_edge(int u,int v,T cap){
    assert(0<=u&&u<n);
    assert(0<=v&&v<n);
    pos.push_back({u,deg[u]});
    int f=deg[u];
    int t=deg[v];
    if(u==v)t++;
    init_csr.emplace_back(u,edge{v,t,cap});
    init_csr.emplace_back(v,edge{u,f,0});
    deg[u]++,deg[v]++;
  }
  struct E{
    int from,to;
    T cap,flow;
  };
  std::vector<E>edges()const{
    int m=pos.size();
    std::vector<E>ret(m);
    for(int i=0;i<m;i++){
      edge e=g[pos[i].first][pos[i].second];
      edge r=g[e.to][e.rev];
      ret[i]={pos[i].first,e.to,e.cap+r.cap,r.cap};
    }
    return ret;
  }
  T flow(int s,int t,T limit){
    assert(0<=s&&s<n);
    assert(0<=t&&t<n);
    g=csr_array<edge>(n,init_csr);
    std::vector<int>level(n),iter(n);
    Q<int>que;
    auto bfs=[&](){
      std::fill(level.begin(),level.end(),-1);
      level[s]=0;
      que.clear();
      que.push(s);
      while(!que.empty()){
        int x=que.front();
        que.pop();
        for(auto e:g[x]){
          if(e.cap==0||level[e.to]>=0)continue;
          level[e.to]=level[x]+1;
          if(e.to==t)return;
          que.push(e.to);
        }
      }
    };
    auto dfs=[&](auto self,int v,T up)->T {
      if(v==s)return up;
      T ret=0;
      int lv=level[v];
      for(int &i=iter[v];i<(int)g[v].size();i++){
        edge e=g[v][i];
        if(lv<=level[e.to]||g[e.to][e.rev].cap==0)continue;
        T d=self(self,e.to,std::min(up-ret,g[e.to][e.rev].cap));
        if(d<=0)continue;
        g[v][i].cap+=d;
        g[e.to][e.rev].cap-=d;
        ret+=d;
        if(ret==up)return ret;
      }
      level[v]=n;
      return ret;
    };
    T flow=0;
    while(flow<limit){
      bfs();
      if(level[t]==-1)break;
      std::fill(iter.begin(),iter.end(),0);
      T f=dfs(dfs,t,limit-flow);
      if(!f)break;
      flow+=f;
    }
    init_csr.clear();
    for(int i=0;i<n;i++){
      for(const edge&e:g[i])init_csr.emplace_back(i,e);
    }
    return flow;
  }
  T flow(int s,int t){
    return flow(s,t,std::numeric_limits<T>::max());
  }
  std::vector<bool>min_cut(int s){
    assert(0<=s&&s<n);
    std::vector<bool>ret(n,false);
    Q<int>que;
    que.push(s);
    while(!que.empty()){
      int x=que.front();
      que.pop();
      ret[x]=true;
      for(auto e:g[x]){
        if(e.cap&&!ret[e.to]){
          ret[e.to]=true;
          que.push(e.to);
        }
      }
    }
    return ret;
  }
};
void SOLVE(){
  int n,m,s,t;
  cin>>n>>m>>s>>t;
  s--,t--;
  Dinic<ll>g(n);
  rep(i,m){
    int a,b,c;
    cin>>a>>b>>c;
    a--,b--;
    g.add_edge(a,b,c);
  }
  cout<<g.flow(s,t)<<endl;
}