Language: C++

#include <iostream>
#include <iomanip>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <stack>
#include <queue>
#include <bitset>
#include <numeric>
#include <cassert>
#include <array>
#include <memory>
#ifdef DEBUG
#include "./Lib/debug.hpp"
#include "./Lib/Timer.hpp"
#include "./Lib/sample.hpp"
#else
#define dump(...)
#endif

/* (=＾o＾=) */
#define int ll

/* macro */
#define FOR(i, b, e) for(ll i = (ll)(b); i < (ll)(e); ++i)
#define RFOR(i, b, e) for(ll i = (ll)(e-1); i >= (ll)(b); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define REPC(x,c) for(const auto& x:(c))
#define REPI2(it,b,e) for(auto it = (b); it != (e); ++it)
#define REPI(it,c) REPI2(it, (c).begin(), (c).end())
#define RREPI(it,c) REPI2(it, (c).rbegin(), (c).rend())
#define REPI_ERACE2(it, b, e) for(auto it = (b); it != (e);)
#define REPI_ERACE(it, c) REPI_ERACE2(it, (c).begin(), (c).end())
#define ALL(x) (x).begin(),(x).end()
#define cauto const auto&
/* macro func */
template<class T>
inline auto sort(T& t) { std::sort(ALL(t)); }
template<class T>
inline auto rsort(T& t) { std::sort((t).rbegin(), (t).rend()); }
template<class T>
inline auto unique(T& t) { (t).erase(unique((t).begin(), (t).end()), (t).end()); }
template<class T, class S>
inline auto chmax(T& t, const S& s) { if (s > t) { t = s; return true; } return false; }
template<class T, class S>
inline auto chmaxE(T& t, const S& s) { if (s >= t) { t = s; return true; } return false; }
template<class T, class S>
inline auto chmin(T& t, const S& s) { if (s < t) { t = s; return true; } return false; }
inline auto BR() { std::cout << "\n"; }

/* type define */
using ll = long long;
using PAIR = std::pair<ll, ll>;
using VS = std::vector<std::string>;
using VL = std::vector<long long>;
using VVL = std::vector<VL>;
using VVVL = std::vector<VVL>;
using VD = std::vector<double>;
template<class T>
using V = std::vector<T>;

/* using std */
using std::cout;
constexpr char endl = '\n';
using std::cin;
using std::pair;
using std::string;
using std::stack;
using std::queue;
using std::vector;
using std::list;
using std::map;
using std::unordered_map;
using std::multimap;
using std::unordered_multimap;
using std::set;
using std::unordered_set;
using std::unordered_multiset;
using std::multiset;
using std::bitset;
using std::priority_queue;
using std::tuple;

/* constant value */
constexpr ll MOD = 1000000007;
//constexpr ll MOD = 998244353;

/* Initial processing  */
struct Preprocessing { Preprocessing() { std::cin.tie(0); std::ios::sync_with_stdio(0); }; }_Preprocessing;

/* Remove the source of the bug */
inline signed pow(signed, signed) { assert(false); return -1; }

/* define hash */
namespace std {
template <>	class hash<std::pair<ll, ll>> { public:	size_t operator()(const std::pair<ll, ll>& x) const { return hash<ll>()(1000000000 * x.first + x.second); } };
}

/* input */
template<class T> std::istream& operator >> (std::istream& is, vector<T>& vec) { for (T& x : vec) is >> x; return is; }

//=============================================================================================
constexpr auto nullLambda = [](ll n) {};
template <class Val = bool, Val ignore = false>
class TrieTree :public std::enable_shared_from_this<TrieTree<Val, ignore>> {
	Val m_val;
	ll end = 0;
	std::vector<std::shared_ptr<TrieTree>> m_next;
	std::vector<int> m_next_jump;
	// static constexpr auto nullLambda = [](ll n) {}; c++17

