Submission #389649

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
389649	2021-04-14T10:38:29 Z	2qbingxuan	Permutation Recovery (info1cup17_permutation)	C++14	Compilation error	0 ms	0 KB

permutation

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb emplace_back
#define AI(i) begin(i), end(i)
template<class T> bool chmin(T &a, T b) { return b < a && (a = b, true); }
template<class T> bool chmax(T &a, T b) { return a < b && (a = b, true); }
#ifdef KEV
#define DE(args...) kout("[ " + string(#args) + " ] = ", args)
void kout() { cerr << endl; }
template<class T, class ...U> void kout(T a, U ...b) { cerr << a << ' ', kout(b...); }
template<class T> void debug(T l, T r) { while (l != r) cerr << *l << " \n"[next(l)==r], ++l; }
#else
#define DE(...) 0
#define debug(...) 0
#endif
 
unsigned mrand() {
	static unsigned x = 12323421;
	return (++x) *= 0xdefaced;
}
 
const ll MAX_N = 100000, BD = 1e18, WID = 18, MAX_D = 65;
 
 
struct BigInteger : vector<int> {
    static constexpr int base = 1000000000;
    static constexpr int width = 9;
    BigInteger() {}
    explicit BigInteger(int x) : vector<int>{x} {}
    friend istream & operator>>(istream &I, BigInteger &n) {
        string s;
        I >> s;
        n.reserve(s.size() / 9);
        reverse(s.begin(), s.end());
        int cur = 0, cnt = 0, p = 1;
        for (char c: s) {
            cur = cur + (c - '0') * p;
            if (++cnt == width) {
                n.emplace_back(cur);
                cur = 0;
                cnt = 0;
                p = 1;
            } else {
                p *= 10;
            }
        }
        if (cnt)
            n.emplace_back(cur);
        return I;
    }
    BigInteger& operator+=(const BigInteger &rhs) {
        if (size() < rhs.size()) resize(rhs.size());
        int carry = 0;
        for (size_t i = 0; i < size(); i++) {
            at(i) += (i < rhs.size() ? rhs[i] : 0) + carry;
            carry = at(i) / base;
            at(i) %= base;
        }
        if (carry)
            push_back(carry);
        return *this;
    }
    BigInteger& operator-=(const BigInteger &rhs) {
        int carry = 0;
        for (size_t i = 0; i < size(); i++) {
            at(i) -= (i < rhs.size() ? rhs[i] : 0) + carry;
            if (at(i) < 0) {
                at(i) += base;
                carry = 1;
            } else {
                carry = 0;
            }
        }
        while (!empty() && back() == 0) pop_back();
        return *this;
    }
    friend bool operator<(const BigInteger &x, const BigInteger &y) {
        if (x.size() != y.size()) return x.size() < y.size();
        if (x.empty()) return false;
        for (int i = x.size()-1; i >= 0; i--)
            if (x[i] != y[i])
                return x[i] < y[i];
        return false;
    }
    friend bool operator>=(const BigInteger &x, const BigInteger &y) { return !(x < y); }
    friend bool operator>(const BigInteger &x, const BigInteger &y) { return y < x; }
    friend bool operator<=(const BigInteger &x, const BigInteger &y) { return !(y < x); }
    friend BigInteger operator+(BigInteger a, const BigInteger &b) {
        return a += b;
    }
    friend BigInteger operator-(BigInteger a, const BigInteger &b) {
        return a -= b;
    }
    friend ostream & operator<<(ostream &O, BigInteger n) {
        return O << n[0];
    }
};

using mint = BigInteger;
 
struct node {
	mint sum, val;
	int l, r;
	unsigned pri;
	int ind;
}room[MAX_N];
 
int new_mem(mint val = 0, int ind = 0) {
	static int mem;
	room[++mem] = {val, val, 0, 0, mrand(), ind};
	return mem;
}
 
#define P(i) room[i].pri
#define L(i) room[i].l
#define R(i) room[i].r
#define S(i) room[i].sum
#define V(i) room[i].val
#define ID(i) room[i].ind
 
