結果

問題 No.1596 Distance Sum in 2D Plane
ユーザー 2 n2 n
提出日時 2021-07-09 21:54:30
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 67 ms / 2,000 ms
コード長 6,037 bytes
コンパイル時間 4,012 ms
コンパイル使用メモリ 186,340 KB
実行使用メモリ 7,936 KB
最終ジャッジ日時 2024-07-01 16:12:37
合計ジャッジ時間 5,965 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 13 ms
7,936 KB
testcase_01 AC 13 ms
7,808 KB
testcase_02 AC 66 ms
7,936 KB
testcase_03 AC 67 ms
7,936 KB
testcase_04 AC 67 ms
7,936 KB
testcase_05 AC 65 ms
7,936 KB
testcase_06 AC 66 ms
7,808 KB
testcase_07 AC 66 ms
7,936 KB
testcase_08 AC 67 ms
7,808 KB
testcase_09 AC 67 ms
7,936 KB
testcase_10 AC 67 ms
7,936 KB
testcase_11 AC 56 ms
7,808 KB
testcase_12 AC 57 ms
7,936 KB
testcase_13 AC 56 ms
7,936 KB
testcase_14 AC 13 ms
7,936 KB
testcase_15 AC 13 ms
7,936 KB
testcase_16 AC 13 ms
7,936 KB
testcase_17 AC 13 ms
7,936 KB
testcase_18 AC 13 ms
7,808 KB
testcase_19 AC 13 ms
7,808 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp:123: warning: "dbg" redefined
  123 | #define dbg(x) (x)
      | 
main.cpp:120: note: this is the location of the previous definition
  120 | #define dbg(x) (debug_h(__FILE__, __LINE__, "" #x),dbg_(x))
      | 
main.cpp:124: warning: "debug" redefined
  124 | #define debug(...) ((void)0)
      | 
main.cpp:117: note: this is the location of the previous definition
  117 | #define debug(...) (debug_h(__FILE__, __LINE__, "" #__VA_ARGS__),debug_(__VA_ARGS__))
      | 
main.cpp:126: warning: "clk" redefined
  126 | #define clk(...) ((void)0)
      | 
main.cpp:121: note: this is the location of the previous definition
  121 | #define clk(...) (cerr << __VA_ARGS__ " @ " << (clock()-clock0) <<endl,(void)0)
      |

ソースコード

diff # 

#pragma GCC target("avx2")
//#pragma GCC target("avx")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("O3")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")

// #include<bits/stdc++.h>

// #include <array>
#include <vector>
// #include <list>
// #include <forward_list>
#include <deque>
#include <queue>
#include <stack>

// #include <bitset>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <set>

#include <algorithm>

#include <string>
#include <iostream>
#include <iomanip>
// #include <sstream>

// #include <bit>
// #include <complex>
// #include <exception>
// #include <fstream>
// #include <functional>
// #include <iosfwd>
// #include <iterator>
// #include <limits>
// #include <locale>
// #include <memory>
// #include <new>
// #include <numeric>
// #include <stdexcept>
// #include <typeinfo>
// #include <utility>
// #include <valarray>
// #include <atomic>
// #include <chrono>
// #include <condition_variable>
// #include <future>
// #include <mutex>
// #include <random>
// #include <ratio>
// #include <regex>
// #include <scoped_allocator>
// #include <system_error>
// #include <thread>
// #include <tuple>
// #include <typeindex>
// #include <type_traits>

// #include <cctype>
// #include <cerrno>
// #include <cfloat>
// #include <ciso646>
// #include <climits>
// #include <clocale>
// #include <cmath>
// #include <csetjmp>
// #include <csignal>
// #include <cstdarg>
// #include <cstddef>
// #include <cstdio>
// #include <cstdlib>
// #include <cstring>
#include <ctime>
// #include <ccomplex>
// #include <cfenv>
// #include <cinttypes>
// #include <cstdbool>
// #include <cstdint>
// #include <ctgmath>
// #include <cwchar>
// #include <cwctype>

using namespace std;
#include <atcoder/all>
using namespace atcoder;

#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)

