Submission #39011803

---

Source Code Expand

#include <bits/stdc++.h>
using namespace std;

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> ii;
typedef pair<ll,ll> llll;
typedef pair<double,double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;

#define pb  push_back
#define eb  emplace_back
#define rep(var,n)  for(int var=0;var<(n);++var)
#define rep1(var,n)  for(int var=1;var<=(n);++var)
#define repC2(vari,varj,n)  for(int vari=0;vari<(n)-1;++vari)for(int varj=vari+1;varj<(n);++varj)
#define repC3(vari,varj,vark,n)  for(int vari=0;vari<(n)-2;++vari)for(int varj=vari+1;varj<(n)-1;++varj)for(int vark=varj+1;vark<(n);++vark)
#define ALL(c)  (c).begin(),(c).end()
#define RALL(c)  (c).rbegin(),(c).rend()
#define whole(f, x, ...)                                     \
    ([&](decltype((x)) whole) {                              \
        return (f)(begin(whole), end(whole), ##__VA_ARGS__); \
    })(x)
#define tr(i,c)  for(auto i=(c).begin(); i!=(c).end(); ++i)
#define found(s,e)  ((s).find(e)!=(s).end())
#define mset(arr,val)  memset(arr,val,sizeof(arr))
#define mid(x,y) ((x)+((y)-(x))/2)
#define IN(x,a,b) ((a)<=(x)&&(x)<=(b))
#define IN_(x,a,b) ((a)<=(x)&&(x)<(b))
#define tors(a) sort(ALL(a), greater<decltype(a[0])>())
#define nC2(n) ((ll)(n)*((n)-1)/2)

#define clamp(v,lo,hi) min(max(v,lo),hi)
#define ABS(x) max((x),-(x))
#define PQ(T) priority_queue<T,vector<T>,greater<T>>
#define CLEAR(a) remove_reference_t<decltype(a)>().swap(a)
template <typename T>
vector<T> vec(size_t len, T elem) { return vector<T>(len, elem); }

template<typename T1, typename T2> inline void amin(T1 & a, T2 const & b) { if (a>b) a=b; }
template<typename T1, typename T2> inline void amax(T1 & a, T2 const & b) { if (a<b) a=b; }

template <typename T>
void erase_one(multiset<T>& ms, T val) {
    auto iter = ms.find(val);
    if (iter != ms.end()) ms.erase(iter);
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) { while(a) swap(a, b%=a); return b; }
inline ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
template <typename T>
inline T mod(T a, T b) { return ((a % b) + b) % b; }

inline string _sbin(long long x, int width = -1) {
    vector<char> w;
    for (int i = 0; i < 64; ++i) {
        if (!x) break;
        w.push_back('0' + x % 2);
        x /= 2;
    }
    if (width > 0) {
        while (w.size() < width) w.push_back('0');
    }
    return string(w.rbegin(), w.rend());
}
#define sbin(x) _sbin(x).c_str()
#define sbinn(x, n) _sbin(x, n).c_str()

const long double pi = 3.141592653589793238462643383279502884197;

template <typename T>
int find_left(vector<T>& v, T elem) {
    return (int)(upper_bound(v.begin(), v.end(), elem) - v.begin()) - 1;
}
template <typename T>
int find_right(vector<T>& v, T elem) {
    return (int)(lower_bound(v.begin(), v.end(), elem) - v.begin());
}

template <typename T>
int lower_bound_ix(vector<T>& v, T val) { return lower_bound(v.begin(), v.end(), val) - v.begin(); }
template <typename T>
int upper_bound_ix(vector<T>& v, T val) { return upper_bound(v.begin(), v.end(), val) - v.begin(); }

template <typename T>
size_t uniq(vector<T>& a, bool do_sort=true) {
    if (do_sort) sort(a.begin(), a.end());
    a.erase(unique(a.begin(), a.end()), a.end());
    return a.size();
}

template <typename T1, typename T2>
vector<T2> accum(vector<T1>& a, T2 init) {
    int L = a.size();
    vector<T2> acc(L + 1);
    acc[0] = init;
    for (int i=0; i<L; ++i) acc[i+1] = acc[i] + a[i];
    return move(acc);
}

#define accum0(a) for(int i=1;i<a.size();++i)a[i]+=a[i-1]

template <typename T>
T accumed(vector<T>& acc, int from, int to) {
    int M = acc.size() - 1;
    return acc[min(M, to)] - acc[max(0, from)];
}

ll MOD=1000000007LL;

inline ll ADD(ll x, ll y) { return (x+y) % MOD; }
inline ll SUB(ll x, ll y) { return (x-y+MOD) % MOD; }
inline ll MUL(ll x, ll y) { return (x%MOD)*(y%MOD) % MOD; }
inline ll POW(ll x, ll e) { ll v=1; for(; e; x=MUL(x,x), e>>=1) if (e&1) v = MUL(v,x); return v; }
inline ll INV(ll y) { /*assert(y%MOD!=0);*/ return POW(y, MOD-2); }
inline ll DIV(ll x, ll y) { return MUL(x, INV(y)); }

vector<ll> fact { 1, 1 }, ifact { 1, 1 };
int fact_prepared = 1;

void prepare_fact(int mx){
    if (mx <= fact_prepared) return;

    fact.resize(mx+1);
    ifact.resize(mx+1);
    for (int n=fact_prepared+1; n<=mx; ++n) fact[n] = MUL(fact[n-1], n);
    ifact[mx] = INV(fact[mx]);
    for (int n=mx; n>fact_prepared+1; --n) ifact[n-1] = MUL(ifact[n], n);

    for (int n=fact_prepared+1; n<=mx; ++n) { assert(MUL(fact[n], ifact[n]) == 1LL); }
    fact_prepared = mx;
}

inline ll nCk(int n, int k) {
    if (!IN(k, 0, n)) return 0;
    prepare_fact(n);
    return fact[n] * ifact[k] % MOD * ifact[n - k] % MOD;
}
inline ll nPk(int n, int k) {
    if (!IN(k, 0, n)) return 0;
    prepare_fact(n);
    return fact[n] * ifact[n-k] % MOD;
}
inline ll nDk(int n, int k) {
    return nCk(n+k, k);
}
inline ll nHk(int n, int k) {
    return nCk(n+k-1, k);
}


#define is_digit(c) ('0'<=(c)&&(c)<='9')
#define is_whitespace(c) ((c)==' '||(c)=='\n'||(c)=='\r'||(c)=='\t'||(c)==EOF)
void reader(int& x){
  x=0;
  bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break;} }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
  if(neg) x=-x; }