void upd(int ind) {
	S(ind) = S(L(ind)) + S(R(ind)) + V(ind);
}
 
int merge(int a, int b) {
	if (a == 0) return b;
	if (b == 0) return a;
	if (P(a) < P(b)) {
		R(a) = merge(R(a), b);
		upd(a);
		return a;
	}
	else {
		L(b) = merge(a, L(b));
		upd(b);
		return b;
	}
}
 
void split(int root, mint sum, int &a, int &b) {
	if (root == 0) {
		a = b = 0;
		return;
	}
	if (S(L(root)) + V(root) <= sum) {
		sum -= S(L(root)) + V(root);
		a = root;
		split(R(root), sum, R(a), b);
		upd(a);
	}
	else {
		b = root;
		split(L(root), sum, a, L(b));
		upd(b);
	}
}
vector<int> order;
void dfs(int now) {
	if (now == 0) return;
	dfs(L(now));
	order.pb(ID(now));
	dfs(R(now));
}
 
int32_t main() {
	ios_base::sync_with_stdio(0), cin.tie(0);
 
	int n;
	cin >> n;
 
	vector<mint> val(n);
 
	{
		vector<string> inp(n);
		for (auto &i : inp) cin >> i;
 
		for (int i = 0;i < n;++i)
			val[i] = mint(inp[i]);
	}
 
//	for (mint &a : val) {
// 
//		string v;
//		cin >> v;
//		a = mint(v);
//	}
 
	for (int i = n-1;i > 0;--i) {
		val[i] -= val[i-1];
	}
 
	int root = 0;
 
	for (int i = 0;i < n;++i) {
 
		mint v = val[i] - 1;
 
		int a, b;
 
		split(root, v, a, b);
 
		int now = new_mem(val[i]);
 
		ID(now) = i;
 
		root = merge(a, merge(now, b));
 
	}
 
	dfs(root);
 
	vector<int> ans(n);
	for (int i = 0;i < n;++i) {
		int id = order[i];
		ans[id] = i+1;
	}
 
	for (int i = 0;i < n;++i)
		cout << ans[i] << " \n"[i+1==n];
}

Compilation message