	auto emplace(const std::vector<int>& vec, Val val, int it) {
		++m_val;
		if (it == vec.size()) {
			++end;
			return;
		}
		if (!m_next[vec[it]]) {
			m_next[vec[it]] = std::make_shared<TrieTree>();
		}
		m_next[vec[it]]->emplace(vec, val, it + 1);
	}

	auto find(const std::vector<int>& vec, int it, const VL& order) const {
		if (m_val != ignore) {
		}
		if (it == vec.size()) {
			return 0LL;
		}
		ll cnt = 0;
		REP(i, 26) {
			if (vec[it] == order[i]) {
				if (m_next[order[i]]) {
					cnt += this->end;
				}
				break;
			}
			if (m_next[order[i]]) {
				cnt += m_next[order[i]]->m_val;
			}
		}
		//dump(cnt);

		if (!m_next[vec[it]]) {
			return cnt;
		}
		return cnt + m_next[vec[it]]->find(vec, it + m_next_jump[vec[it]], order);
	}

	template<class Lambda>
	auto find_old(const std::vector<int>& vec, int it, const Lambda& lambda)const {
		if (m_val != ignore) { lambda(m_val); }
		if (it >= vec.size()) { return m_val; }
		if (!m_next[vec[it]]) { return ignore; }
		return m_next[vec[it]]->find_old(vec, it + m_next_jump[vec[it]], lambda);
	}

public:
	TrieTree() : TrieTree(ignore) {}
	TrieTree(Val val)
		: m_val(val),
		m_next(std::vector<std::shared_ptr<TrieTree>>(26)),
		m_next_jump(std::vector<int>(26, 1)) {}

	auto emplace(const std::vector<int>& vec, Val val) {
		return emplace(vec, val, 0);
	}

	template <class Lambda = decltype(nullLambda)>
	auto find(const std::vector<int>& vec, const VL& order) {
		return find(vec, 0, order);
	}

	//ptr, num
	auto compress(ll num) ->tuple<std::shared_ptr<TrieTree<Val, ignore>>, ll> {
		ll cnt = 0;
		ll it = -1;
		REP(i, 26) if (m_next[i]) { ++cnt; it = i; }
		if (cnt == 1) {
			auto ptr_n = m_next[it]->compress(num);
			auto ptr = std::get<0>(ptr_n);
			auto n = std::get<1>(ptr_n);
			m_next[it] = ptr;
			m_next_jump[it] = n;
			return tuple(ptr, n + 1);
		}
		REPC(ptr, m_next) if (ptr) {
			ptr->compress(0);
		}
		return tuple(shared_from_this(), num + 1);
	}

	template<class Lambda = decltype(nullLambda)>
	auto find_old(const std::vector<int>& vec, const Lambda& lambda = nullLambda) { return find_old(vec, 0, lambda); }
};

signed main() {
	ll n;
	cin >> n;
	V<string> v(n);
	cin >> v;
	auto tree = std::make_shared<TrieTree<ll, 0>>();
	auto to = [&](const string& s) {
		VL v;
		v.reserve(s.size());
		REPC(c, s) { v.emplace_back(c - 'a'); }
		return v;
	};

	REPC(s, v) { tree->emplace(to(s), 1); }

	ll q;
	cin >> q;
	REP(_, q) {
		ll k;
		string s;
		cin >> k >> s;
		auto ans = tree->find(to(v[k - 1]), to(s));
		++ans;
		cout << ans << endl;
	}
}

Compiler output:
a.cc: In member function 'std::tuple<std::shared_ptr<TrieTree<Val, ignore> >, long long int> TrieTree<Val, ignore>::compress(ll)':
a.cc:197:30: error: there are no arguments to 'shared_from_this' that depend on a template parameter, so a declaration of 'shared_from_this' must be available [-fpermissive]
  197 |                 return tuple(shared_from_this(), num + 1);
      |                              ^~~~~~~~~~~~~~~~
a.cc:197:30: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)