void reader(long long& x){
  x=0;
  bool neg=false; for(;;){ int k=getchar(); if(k=='-'){ neg=true; break; } if (is_digit(k)){ x=k-'0'; break; } }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; }
  if(neg) x=-x; }
void reader(unsigned long long& x){
  x=0;
  for(;;){ int k=getchar(); if (is_digit(k)){ x=(unsigned long long)(k-'0'); break; } }
  for(;;){ int k=getchar(); if (!is_digit(k)) break; x=x*10+k-'0'; } }
int reader(char s[]){
  int c,i=0;
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s[i++]=c;
  for(;;){ c=getchar(); if (is_whitespace(c)) break; s[i++]=c; }
  s[i]='\0'; return i; }
int reader(string& s){
  int c;
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } s.push_back(c);
  for(;;){ c=getchar(); if (is_whitespace(c)) break; s.push_back(c); }
  return s.size(); }
void reader(char& c){
  for(;;){ c=getchar(); if (!is_whitespace(c)) break; } }

void writer(int x, char c=0){
  int s=0; bool neg=false; char f[10]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(long long x, char c=0){
  int s=0; bool neg=false; char f[20]; if(x<0) neg=true,x=-x; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(unsigned long long x, char c=0){
  int s=0; char f[20]; if(x==0) f[s++]='0'; else while(x) f[s++]='0'+x%10,x/=10;
  while(s--) putchar(f[s]); if(c) putchar(c); }
void writer(const string& x, char c=0){
  for(int i=0;i<x.size();++i) putchar(x[i]); if(c) putchar(c); }
void writer(const char x[], char c=0){
  for(int i=0;x[i]!='\0';++i) putchar(x[i]); if(c) putchar(c); }

template <class T,class S> void reader(T& x, S& y){ reader(x); reader(y); }
template <class T,class S,class U> void reader(T& x, S& y, U& z){ reader(x); reader(y); reader(z); }
template <class T,class S,class U,class V> void reader(T& x, S& y, U& z, V& w){ reader(x); reader(y); reader(z); reader(w); }
template <class T> vector<T> readerArray(int n){
  vector<T> ret(n); for(int i=0;i<n;++i) reader(ret[i]); return ret; }
template <class T> vector<vector<T>> readerMatrix(int n,int m=0){
  if (m==0) m = n; vector<vector<T>> ret(n); for(int i=0;i<n;++i) ret[i] = readerArray<T>(m); return ret; }

template <class T> void writerLn(T x){ writer(x,'\n'); }
template <class T,class S> void writerLn(T x, S y){ writer(x,' '); writer(y,'\n'); }
template <class T,class S,class U> void writerLn(T x, S y, U z){ writer(x,' '); writer(y,' '); writer(z,'\n'); }
template <class T,class S,class U,class V> void writerLn(T x, S y, U z, V v){ writer(x,' '); writer(y,' '); writer(z,' '); writer(v,'\n'); }
template <class T> void writerArrayLn(T x[], int n){
  if(n==0){ putchar('\n'); return; }
  for(int i=0;i<n-1;++i) writer(x[i],' '); writer(x[n-1],'\n'); }
template <class T> void writerArrayLn(vector<T>& x){ writerArrayLn(x.data(),(int)x.size()); }
template <class T> void writerArrayLnV(T x[], int n){ for(int i=0;i<n;++i) writerLn(x[i]); }
template <class T> void writerArrayLnV(vector<T>& x){ for(T xi: x) writerLn(xi); }
template <class T> void writerMatrix(vector<vector<T>>& x){
  int n = x.size(); if (n == 0) return;
  int m = x[0].size(); for (int i=0; i<n; ++i) writerArrayLn(x[i]); }

void readerEdges(size_t M,vector<int>& a,vector<int>& b,bool decrement=true){
  a.resize(M); b.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class W> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<W>& c,bool decrement=true){
  a.resize(M); b.resize(M); c.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); if(decrement){ --a[i]; --b[i]; } } }