permutation.cpp:110:38: error: could not convert '0' from 'int' to 'mint' {aka 'BigInteger'}
  110 | int new_mem(mint val = 0, int ind = 0) {
      |                                      ^
      |                                      |
      |                                      int
permutation.cpp: In function 'int32_t main()':
permutation.cpp:180:24: error: no matching function for call to 'BigInteger::BigInteger(__gnu_cxx::__alloc_traits<std::allocator<std::__cxx11::basic_string<char> >, std::__cxx11::basic_string<char> >::value_type&)'
  180 |    val[i] = mint(inp[i]);
      |                        ^
permutation.cpp:31:14: note: candidate: 'BigInteger::BigInteger(int)'
   31 |     explicit BigInteger(int x) : vector<int>{x} {}
      |              ^~~~~~~~~~
permutation.cpp:31:29: note:   no known conversion for argument 1 from '__gnu_cxx::__alloc_traits<std::allocator<std::__cxx11::basic_string<char> >, std::__cxx11::basic_string<char> >::value_type' {aka 'std::__cxx11::basic_string<char>'} to 'int'
   31 |     explicit BigInteger(int x) : vector<int>{x} {}
      |                         ~~~~^
permutation.cpp:30:5: note: candidate: 'BigInteger::BigInteger()'
   30 |     BigInteger() {}
      |     ^~~~~~~~~~
permutation.cpp:30:5: note:   candidate expects 0 arguments, 1 provided
permutation.cpp:27:8: note: candidate: 'BigInteger::BigInteger(const BigInteger&)'
   27 | struct BigInteger : vector<int> {
      |        ^~~~~~~~~~
permutation.cpp:27:8: note:   no known conversion for argument 1 from '__gnu_cxx::__alloc_traits<std::allocator<std::__cxx11::basic_string<char> >, std::__cxx11::basic_string<char> >::value_type' {aka 'std::__cxx11::basic_string<char>'} to 'const BigInteger&'
permutation.cpp:27:8: note: candidate: 'BigInteger::BigInteger(BigInteger&&)'
permutation.cpp:27:8: note:   no known conversion for argument 1 from '__gnu_cxx::__alloc_traits<std::allocator<std::__cxx11::basic_string<char> >, std::__cxx11::basic_string<char> >::value_type' {aka 'std::__cxx11::basic_string<char>'} to 'BigInteger&&'
permutation.cpp:198:19: error: no match for 'operator-' (operand types are '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} and 'int')
  198 |   mint v = val[i] - 1;
In file included from /usr/include/c++/9/bits/stl_algobase.h:67,
                 from /usr/include/c++/9/bits/char_traits.h:39,
                 from /usr/include/c++/9/ios:40,
                 from /usr/include/c++/9/istream:38,
                 from /usr/include/c++/9/sstream:38,
                 from /usr/include/c++/9/complex:45,
                 from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/stl_iterator.h:415:5: note: candidate: 'template<class _IteratorL, class _IteratorR> decltype ((__y.base() - __x.base())) std::operator-(const std::reverse_iterator<_Iterator>&, const std::reverse_iterator<_IteratorR>&)'
  415 |     operator-(const reverse_iterator<_IteratorL>& __x,
      |     ^~~~~~~~
/usr/include/c++/9/bits/stl_iterator.h:415:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::reverse_iterator<_Iterator>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/bits/stl_algobase.h:67,
                 from /usr/include/c++/9/bits/char_traits.h:39,
                 from /usr/include/c++/9/ios:40,
                 from /usr/include/c++/9/istream:38,
                 from /usr/include/c++/9/sstream:38,
                 from /usr/include/c++/9/complex:45,
                 from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/stl_iterator.h:1212:5: note: candidate: 'template<class _IteratorL, class _IteratorR> decltype ((__x.base() - __y.base())) std::operator-(const std::move_iterator<_IteratorL>&, const std::move_iterator<_IteratorR>&)'
 1212 |     operator-(const move_iterator<_IteratorL>& __x,
      |     ^~~~~~~~
/usr/include/c++/9/bits/stl_iterator.h:1212:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::move_iterator<_IteratorL>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/complex:357:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&, const std::complex<_Tp>&)'
  357 |     operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/9/complex:357:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::complex<_Tp>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/complex:366:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&, const _Tp&)'
  366 |     operator-(const complex<_Tp>& __x, const _Tp& __y)
      |     ^~~~~~~~
/usr/include/c++/9/complex:366:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::complex<_Tp>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/complex:375:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator-(const _Tp&, const std::complex<_Tp>&)'
  375 |     operator-(const _Tp& __x, const complex<_Tp>& __y)
      |     ^~~~~~~~
/usr/include/c++/9/complex:375:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   mismatched types 'const std::complex<_Tp>' and 'int'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:54,
                 from permutation.cpp:2:
/usr/include/c++/9/complex:452:5: note: candidate: 'template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&)'
  452 |     operator-(const complex<_Tp>& __x)
      |     ^~~~~~~~
/usr/include/c++/9/complex:452:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::complex<_Tp>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/deque:67,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:68,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/stl_deque.h:370:5: note: candidate: 'template<class _Tp, class _Ref, class _Ptr> typename std::_Deque_iterator<_Tp, _Ref, _Ptr>::difference_type std::operator-(const std::_Deque_iterator<_Tp, _Ref, _Ptr>&, const std::_Deque_iterator<_Tp, _Ref, _Ptr>&)'
  370 |     operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
      |     ^~~~~~~~
/usr/include/c++/9/bits/stl_deque.h:370:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::_Deque_iterator<_Tp, _Ref, _Ptr>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/deque:67,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:68,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/stl_deque.h:382:5: note: candidate: 'template<class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> typename std::_Deque_iterator<_Tp, _Ref, _Ptr>::difference_type std::operator-(const std::_Deque_iterator<_Tp, _Ref, _Ptr>&, const std::_Deque_iterator<_Tp, _RefR, _PtrR>&)'
  382 |     operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
      |     ^~~~~~~~
/usr/include/c++/9/bits/stl_deque.h:382:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::_Deque_iterator<_Tp, _Ref, _Ptr>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/vector:68,
                 from /usr/include/c++/9/queue:61,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:86,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/stl_bvector.h:214:3: note: candidate: 'std::ptrdiff_t std::operator-(const std::_Bit_iterator_base&, const std::_Bit_iterator_base&)'
  214 |   operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
      |   ^~~~~~~~
/usr/include/c++/9/bits/stl_bvector.h:214:39: note:   no known conversion for argument 1 from '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} to 'const std::_Bit_iterator_base&'
  214 |   operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
      |             ~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
In file included from /usr/include/c++/9/valarray:603,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/valarray_after.h:406:5: note: candidate: 'template<class _Dom1, class _Dom2> std::_Expr<std::__detail::_BinClos<std::__minus, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__minus, typename _Dom1::value_type>::result_type> std::operator-(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::_Expr<_Dom2, typename _Dom2::value_type>&)'
  406 |     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/bits/valarray_after.h:406:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/valarray:603,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/valarray_after.h:406:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__minus, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__minus, typename _Dom1::value_type>::result_type> std::operator-(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)'
  406 |     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/bits/valarray_after.h:406:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/valarray:603,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/valarray_after.h:406:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__minus, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__minus, typename _Dom1::value_type>::result_type> std::operator-(const typename _Dom::value_type&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)'
  406 |     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/bits/valarray_after.h:406:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/valarray:603,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/valarray_after.h:406:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__minus, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__minus, typename _Dom1::value_type>::result_type> std::operator-(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::valarray<typename _Dom::value_type>&)'
  406 |     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/bits/valarray_after.h:406:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/c++/9/valarray:603,
                 from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/bits/valarray_after.h:406:5: note: candidate: 'template<class _Dom> std::_Expr<std::__detail::_BinClos<std::__minus, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__minus, typename _Dom1::value_type>::result_type> std::operator-(const std::valarray<typename _Dom::value_type>&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)'
  406 |     _DEFINE_EXPR_BINARY_OPERATOR(-, __minus)
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/bits/valarray_after.h:406:5: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/valarray:1186:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__minus, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__minus, _Tp>::result_type> std::operator-(const std::valarray<_Tp>&, const std::valarray<_Tp>&)'
 1186 | _DEFINE_BINARY_OPERATOR(-, __minus)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/valarray:1186:1: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::valarray<_Tp>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/valarray:1186:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__minus, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__minus, _Tp>::result_type> std::operator-(const std::valarray<_Tp>&, const typename std::valarray<_Tp>::value_type&)'
 1186 | _DEFINE_BINARY_OPERATOR(-, __minus)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/valarray:1186:1: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   '__gnu_cxx::__alloc_traits<std::allocator<BigInteger>, BigInteger>::value_type' {aka 'BigInteger'} is not derived from 'const std::valarray<_Tp>'
  198 |   mint v = val[i] - 1;
      |                     ^
In file included from /usr/include/x86_64-linux-gnu/c++/9/bits/stdc++.h:95,
                 from permutation.cpp:2:
/usr/include/c++/9/valarray:1186:1: note: candidate: 'template<class _Tp> std::_Expr<std::__detail::_BinClos<std::__minus, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__minus, _Tp>::result_type> std::operator-(const typename std::valarray<_Tp>::value_type&, const std::valarray<_Tp>&)'
 1186 | _DEFINE_BINARY_OPERATOR(-, __minus)
      | ^~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/9/valarray:1186:1: note:   template argument deduction/substitution failed:
permutation.cpp:198:21: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
  198 |   mint v = val[i] - 1;
      |                     ^
permutation.cpp:93:23: note: candidate: 'BigInteger operator-(BigInteger, const BigInteger&)'
   93 |     friend BigInteger operator-(BigInteger a, const BigInteger &b) {
      |                       ^~~~~~~~
permutation.cpp:93:65: note:   no known conversion for argument 2 from 'int' to 'const BigInteger&'
   93 |     friend BigInteger operator-(BigInteger a, const BigInteger &b) {
      |                                               ~~~~~~~~~~~~~~~~~~^