using ll = long long;
using ull = unsigned long long;
template<typename T> using maxque = priority_queue<T>;
template<typename T> using minque = priority_queue<T,vector<T>,greater<T>>;
#define int ll
#define endl "\n"
#define unless(cond) if(!(cond))
#define until(cond) while(!(cond))
#define rep(i,s,e) for(ll i = (s); i < (e); ++i)
#define repR(i,s,e) for(ll i = (e)-1; (s) <= i; --i)
#define repE(i,s,e) for(ll i = (s); i <= (e); ++i)
#define repER(i,s,e) for(ll i = (e); (s) <= i; --i)
#define repSubsetR(set,super) for(ll _super=super,set = _super; 0 <= set; --set)if(set &= _super, true)
#define ALL(xs) (xs).begin(), (xs).end()
#define ALLR(xs) (xs).rbegin(), (xs).rend()
#define ALLC(xs) (xs).cbegin(), (xs).cend()
#define ALLCR(xs) (xs).crbegin(), (xs).crend()
template<typename C> void uniq(C &xs){ xs.erase(unique(ALL(xs)), xs.end()); }
template<typename C> constexpr ll len(C &&xs){ return size(forward<C>(xs)); }
ll BIT(ll n){ return 1LL<<n; }

auto clock0 = clock();
void debug_h(const char *file, signed line, const char *str_args){ cerr << file << ":" << line << ":    " << str_args << "  =>  "; }
template<class X, class... Xs> void debug_(const X &x, const Xs&... xs){ cerr << x; (void)initializer_list<int>{ (cerr << ", " << xs,0)... };cerr << endl; }void debug_(){ cerr << endl; }
#define debug(...) (debug_h(__FILE__, __LINE__, "" #__VA_ARGS__),debug_(__VA_ARGS__))
#define ASSERT(pred,...) (static_cast<bool>(pred) ? void(0) : (debug_h(__FILE__, __LINE__, "ASSERT FAIL!   " #pred ";   " #__VA_ARGS__),debug_(__VA_ARGS__),exit(1)))
template<class X> X &&dbg_(X &&x){ cerr<<x<<endl; return forward<X>(x); }
#define dbg(x) (debug_h(__FILE__, __LINE__, "" #x),dbg_(x))
#define clk(...) (cerr << __VA_ARGS__ " @ " << (clock()-clock0) <<endl,(void)0)
#ifndef DEBUG
#define dbg(x) (x)
#define debug(...) ((void)0)
//#define ASSERT(pred,...) ((void)0)
#define clk(...) ((void)0)
#endif

template<class C> auto operator<<(ostream &os, const C &xs) -> enable_if_t<!is_same_v<typename iterator_traits<decltype(begin(xs))>::value_type,char>,ostream&> { os<<"[ "; for(auto&&x:xs)os<<x<<", "; return os<<"]"; }
template<typename MINT, typename = internal::is_modint_t<MINT>> ostream &operator<<(ostream &out, MINT x){ return out << x.val(); }

template<typename F> struct Fix : F {
    template<typename G> Fix(G &&g) : F{forward<G>(g)} {}
    template<typename... Xs> decltype(auto) operator()(Xs&&... xs)const{ return F::operator()(*this, forward<Xs>(xs)...); }
};
template<typename F> Fix(F&&) -> Fix<decay_t<F>>;

template<typename T,typename U> bool chmin(T &a, U b){ if(a <= b)return false; a = b; return true; }
template<typename T,typename U> bool chmax(T &a, U b){ if(a >= b)return false; a = b; return true; }

//const signed MOD = 998244353;
const signed MOD = 1000000007; // 10^9+7
using mint = static_modint<MOD>;
// using mint = dynamic_modint<-1>; // mint::set_mod(mod);
// using mint0 = dynamic_modint<0>; // mint0::set_mod(mod);

const ll INF = BIT(60);



const ll N_FACT = 400001;
struct fact_{
    mint ys[N_FACT];
    mint rs[N_FACT];
    fact_(){
        vector<mint> inv(len(ys));
        ys[0] = 1;
        rs[0] = 1;
        inv[1] = 1;
        rep(i,1,len(ys)){
            ys[i] = ys[i-1]*i;
            if(1<i) inv[i] = -inv[MOD%i] * (MOD/i);
            rs[i] = rs[i-1]*inv[i];
        }
    }
    mint operator()(ll i){ return ys[i]; }
    mint inv(ll i){ return rs[i]; }
} fact;
mint cmb(ll a,ll b){ return fact(a+b)*fact.inv(a)*fact.inv(b); }
ll solve(){
    ll n,m;cin>>n>>m;
    mint ans=cmb(n,n)*2*n;
    rep(i,0,m){
        ll t,x,y;cin>>t>>x>>y;
        switch(t){
            case 1:
                ans -= cmb(x,y)*cmb(n-x-1,n-y);
                break;
            case 2:
                ans -= cmb(x,y)*cmb(n-x,n-y-1);
                break;
        }
    }
    return ans.val();
}

signed main(){
    cin.tie(nullptr);ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    try{
        cout << solve() << endl;
        return 0;
    }catch(exception& e){
        cerr << e.what() << endl;
    }catch(char *s){
        cerr << s << endl;
    }
    return 1;
}
0