template <class S,class T> void readerEdges(size_t M,vector<int>& a,vector<int>& b,vector<S>& c,vector<T>& d,bool decrement=true){
  a.resize(M); b.resize(M); c.resize(M); d.resize(M);
  for(int i=0;i<M;++i){ reader(a[i]); reader(b[i]); reader(c[i]); reader(d[i]); if(decrement){ --a[i]; --b[i]; } } }

vector<vector<int>> make_nxt(int N, int M, vector<int>& a, vector<int>& b){
  vector<vector<int>> nxt(N);
  for(int i=0;i<M;++i){ nxt[a[i]].push_back(b[i]); nxt[b[i]].push_back(a[i]); }
  return nxt; }
template <class T> vector<vector<pair<int,T>>> make_nxt(int N, int M, vector<int>& a, vector<int>& b, vector<T>& c){
  vector<vector<pair<int,T>>> nxt(N);
  for(int i=0;i<M;++i){ nxt[a[i]].emplace_back(b[i],c[i]); nxt[b[i]].emplace_back(a[i],c[i]); }
  return nxt; }

ll solve(int N, vi& a) {
    return -1LL;
}

int main() {
    int N, M; reader(N, M);
    vi a = readerArray<int>(N);
    vi b = readerArray<int>(M);
    int sc =0;
    rep(i,M){
        sc += a[ b[i]-1 ];
    }
    cout << sc << endl;



    return 0;
}

Submission Info

Compile Error

./Main.cpp: In function ‘std::string _sbin(long long int, int)’:
./Main.cpp:75:25: warning: comparison of integer expressions of different signedness: ‘std::vector<char>::size_type’ {aka ‘long unsigned int’} and ‘int’ [-Wsign-compare]
   75 |         while (w.size() < width) w.push_back('0');
      |                ~~~~~~~~~^~~~~~~
./Main.cpp: In function ‘void writer(int, char)’:
./Main.cpp:196:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
  196 |   if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
      |   ^~
./Main.cpp:196:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
  196 |   if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
      |                         ^~~~~
./Main.cpp: In function ‘void writer(long long int, char)’:
./Main.cpp:199:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
  199 |   if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
      |   ^~
./Main.cpp:199:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
  199 |   if(neg) putchar('-'); while(s--) putchar(f[s]); if(c) putchar(c); }
      |                         ^~~~~
./Main.cpp: In function ‘void writer(long long unsigned int, char)’:
./Main.cpp:202:3: warning: this ‘while’ clause does not guard... [-Wmisleading-indentation]
  202 |   while(s--) putchar(f[s]); if(c) putchar(c); }
      |   ^~~~~
./Main.cpp:202:29: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘while’
  202 |   while(s--) putchar(f[s]); if(c) putchar(c); }
      |                             ^~
./Main.cpp: In function ‘void writer(const string&, char)’:
./Main.cpp:204:16: warning: comparison of integer expressions of different signedness: ‘int’ and ‘std::__cxx11::basic_string<char>::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
  204 |   for...

Judge Result