Language: C++

#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <cstdio>
#include <string>
#include <cmath>
#include <queue>
#include <tuple>
#include <set>
#include <assert.h>
#include <sstream>
#include <string>
//#include <bits/stdc++.h>
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define repr(i, n) for (int i = (n) - 1; i >= 0; i--)
#define FOR(i,i0,n) for(int (i)=(i0);(i)<(n);(i)++)
#define FORR(i,i0,n) for(int (i)=(n)-1; (i)>=(i0);(i)--)
#define SORT(x) sort(x.begin(),x.end())
#define SORTR(x) sort(x.begin(),x.end(),greater <>())
#define rn return
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
using namespace std;
using ll = long long;
typedef std::pair<ll,ll> P;
//#include <boost/multiprecision/cpp_int.hpp>
//using bint = boost::multiprecision::cpp_int;
const int mod = 1000000007;
struct mint {
    ll x; // typedef long long ll;
    mint(ll x=0):x((x%mod+mod)%mod){}
    
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        mint res(*this);
        return res+=a;
    }
    mint operator-(const mint a) const {
        mint res(*this);
        return res-=a;
    }
    mint operator*(const mint a) const {
        mint res(*this);
        return res*=a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
    
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }
    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }
};
// combination mod prime
struct combination {
    vector<mint> fact, ifact;
    combination(int n):fact(n+1),ifact(n+1) {
        assert(n < mod);
        fact[0] = 1;
        for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;
        ifact[n] = fact[n].inv();
        for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;
    }
    mint operator()(int n, int k) {
        if (k < 0 || k > n) return 0;
        return fact[n]*ifact[k]*ifact[n-k];
    }
};



ll mod_pow(ll x, ll n, ll mod){
    if (n==0) return 1;
    ll res = mod_pow(x*x%mod,n/2,mod);
    if(n&1) res = res*x%mod;
    return res;
}
int main1(){
    int n,a,b;
    cin >> n >> a >> b;
    ll temp = mod_pow(2,n,mod);
    mint ans = temp;
    ans -= 1;
    
    a = min(n-a,a);
    b = min(n-b,b);
    
    mint  bfact = 1;
    rep(i,b){
        bfact *= (i+1);
    }
    mint afact = 1;
    rep(i,a){
        afact *= (i+1);
    }
    
    mint am = 1;
    rep(i,a){
        am *= (n-i);
    }
    
    mint bm = 1;
    rep(i,b){
        bm *= (n-i);
    }
    ans -= bm/bfact;
    ans -= am/afact;
    
    cout << ans.x;
    rn 1;
}


int table[200000+1];

int countWays(int n)
{
    // table[i] will be storing the number of
    // solutions for value i. We need n+1 rows
    // as the table is consturcted in bottom up
    // manner using the base case (n = 0)
    
  
    // Initialize all table values as 0
    memset(table, 0, sizeof(table));
  
    // Base case (If given value is 0)
    table[0] = 1;
  
    // Pick all integer one by one and update the
    // table[] values after the index greater
    // than or equal to n
    for (int i=1; i<n; i++)
        for (int j=i; j<=n; j++)
            table[j] += table[j-i];
  
    return table[n];
}


int main(){
    vector<vector<int>> A(3,vector<int>(3));
    rep(ii,3) rep(j,3) cin >> A[ii][j];
    int n;
    cin >> n;
    rep(i,n){
        int b;
        cin >> b;
        rep(i,3) rep(j,3) if (A[i][j] == b) A[i][j] = 0;
    }
    int ans = 10000;
    rep(ii,3){
        int temp = 0;
        rep(j,3){
            temp += A[ii][j];
        }
        ans = min(temp,ans);
    }
    rep(i,3){
        int temp = 0;
        rep(jj,3){
            temp += A[jj][i];
        }
        ans = min(temp,ans);
    }
    int temp = 0;
    rep(i,3){
        temp += A[i][i];
    }
    ans = min(ans,temp);
    cout << (ans ? "No":"Yes");
}


Compiler output:
a.cc: In function 'int countWays(int)':
a.cc:156:5: error: 'memset' was not declared in this scope
  156 |     memset(table, 0, sizeof(table));
      |     ^~~~~~
a.cc:13:1: note: 'memset' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
   12 | #include <sstream>
  +++ |+#include <cstring>
   13 | #include <string>