text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n1, m1, s;
long long INF = 1000000000005LL;
long long d[200005];
long long p[200005];
long long ticket[200005];
struct Edge {
int from, to;
long long dist;
Edge(int u, int v, long long d) : from(u), to(v), dist(d) {}
};
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
struct Dijkstra {
int m;
vector<Edge> edges;
vector<int> G[200005];
bool done[200005];
void init(int n) {
for (int i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, long long dist) {
edges.push_back(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> Q;
for (int i = 0; i <= n1; i++) d[i] = INF;
d[s] = 0;
memset(done, 0, sizeof(done));
Q.push((HeapNode){0, s});
while (!Q.empty()) {
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if (done[u]) {
continue;
}
done[u] = true;
for (int i = 0; i < G[u].size(); i++) {
Edge& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
Q.push((HeapNode){d[e.to], e.to});
}
}
}
}
} aa;
int main() {
cin >> n1 >> m1;
aa.init(n1);
for (int i = 0; i < m1; i++) {
int a, b;
long long c;
cin >> a >> b >> c;
c *= 2;
aa.AddEdge(a, b, c);
aa.AddEdge(b, a, c);
}
for (int i = 1; i <= n1; i++) {
long long a;
cin >> a;
ticket[i] = a;
aa.AddEdge(0, i, a);
}
aa.dijkstra(0);
for (int i = 1; i <= n1; i++) {
cout << d[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ui = unsigned int;
const int NMax = 2e5 + 5;
const ll inf = 1e18 + 5;
const int mod = 100003;
using zint = int;
int N, M;
ll dist[NMax];
vector<pair<int, ll> > v[NMax];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; ++i) {
int x, y;
ll c;
cin >> x >> y >> c;
v[x].push_back({y, 2 * c});
v[y].push_back({x, 2 * c});
}
set<pair<ll, int> > heap;
for (int i = 1; i <= N; ++i) {
ll d;
cin >> d;
v[0].push_back({i, d});
dist[i] = inf;
}
dist[0] = 0;
heap.insert({0, 0});
while (heap.size()) {
int node = heap.begin()->second;
ll d = (heap.begin())->first;
heap.erase({d, node});
for (auto p : v[node]) {
int nxt = p.first;
ll d = p.second;
if (dist[nxt] <= dist[node] + d) {
continue;
}
heap.erase({dist[nxt], nxt});
dist[nxt] = dist[node] + d;
heap.insert({dist[nxt], nxt});
}
}
for (int i = 1; i <= N; ++i) {
cout << dist[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 13;
int n, m;
vector<pair<int, long long>> g[N];
void Dijkstra(vector<long long> &a, vector<long long> &dist) {
set<pair<long long, int>> q;
for (int i = 0; i < int(n); i++) {
dist[i] = a[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (auto it : g[v]) {
int u = it.first;
long long w = it.second;
if (dist[u] > dist[v] + w) {
q.erase({dist[u], u});
dist[u] = dist[v] + w;
q.insert({dist[u], u});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _ = 0; _ < int(m); _++) {
int f, t;
long long w;
cin >> f >> t >> w;
--f, --t;
w *= 2;
g[f].push_back({t, w});
g[t].push_back({f, w});
}
vector<long long> a(n + 1);
for (int i = 0; i < int(n); i++) {
cin >> a[i];
}
vector<long long> dist(n + 1);
Dijkstra(a, dist);
for (int i = 0; i < int(n); i++) cout << dist[i] << " ";
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200010;
const int Maxm = 400010;
int n, m;
int from[Maxn], nxt[Maxm * 2], to[Maxm * 2], cnt;
long long w[Maxn], dis[Maxn], vis[Maxn], len[Maxm * 2];
struct Node {
int u;
long long dis;
inline bool operator<(const Node &a) const { return dis > a.dis; }
};
inline void add_edge(int a, int b, long long l) {
len[cnt] = l;
to[cnt] = b;
nxt[cnt] = from[a];
from[a] = cnt++;
}
void Dijkstra(int Begin) {
int u = Begin;
priority_queue<Node> q;
q.push((Node){u, 0});
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) dis[i] = (long long)1e13;
dis[u] = 0;
while (!q.empty()) {
u = q.top().u;
q.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = from[u]; i != -1; i = nxt[i]) {
int v = to[i];
if (dis[v] > dis[u] + len[i]) {
dis[v] = dis[u] + len[i];
q.push((Node){v, dis[v]});
}
}
}
}
int main() {
memset(from, -1, sizeof(from));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long l;
scanf("%d%d%lld", &u, &v, &l);
add_edge(u, v, l * 2);
add_edge(v, u, l * 2);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
add_edge(0, i, w[i]);
}
Dijkstra(0);
for (int i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, M, u, v, w, d[int(2e5) + 5];
bool vis[int(2e5) + 5];
struct Node {
long long v, w;
friend bool operator<(const Node n1, const Node n2) { return n1.w > n2.w; }
Node(long long v = 0, long long w = 0) : v(v), w(w){};
} cur;
vector<Node> adj[int(2e5) + 5];
priority_queue<Node> q;
int main() {
scanf("%lld%lld", &N, &M);
for (long long i = 1; i <= M; i++) {
scanf("%lld%lld%lld", &u, &v, &w);
adj[u].push_back(Node(v, w << 1));
adj[v].push_back(Node(u, w << 1));
}
for (long long i = 1; i <= N; i++) {
scanf("%lld", &d[i]);
q.push(Node(i, d[i]));
}
while (!q.empty()) {
cur = q.top();
q.pop();
u = cur.v;
if (vis[u]) continue;
vis[u] = 1;
for (long long i = 0; i < adj[u].size(); i++) {
v = adj[u][i].v;
w = adj[u][i].w;
if (!vis[v] && d[u] + w < d[v]) {
d[v] = d[u] + w;
q.push(Node(v, d[v]));
}
}
}
for (long long i = 1; i <= N; i++) printf("%lld ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 10;
vector<pair<int, long long int>> node[N];
long long int e[N];
bool z[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, m;
cin >> n >> m;
long long int x, y, w;
for (int i = 0; i <= n + 1; i++) node[i].clear();
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
node[x].push_back({y, 2 * w});
node[y].push_back({x, 2 * w});
}
for (int i = 1; i <= n; i++) {
cin >> w;
node[0].push_back({i, w});
}
memset(z, 0, sizeof(z));
for (int i = 0; i <= n; i++) e[i] = 1e18;
e[0] = 0;
priority_queue<pair<long long int, int>> q;
q.push({0, 0});
while (!q.empty()) {
long long int a = q.top().second;
q.pop();
if (z[a]) continue;
z[a] = 1;
for (auto b : node[a]) {
if (e[a] + b.second < e[b.first]) {
e[b.first] = e[a] + b.second;
q.push({-e[b.first], b.first});
}
}
}
for (int i = 1; i <= n; i++) {
cout << e[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int n, m, tot;
int tu, tv;
long long tw;
int frst[maxn + 5], nxt[(maxn << 2) + 5];
long long juli[maxn + 5], vis[maxn + 5];
struct zu {
int hao;
long long zhong;
bool operator<(const zu &a) const { return zhong > a.zhong; }
} tmp;
priority_queue<zu> q;
struct node {
int u, v;
long long w;
} g[(maxn << 2) + 5];
void Dijkstra() {
while (!q.empty()) {
tmp = q.top();
q.pop();
if (!vis[tmp.hao]) {
vis[tmp.hao] = 1;
for (int i = frst[tmp.hao]; i != 0; i = nxt[i]) {
if (tmp.zhong + g[i].w < juli[g[i].v]) {
juli[g[i].v] = tmp.zhong + g[i].w;
q.push((zu){g[i].v, juli[g[i].v]});
}
}
}
}
return;
}
void add(int x, int y, long long z) {
nxt[++tot] = frst[x], frst[x] = tot;
g[tot].u = x, g[tot].v = y, g[tot].w = z;
return;
}
int main() {
scanf("%d%d", &n, &m);
memset(juli, 0x3f, sizeof(juli));
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &tu, &tv, &tw);
add(tu, tv, (tw << 1));
add(tv, tu, (tw << 1));
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &tw);
add(i, n + 1, tw);
add(n + 1, i, tw);
}
tmp.hao = n + 1, tmp.zhong = 0;
q.push(tmp);
tmp = q.top();
juli[n + 1] = 0;
Dijkstra();
for (int i = 1; i <= n; i++) printf("%lld ", juli[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
namespace shl {
inline long long read() {
long long ret = 0, op = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') op = -1;
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret * op;
}
const int N = 2e5 + 10;
struct Edge {
int nxt, to;
long long dis;
} e[N << 2];
int head[N], num, n, m;
inline void add(int from, int to, long long dis) {
e[++num].nxt = head[from];
e[num].to = to;
e[num].dis = dis;
head[from] = num;
}
long long dis[N], vis[N];
struct Dijkstra {
long long id, dis;
bool operator<(const Dijkstra &x) const { return dis > x.dis; }
};
std::priority_queue<Dijkstra> q;
int main() {
n = read(), m = read();
for (register int i = 1; i <= m; ++i) {
long long x = read(), y = read(), z = read();
add(x, y, z << 1);
add(y, x, z << 1);
}
for (register int i = 1; i <= n; ++i) {
long long x = read();
add(i, n + 1, x);
add(n + 1, i, x);
}
for (register int i = 1; i <= n; ++i) dis[i] = 1ll << 62;
dis[n + 1] = 0;
q.push((Dijkstra){n + 1, 0});
while (!q.empty()) {
int now = q.top().id;
q.pop();
if (vis[now]) continue;
vis[now] = 1;
for (register int i = head[now]; i; i = e[i].nxt)
if (dis[e[i].to] > dis[now] + e[i].dis) {
dis[e[i].to] = dis[now] + e[i].dis;
q.push((Dijkstra){e[i].to, dis[e[i].to]});
}
}
for (register int i = 1; i <= n; ++i) printf("%lld ", dis[i]);
return 0;
}
} // namespace shl
int main() {
shl::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int N = 2e5 + 5;
vector<pair<int, ll>> gr[N];
vector<ll> cost;
int n, m;
void add_edge(int a, int b, ll w) {
gr[a].emplace_back(b, w);
gr[b].emplace_back(a, w);
}
void Solve() {
cin >> n >> m;
for (ll i = 0, a, b, w; i < m; i++) {
cin >> a >> b >> w;
add_edge(a, b, w);
}
cost.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> cost[i];
set<pair<ll, int>> q;
for (int i = 1; i <= n; i++) q.emplace(cost[i], i);
while (q.size()) {
auto [val, id] = *q.begin();
q.erase(q.begin());
for (auto [u, w] : gr[id]) {
if (cost[u] > val + (w << 1)) {
q.erase({cost[u], u});
cost[u] = val + (w << 1);
q.emplace(cost[u], u);
}
}
}
for (int i = 1; i <= n; i++) cout << cost[i] << " ";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<long long, long long> > neig[n + 1];
long long a[n + 1];
while (m--) {
long long u, v, w;
cin >> u >> v >> w;
neig[u].push_back({v, w});
neig[v].push_back({u, w});
}
set<pair<long long, long long> > s;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s.insert({a[i], i});
}
while (s.begin() != s.end()) {
int u = (*s.begin()).second;
s.erase(s.begin());
for (pair<long long, long long> p : neig[u]) {
int v = p.first;
if (a[v] > 2 * p.second + a[u]) {
s.erase({a[v], v});
a[v] = 2 * p.second + a[u];
s.insert({a[v], v});
}
}
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct Edge {
int to;
long long weight;
};
const int N = (int)2e5 + 9;
vector<Edge> T[N];
int n;
long long dep[N];
void Dijikstra() {
set<pair<long long, int> > Q;
for (int i = 1; i <= n; i++) {
Q.insert(make_pair(dep[i], i));
}
int nod;
while (!Q.empty()) {
nod = Q.begin()->second;
Q.erase(Q.begin());
for (Edge nex : T[nod]) {
if (dep[nod] + nex.weight < dep[nex.to]) {
Q.erase(make_pair(dep[nex.to], nex.to));
dep[nex.to] = dep[nod] + nex.weight;
Q.insert(make_pair(dep[nex.to], nex.to));
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
;
int m;
cin >> n >> m;
int ui, vi;
long long wi;
for (int i = 0; i < m; i++) {
cin >> ui >> vi >> wi;
wi *= 2;
T[ui].push_back({vi, wi});
T[vi].push_back({ui, wi});
}
for (int i = 1; i <= n; i++) cin >> dep[i];
Dijikstra();
for (int i = 1; i <= n; i++) {
cout << dep[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 400010;
long long n, m, first[maxn], v[maxn], nextt[maxn], w[maxn], tot = 1, vis[maxn],
ans[maxn];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void add(long long x, long long y, long long z) {
w[tot] = z;
v[tot] = y;
nextt[tot] = first[x];
first[x] = tot++;
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
add(a, b, 2 * c);
add(b, a, 2 * c);
}
for (long long i = 1; i <= n; i++) {
long long t;
scanf("%lld", &t);
q.push(make_pair(t, i));
}
while (!q.empty()) {
pair<long long, long long> u = q.top();
q.pop();
if (vis[u.second]) continue;
vis[u.second] = 1;
ans[u.second] = u.first;
for (long long e = first[u.second]; e; e = nextt[e]) {
q.push(make_pair(u.first + w[e], v[e]));
}
}
for (long long i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[200005];
vector<pair<int, long long> > edge[200005];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
bool vis[200005];
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
ans[i] = 2000000000000000001;
}
for (i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
edge[u].push_back(make_pair(v, w << 1));
edge[v].push_back(make_pair(u, w << 1));
}
for (i = 1; i <= n; i++) {
long long w;
scanf("%lld", &w);
edge[n + 1].push_back(make_pair(i, w));
}
q.push(make_pair(0, n + 1));
while (!q.empty()) {
int t = q.top().second;
q.pop();
if (vis[t]) {
continue;
}
vis[t] = 1;
for (i = 0; i < edge[t].size(); i++) {
ans[edge[t][i].first] =
min(ans[edge[t][i].first], ans[t] + edge[t][i].second);
q.push(make_pair(ans[edge[t][i].first], edge[t][i].first));
}
}
for (i = 1; i <= n; i++) {
printf("%lld ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, long long> > vec[2 * (int)1e5 + 5];
priority_queue<pair<long long, int> > pq;
long long ans[2 * (int)1e5 + 5];
void update() {
while (!pq.empty()) {
int u = pq.top().second;
long long tempAns = -pq.top().first;
pq.pop();
for (int i = 0; i < vec[u].size() && tempAns == ans[u]; i++) {
int v = vec[u][i].first;
long long w = 2LL * vec[u][i].second;
if (ans[v] > ans[u] + w) {
ans[v] = ans[u] + w;
pq.push(make_pair(-ans[v], v));
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0, u, v; i < m; i++) {
long long w;
scanf("%d %d %lld", &u, &v, &w);
vec[u].push_back(make_pair(v, w));
vec[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &ans[i]);
pq.push(make_pair(-ans[i], i));
}
update();
for (int i = 1; i <= n; i++) {
if (i - 1) printf(" ");
printf("%lld", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int to;
long long d;
A() {}
A(int to, long long d) : to(to), d(d) {}
};
vector<A> G[200005];
long long dis[200005] = {};
priority_queue<pair<long long, int> > pq;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0, x, y; i < m; ++i) {
long long v;
scanf("%d%d%lld", &x, &y, &v);
G[x].push_back(A(y, 2 * v));
G[y].push_back(A(x, 2 * v));
}
for (int i = 1; i <= n; ++i) {
long long v;
scanf("%lld", &v);
pq.push({-v, i});
dis[i] = v;
}
bool done[200005] = {};
while (!pq.empty()) {
auto fr = pq.top();
pq.pop();
if (done[fr.second]) continue;
for (auto re : G[fr.second]) {
long long d = dis[fr.second] + re.d;
if (d < dis[re.to]) {
dis[re.to] = d;
pq.push({-d, re.to});
}
}
done[fr.second] = 1;
}
for (int i = 1; i <= n; ++i) {
printf("%lld", dis[i]);
if (i != n) putchar(' ');
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
register T c = getchar();
x = 0;
int t = 0;
if (c == '-') t = 1, c = getchar();
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (t) x = -x;
}
vector<pair<long long, long long> > g[200005];
long long cost[200005];
bool visited[200005];
int main() {
long long n, m;
cin >> n >> m;
long long u, v, w;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (int i = 0; i < m; ++i) {
cin >> u >> v >> w;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 1; i <= n; ++i) {
cin >> cost[i];
pq.push({cost[i], i});
}
while (!pq.empty()) {
pair<long long, long long> p = pq.top();
pq.pop();
if (visited[p.second]) continue;
visited[p.second] = 1;
long long node = p.second;
long long c = p.first;
auto it = g[node].begin();
for (; it != g[node].end(); ++it) {
if (cost[it->first] > c + it->second) {
pq.push({(c + it->second), it->first});
cost[it->first] = c + it->second;
}
}
}
for (int i = 1; i <= n; ++i) cout << cost[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > g[200001];
long long int n, m;
vector<long long int> dijkstra(int root) {
long long int next, dist;
priority_queue<pair<long long int, long long int> > q;
vector<long long int> d(n + 1, 1000000000001);
d[root] = 0;
q.push({0, root});
while (!q.empty()) {
next = q.top().second;
dist = -q.top().first;
q.pop();
if (dist <= d[next]) {
for (auto p : g[next]) {
if (d[next] + p.second < d[p.first]) {
d[p.first] = d[next] + p.second;
q.push({-d[p.first], p.first});
}
}
}
}
return d;
}
int main() {
long long int x, y, w, i;
vector<long long int> resp;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y >> w;
x--;
y--;
g[x].push_back({y, 2 * w});
g[y].push_back({x, 2 * w});
}
for (i = 0; i < n; i++) {
cin >> x;
g[n].push_back({i, x});
}
resp = dijkstra(n);
for (i = 0; i < n; i++) {
cout << resp[i] << " ";
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, E;
const int MX = 200005;
long long dist[MX];
vector<pair<long long, long long> > adj[MX];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
void dijkstra() {
while (pq.size()) {
pair<long long, long long> x = pq.top();
pq.pop();
if (dist[x.second] != x.first) continue;
for (auto i : adj[x.second]) {
if (dist[i.first] > 2 * i.second + x.first) {
dist[i.first] = 2 * i.second + x.first;
pq.push(pair<long long, long long>(dist[i.first], i.first));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long u, v, w;
cin >> N >> E;
for (int i = 0; i < E; i++) {
cin >> u >> v >> w;
adj[u].push_back(pair<long long, long long>(v, w));
adj[v].push_back(pair<long long, long long>(u, w));
}
for (int i = 1; i <= N; i++) {
cin >> dist[i];
pq.push(pair<long long, long long>(dist[i], i));
}
dijkstra();
for (int i = 1; i <= N; i++) cout << dist[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<pair<int, long long>> G[N];
long long answer[N];
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int n, m, u, v;
long long w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--;
v--;
G[u].push_back(make_pair(v, 2 * w));
G[v].push_back(make_pair(u, 2 * w));
}
for (int i = 0; i < n; i++) {
answer[i] = 1LL << 60;
}
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
Q;
for (int i = 0; i < n; i++) {
cin >> w;
answer[i] = w;
Q.push(make_pair(w, i));
}
while (!Q.empty()) {
pair<long long, int> temp = Q.top();
Q.pop();
u = temp.second;
if (answer[temp.second] < temp.first) {
continue;
}
for (auto &t : G[u]) {
v = t.first;
w = t.second;
if (w + answer[u] < answer[v]) {
answer[v] = w + answer[u];
Q.push(make_pair(answer[v], v));
}
}
}
for (int i = 0; i < n; i++) {
cout << answer[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5, M = 200000 + 5;
int T, n, m, u, v, s, f, es;
int pre[N];
long long dis[N], w;
bool vis[N];
struct Edge {
int from, to, pre;
long long w;
} e[M * 2];
void ine(int a, int b, long long w) {
es++;
e[es].from = a;
e[es].to = b;
e[es].w = w;
e[es].pre = pre[a];
pre[a] = es;
}
inline void ine2(int a, int b, long long w) {
ine(a, b, w);
ine(b, a, w);
}
priority_queue<pair<long long, int> > Q;
void init() {
es = 0;
while (!Q.empty()) Q.pop();
memset(pre, 0, sizeof(pre));
memset(vis, false, sizeof(vis));
}
void Dijkstra() {
while (!Q.empty()) {
int x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = true;
for (int i = pre[x]; i; i = e[i].pre) {
int y = e[i].to;
long long w = e[i].w;
if (dis[x] + 2LL * w < dis[y]) {
dis[y] = dis[x] + 2 * w;
Q.push(make_pair(-dis[y], y));
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) scanf("%d%d%I64d", &u, &v, &w), ine2(u, v, w);
for (int i = 1; i <= n; i++) {
scanf("%lld", &dis[i]);
Q.push(make_pair(-dis[i], i));
}
Dijkstra();
for (int i = 1; i <= n - 1; i++) printf("%I64d ", dis[i]);
printf("%lld\n", dis[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210000;
const int M = 210000;
void read(long long &x) {
x = 0;
long long f;
f = 1;
char c;
c = getchar();
while ((c < '0' || c > '9') && c != '-') {
c = getchar();
}
if (c == '-') {
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
x = x * f;
}
void read(int &x) {
x = 0;
int f;
f = 1;
char c;
c = getchar();
while ((c < '0' || c > '9') && c != '-') {
c = getchar();
}
if (c == '-') {
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
x = x * f;
}
struct node {
int next;
int to;
long long val;
};
node e[2 * M + 2 * N];
int head[N], etot;
long long dis[N];
bool vis[N];
struct data {
int val;
long long dis;
data(int vv, long long dd) {
val = vv;
dis = dd;
}
data() {}
bool operator<(const data &x1) const { return !(dis < x1.dis); }
};
priority_queue<data> q;
void add(int x, int y, long long v) {
etot++;
e[etot].to = y;
e[etot].val = v;
e[etot].next = head[x];
head[x] = etot;
}
int main() {
etot = 0;
int n, m, i, x, y, j;
long long v;
data now;
read(n);
read(m);
for (i = 1; i <= m; i++) {
read(x);
read(y);
read(v);
add(x, y, 2 * v);
add(y, x, 2 * v);
}
for (i = 1; i <= n; i++) {
read(v);
add(i, n + 1, v);
add(n + 1, i, v);
}
memset(dis, 0x3f3f3f3f3f3f3f3f, sizeof(dis));
dis[n + 1] = 0;
q.push(data(n + 1, 0));
while (!q.empty()) {
now = q.top();
q.pop();
if (vis[now.val] == 0) {
vis[now.val] = 1;
for (j = head[now.val]; j != 0; j = e[j].next) {
if (dis[e[j].to] > dis[now.val] + e[j].val) {
dis[e[j].to] = dis[now.val] + e[j].val;
q.push(data(e[j].to, dis[e[j].to]));
}
}
}
}
for (i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first < b.first;
else
return (a.second > b.second);
}
bool cmp(pair<string, int> x, pair<string, int> y) {
return (x.second < y.second);
}
void NA() {
printf("NO\n");
exit(0);
}
void YA() {
printf("YES\n");
exit(0);
}
const int N = 2e5 + 5;
long long int dis[N], a[N];
vector<pair<int, long long int> > g[N];
int n, m;
void dijkstra() {
set<pair<long long int, int> > Set;
for (int i = 0; i < n; i++) {
dis[i] = a[i];
Set.insert({dis[i], i});
}
while (!Set.empty()) {
int u = Set.begin()->second;
Set.erase(Set.begin());
for (auto it : g[u]) {
int v = it.first;
long long int w = it.second;
if (dis[v] > dis[u] + w) {
Set.erase({dis[v], v});
dis[v] = dis[u] + w;
Set.insert({dis[v], v});
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int u, v, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--, v--;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) cin >> a[i];
dijkstra();
for (int i = 0; i < n; i++) cout << dis[i] << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, sum = 0, flag = 0, ans[200005], m, tot = 0, t,
a[200005] = {0}, w;
vector<pair<long long, long long> > v[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> j >> k >> w;
v[j].push_back({k, w});
v[k].push_back({j, w});
}
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
for (i = 1; i <= n; i++) {
cin >> k;
pq.push({k, i});
}
while (!pq.empty()) {
auto cur = pq.top();
pq.pop();
if (a[cur.second] != 0) continue;
ans[int(cur.second)] = cur.first;
a[cur.second] = 1;
for (auto i : v[cur.second]) {
if (!a[i.first]) {
pq.push({cur.first + 2 * i.second, i.first});
}
}
}
for (i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v[200005];
long long wt[200005];
int n;
void djkshtra() {
set<pair<long long, int> > s;
for (long long i = 1; i < n + 1; i++) {
s.insert(make_pair(wt[i], i));
}
while (!s.empty()) {
pair<long long, int> p;
p = *(s.begin());
s.erase(s.begin());
long long xx;
int yy;
xx = p.first;
yy = p.second;
for (int i = 0; i < v[yy].size(); i++) {
int zz = v[yy][i].first;
long long dis = v[yy][i].second;
if (wt[zz] > dis + wt[yy]) {
s.erase(s.find(make_pair(wt[zz], zz)));
wt[zz] = dis + wt[yy];
s.insert(make_pair(wt[zz], zz));
}
}
}
}
int main() {
cin >> n;
int m;
cin >> m;
while (m--) {
int x, y;
long long w;
cin >> x >> y >> w;
v[x].push_back(make_pair(y, 2 * w));
v[y].push_back(make_pair(x, 2 * w));
}
for (long long i = 1; i < n + 1; i++) {
cin >> wt[i];
}
djkshtra();
for (long long i = 1; i < n + 1; i++) {
cout << wt[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int n, m;
vector<pair<int, long long> > g[N];
long long ans[N];
priority_queue<pair<long long, int> > q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
long long d;
cin >> a >> b >> d;
d += d;
g[a].push_back({b, d});
g[b].push_back({a, d});
}
for (int i = 1; i <= n; i++) {
cin >> ans[i];
q.push({-ans[i], i});
}
while (!q.empty()) {
long long cost = -q.top().first;
int nod = q.top().second;
q.pop();
if (cost != ans[nod]) continue;
for (auto &it : g[nod]) {
int nou = it.first;
if (cost + it.second < ans[nou]) {
ans[nou] = cost + it.second;
q.push({-ans[nou], nou});
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long power(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1) t = (t * a) % m;
return t;
}
using namespace std;
vector<long long> g[200001];
int main() {
;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
map<pair<long long, long long>, long long> mt;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back(v);
g[v].push_back(u);
mt[make_pair(u, v)] = w;
mt[make_pair(v, u)] = w;
}
long long key[n + 1];
set<pair<long long, long long> > st;
for (long long i = 1; i <= n; i++) {
cin >> key[i];
st.insert(make_pair(key[i], i));
}
while (!st.empty()) {
pair<long long, long long> x = *st.begin();
st.erase(st.begin());
long long a = x.first;
long long b = x.second;
for (long long i = 0; i < g[b].size(); i++) {
if (key[g[b][i]] > 2 * mt[make_pair(b, g[b][i])] + key[b]) {
st.erase(st.find(make_pair(key[g[b][i]], g[b][i])));
key[g[b][i]] = 2 * mt[make_pair(b, g[b][i])] + key[b];
st.insert(make_pair(key[g[b][i]], g[b][i]));
}
}
}
for (long long i = 1; i <= n; i++) cout << key[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long inf = ((1ll << 60 - 1));
vector<pair<int, long long> > E[maxn];
int vis[maxn], n, m;
long long d[maxn];
void dij() {
priority_queue<pair<long long, int> > Q;
for (int i = 1; i <= n; i++) d[i] = inf;
Q.push(make_pair(0, 0));
d[0] = 0;
while (!Q.empty()) {
int now = Q.top().second;
vis[now] = 0;
Q.pop();
for (int i = 0; i < E[now].size(); i++) {
int s = E[now][i].first;
long long val = E[now][i].second;
if (d[s] > d[now] + val) {
d[s] = d[now] + val;
if (!vis[s]) {
vis[s] = 1;
Q.push(make_pair(-d[s], s));
}
}
}
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < m; i++) {
int x, y;
long long z;
scanf("%d%d%lld", &x, &y, &z);
E[x].push_back(make_pair(y, (long long)2 * z));
E[y].push_back(make_pair(x, (long long)2 * z));
}
for (int i = 1; i <= n; i++) {
long long val;
scanf("%lld", &val);
E[0].push_back(make_pair(i, val));
}
dij();
for (int i = 1; i <= n; i++) printf("%lld ", d[i]);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int n, m;
vector<pair<ll, int> > g[200005];
ll dist[200005];
ll a[200005];
void dijkstra() {
set<pair<ll, int> > q;
for (int i = 1; i <= n; ++i) {
q.insert({a[i], i});
}
while (!q.empty()) {
int u = q.begin()->second;
q.erase(q.begin());
for (auto e : g[u]) {
ll w = e.first, v = e.second;
if (dist[v] > dist[u] + w) {
q.erase({dist[v], v});
dist[v] = dist[u] + w;
q.insert({dist[v], v});
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
ll w;
for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v >> w;
w <<= 1;
g[u].push_back({w, v}), g[v].push_back({w, u});
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
dist[i] = a[i];
}
dijkstra();
for (int i = 1; i <= n; ++i) {
cout << dist[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
struct edge {
long long next, to, dis;
} a[maxn * 4];
long long head[maxn], cnt, dis[maxn];
bool used[maxn];
void add(long long x, long long y, long long w) {
a[++cnt].dis = w;
a[cnt].next = head[x];
a[cnt].to = y;
head[x] = cnt;
}
long long n, m;
priority_queue<pair<long long, long long> > q;
void dijkstra() {
dis[0] = 0;
q.push(make_pair(0, 0));
while (!q.empty()) {
long long x = q.top().second;
q.pop();
if (used[x]) continue;
used[x] = 1;
for (long long i = head[x]; i; i = a[i].next) {
long long y = a[i].to;
if (dis[x] + a[i].dis < dis[y]) {
dis[y] = a[i].dis + dis[x];
q.push(make_pair(-dis[y], y));
}
}
}
}
signed main() {
scanf("%lld %lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long x, y, w;
scanf("%lld %lld %lld", &x, &y, &w);
add(x, y, 2 * w);
add(y, x, 2 * w);
}
for (long long i = 1; i <= n; i++) {
long long w;
scanf("%lld", &w);
add(0, i, w);
add(i, 0, w);
}
memset(dis, 0x3f, sizeof(dis));
dijkstra();
for (long long i = 1; i <= n; i++) printf("%lld ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("-Ofast", "-funroll-all-loops", "-ffast-math")
#pragma GCC target("avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long Linf = 0x7f7f7f7f7f7f7f7f;
const int Inf = 0x3f3f3f3f;
const int MAXN = 1e6;
int n, m;
long long a[MAXN], dis[MAXN], vis[MAXN];
vector<vector<pair<long long, long long>>> g(MAXN);
void Dijkstra(int S) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
memset(dis, 0x3f, sizeof dis);
q.push(make_pair(0, S));
dis[S] = 0;
while (!q.empty()) {
long long x = q.top().second;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (auto pi : g[x]) {
long long v = pi.first, w = pi.second;
if (dis[x] + w < dis[v]) {
dis[v] = dis[x] + w;
q.push(make_pair(dis[v], v));
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long x, y, w;
cin >> x >> y >> w;
g[x].push_back(make_pair(y, 2 * w));
g[y].push_back(make_pair(x, 2 * w));
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
g[i].push_back(make_pair(n + 1, a[i]));
g[n + 1].push_back(make_pair(i, a[i]));
}
Dijkstra(n + 1);
for (int i = 1; i <= n; i++) cout << dis[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[200007];
long long dist[200007];
vector<pair<long long, long long> > graph[200007];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void dijkstra(int nodes) {
while (!q.empty()) {
long long from = q.top().second;
long long ccost = q.top().first;
q.pop();
if (dist[from] < ccost) {
continue;
}
for (auto i : graph[from]) {
long long to = i.first;
long long cost = i.second;
if (dist[from] + 2 * cost < dist[to]) {
dist[to] = dist[from] + 2 * cost;
q.push(make_pair(dist[to], to));
}
}
}
}
int main() {
int nodes, edges;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> nodes >> edges;
long long u, v, w;
for (int i = 1; i <= edges; i++) {
cin >> u >> v >> w;
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= nodes; i++) {
cin >> dist[i];
q.push(make_pair(dist[i], i));
}
dijkstra(nodes);
for (int i = 1; i <= nodes; i++) {
cout << dist[i] << " ";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
long long MOD = 1000000009;
int n, m;
vector<vector<pair<int, long long int>>> adj;
vector<long long int> dis;
void solve() {
cin >> n >> m;
adj.resize(n + 1);
dis.resize(n + 1);
for (int i = 1; i <= m; i++) {
int u, v;
long long int w;
cin >> u >> v >> w;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
}
priority_queue<pair<long long int, int>> pq;
for (int i = 1; i <= n; i++) {
long long int p;
cin >> p;
pq.push({-p, i});
dis[i] = p;
}
vector<bool> vis(n + 1, false);
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = true;
for (auto j : adj[u]) {
int v = j.first;
long long int wei = j.second;
if (dis[v] > dis[u] + wei) {
dis[v] = dis[u] + wei;
pq.push({-dis[v], v});
}
}
}
for (int i = 1; i <= n; i++) cout << dis[i] << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 13;
const long long INF64 = 1e18;
int n, m;
long long a[N];
vector<pair<int, long long>> g[N];
long long dist[N];
void Dijkstra() {
set<pair<long long, int>> q;
for (int i = 0; i < int(n); i++) {
dist[i] = a[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (auto it : g[v]) {
int u = it.first;
long long w = it.second;
if (dist[u] > dist[v] + w) {
q.erase({dist[u], u});
dist[u] = dist[v] + w;
q.insert({dist[u], u});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _ = 0; _ < int(m); _++) {
int f, t;
long long w;
scanf("%d%d%lld", &f, &t, &w);
--f, --t;
w *= 2;
g[f].push_back({t, w});
g[t].push_back({f, w});
}
for (int i = 0; i < int(n); i++) {
scanf("%lld", &a[i]);
}
Dijkstra();
for (int i = 0; i < int(n); i++) printf("%lld ", dist[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010;
long long n, m, ans, S, T;
struct node {
long long y, v, to;
} e[1000010];
long long tot = 0, Head[N];
void add(long long x, long long y, long long v) {
e[++tot] = (node){y, v, Head[x]};
Head[x] = tot;
}
long long d[N], vis[N];
priority_queue<pair<long long, long long> > q;
void dij(long long s) {
memset(d, 0x3f, sizeof(d));
memset(vis, 0, sizeof(vis));
d[s] = 0;
q.push(make_pair(0, s));
while (q.size()) {
long long x = q.top().second;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (long long i = Head[x]; i; i = e[i].to) {
long long y = e[i].y, v = e[i].v;
if (d[y] > d[x] + v) {
d[y] = d[x] + v;
q.push(make_pair(-d[y], y));
}
}
}
}
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1, u, v, w; i <= m; i++) {
scanf("%lld%lld%lld", &u, &v, &w);
add(u, v, w * 2), add(v, u, w * 2);
}
for (long long i = 1, w; i <= n; i++) {
scanf("%lld", &w);
add(i, n + 1, w), add(n + 1, i, w);
}
dij(n + 1);
for (long long i = 1; i <= n; i++) {
printf("%lld ", d[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
const int Inf = 0x3f3f3f3f;
const long long IInf = 1e18 + 7;
const int MAXN = 3e5 + 10;
inline int read() {
register int x = 0, f = 1, ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -1 : 1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
return x * f;
}
inline long long readll() {
register long long x = 0, f = 1, ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -1 : 1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
return x * f;
}
struct Edge {
int to, nxt;
long long dis;
} e[MAXN << 2];
int cnt, head[MAXN];
inline void add_edge(int u, int v, long long dis) {
e[++cnt].to = v;
e[cnt].nxt = head[u];
e[cnt].dis = dis;
head[u] = cnt;
}
int n, m, S;
struct Node {
long long dis;
int pos;
inline bool operator<(const Node &x) const { return x.dis < dis; }
};
priority_queue<Node> q;
long long dis[MAXN];
bool vis[MAXN];
inline void Dijkstra() {
for (int i = 1; i <= n; ++i) dis[i] = IInf;
dis[S] = 0;
q.push((Node){0, S});
while (!q.empty()) {
Node tmp = q.top();
q.pop();
int x = tmp.pos;
if (vis[x]) continue;
if (tmp.dis != dis[x]) continue;
vis[x] = true;
for (int i = head[x], y; i; i = e[i].nxt) {
y = e[i].to;
if (dis[y] > dis[x] + e[i].dis) {
dis[y] = dis[x] + e[i].dis;
q.push((Node){dis[y], y});
}
}
}
}
int main() {
n = read();
m = read();
S = n + 1;
for (int i = 1, u, v; i <= m; ++i) {
u = read();
v = read();
long long d = readll();
add_edge(u, v, 2 * d);
add_edge(v, u, 2 * d);
}
for (int i = 1; i <= n; ++i) {
add_edge(S, i, readll());
}
Dijkstra();
for (int i = 1; i <= n; ++i) printf("%I64d ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[200005];
vector<vector<pair<long long, long long> > > G(200005);
int main() {
long long i, j, n, m, a, b, c;
priority_queue<pair<long long, long long> > pq;
scanf("%lld %lld", &n, &m);
for (i = 0; i < m; i++) {
scanf("%lld %lld %lld", &a, &b, &c);
G[a].push_back({b, c});
G[b].push_back({a, c});
}
for (i = 1; i <= n; i++) {
scanf("%lld", &ans[i]);
pq.push({-ans[i], i});
}
while (!pq.empty()) {
pair<long long, long long> tp = pq.top();
pq.pop();
tp.first *= -1;
if (tp.first > ans[tp.second]) continue;
ans[tp.second] = tp.first;
for (pair<long long, long long> next : G[tp.second]) {
long long poss = next.second * 2 + tp.first;
if (poss < ans[next.first]) {
pq.push({-poss, next.first});
}
}
}
for (i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, long long int>> v[300001];
vector<long long int> a(300001);
void bfs(int n) {
set<pair<long long int, int>> p;
for (int i = 1; i <= n; i++) {
p.insert({a[i], i});
}
while (!p.empty()) {
int cor2 = p.begin()->second;
p.erase(p.begin());
for (auto x : v[cor2]) {
int cor = x.first;
long long int val = x.second;
if (a[cor] > (a[cor2] + val)) {
p.erase({a[cor], cor});
a[cor] = a[cor2] + val;
p.insert({a[cor], cor});
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
scanf("%d %d", &n, &m);
int x, y;
long long int k;
for (int i = 0; i < m; i++) {
scanf("%d %d %lld", &x, &y, &k);
k *= 2;
v[x].push_back({y, k});
v[y].push_back({x, k});
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
bfs(n);
for (int i = 1; i <= n; i++) {
printf("%lld ", a[i]);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
using P = pair<ll, int>;
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
priority_queue<P, vector<P>, greater<P>> q;
for (int i = 0; i < n; ++i) {
q.emplace(ans[i], i);
}
while (q.size()) {
auto ev = q.top();
q.pop();
auto [ansv, v] = ev;
if (ansv > ans[v]) continue;
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
q.emplace(cans, edge.first);
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, long long int>>> v(n);
for (int i = 0; i < m; ++i) {
int a, b;
long long int c;
cin >> a >> b >> c;
v[--a].push_back(make_pair(--b, c));
v[b].push_back(make_pair(a, c));
}
vector<long long int> a(n);
set<pair<long long int, int>> s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
s.insert(make_pair(a[i], i));
}
while (!s.empty()) {
int u = s.begin()->second;
long long int cost = s.begin()->first;
s.erase(s.begin());
for (auto p : v[u]) {
if (cost + 2 * p.second < a[p.first]) {
s.erase(s.find(make_pair(a[p.first], p.first)));
a[p.first] = cost + 2 * p.second;
s.insert(make_pair(a[p.first], p.first));
}
}
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, long long> > g[200005];
long long d[200005];
bool cmp(int a, int b) { return d[a] != d[b] ? d[a] < d[b] : a < b; }
set<int, bool (*)(int, int)> q(cmp);
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
long long c;
cin >> a >> b >> c;
--a, --b;
g[a].push_back({b, c});
g[b].push_back({a, c});
}
for (int i = 0; i < n; ++i) {
cin >> d[i];
q.insert(i);
}
while (!q.empty()) {
int v = *q.begin();
q.erase(q.begin());
for (auto to : g[v]) {
long long len = to.second;
int z = to.first;
if (d[v] + len * 2 < d[z]) {
q.erase(z);
d[z] = d[v] + len * 2;
q.insert(z);
}
}
}
for (int i = 0; i < n; ++i) {
cout << d[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int b[200005], vis[200005], x, y, z, xnext, cnt, m, n, s, en, cont, flag = 1;
long long d[200005];
struct node {
int next, to;
long long w;
} e[700005];
void fpush(int u, int v, long long w) {
e[++cnt].next = b[u];
e[cnt].w = w;
e[cnt].to = v;
b[u] = cnt;
}
struct nn {
int to;
long long val;
bool operator<(const nn s2) const { return val > s2.val; }
};
priority_queue<nn> a;
void SPFA() {
a.push((nn){s, 0});
d[s] = 0;
while (!a.empty()) {
cont++;
nn now;
now = a.top();
a.pop();
vis[now.to] = 0;
for (int i = b[now.to]; i; i = e[i].next) {
xnext = e[i].to;
if (d[now.to] + e[i].w < d[xnext]) {
d[xnext] = d[now.to] + e[i].w;
if (!vis[xnext]) {
a.push((nn){xnext, d[xnext]});
vis[xnext] = true;
}
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
memset(d, 0x3f3f3f3f, sizeof(d));
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
fpush(u, v, w * 2);
fpush(v, u, w * 2);
}
for (int i = 1; i <= n; i++) {
long long w;
scanf("%lld", &w);
fpush(0, i, w);
}
s = 0;
SPFA();
printf("%lld", d[1]);
for (int i = 2; i <= n; i++) printf(" %lld", d[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
vector<pair<int, long long>> g[N];
int main() {
int n, m;
cin >> n >> m;
vector<long long> d(n + 1, LLONG_MAX);
d[0] = 0;
for (int i = 0; i < m; ++i) {
int v, u;
long long w;
cin >> v >> u >> w;
w *= 2;
g[v].push_back({u, w});
g[u].push_back({v, w});
}
for (int i = 1; i <= n; ++i) {
long long w;
cin >> w;
g[0].push_back({i, w});
g[i].push_back({0, w});
}
set<pair<long long, int>> q;
q.insert({0, 0});
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i].first;
long long w = g[v][i].second;
if (d[v] + w < d[to]) {
q.erase({d[to], to});
d[to] = d[v] + w;
q.insert({d[to], to});
}
}
}
for (int i = 1; i <= n; ++i) {
cout << d[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const double eps = 1e-9;
const int inf = 1e9;
long long a[N];
long long dis[N];
int n, m;
vector<pair<int, long long> > adj[N];
void dij() {
set<pair<long long, int> > q;
for (int i = 1; i <= n; i++) {
dis[i] = a[i];
q.insert({dis[i], i});
}
while (q.size()) {
int u = q.begin()->second;
q.erase(q.begin());
for (auto i : adj[u]) {
long long ww = i.second;
int v = i.first;
if (dis[v] > dis[u] + ww) {
q.erase({dis[v], v});
dis[v] = dis[u] + ww;
q.insert({dis[v], v});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
w *= 2;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
dij();
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
bool vis[200005];
long long n, m, u, v, w, a[200005], d[200005];
vector<vector<pair<long long, long long> > > edges(2e5 + 5);
void dijkstra() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
for (int i = 1; i <= n; i++) d[i] = a[i], pq.push({a[i], i});
while (!pq.empty()) {
long long cur_node = pq.top().second, cur_cost = pq.top().first;
pq.pop();
if (vis[cur_node]) continue;
vis[cur_node] = 1;
for (auto i : edges[cur_node]) {
if (!vis[i.first]) {
long long new_cost = cur_cost + i.second;
if (new_cost < d[i.first]) {
d[i.first] = new_cost;
pq.push({new_cost, i.first});
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
while (m--) {
cin >> u >> v >> w;
edges[u].push_back({v, 2 * w});
edges[v].push_back({u, 2 * w});
}
for (int i = 1; i <= n; i++) cin >> a[i];
dijkstra();
for (int i = 1; i <= n; i++) cout << d[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first < b.first;
else
return (a.second > b.second);
}
bool cmp(pair<string, int> x, pair<string, int> y) {
return (x.second < y.second);
}
void NA() {
printf("NO\n");
exit(0);
}
void YA() {
printf("YES\n");
exit(0);
}
const int N = 2e5 + 5;
long long int dis[N], a[N];
vector<pair<int, long long int> > g[N];
int n, m;
void dijkstra() {
set<pair<long long int, int> > Set;
for (int i = 0; i < n; i++) {
dis[i] = a[i];
Set.insert({dis[i], i});
}
while (!Set.empty()) {
int u = Set.begin()->second;
Set.erase(Set.begin());
for (auto it : g[u]) {
int v = it.first;
long long int w = it.second;
if (dis[v] > dis[u] + w) {
Set.erase({dis[v], v});
dis[v] = dis[u] + w;
Set.insert({dis[v], v});
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int u, v, w;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld %lld %lld", &u, &v, &w);
u--, v--;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
dijkstra();
for (int i = 0; i < n; i++) printf("%lld ", dis[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dist[200003];
int visited[200003];
vector<pair<long long, long long>> adj[200003];
int main() {
int n, m;
cin >> n >> m;
long long u, v, g;
long long arr[200003];
for (int i = 0; i < m; i++) {
cin >> u >> v >> g;
adj[u].push_back(make_pair(v, 2 * g));
adj[v].push_back(make_pair(u, 2 * g));
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
for (int i = 1; i <= n; i++) {
q.push(make_pair(arr[i], i));
dist[i] = arr[i];
}
while (!q.empty()) {
pair<long long, long long> p = q.top();
long long x = p.second;
q.pop();
if (p.first <= dist[x])
;
else
continue;
for (auto it : adj[x]) {
long long nd = it.second;
if (dist[it.first] > dist[x] + nd) {
dist[it.first] = dist[x] + nd;
q.push(make_pair(dist[it.first], it.first));
}
}
}
for (int i = 1; i <= n; i++) {
cout << dist[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node1 {
int v, next;
long long w;
};
struct node2 {
bool friend operator<(node2 n1, node2 n2) { return n1.val > n2.val; }
long long val;
int id;
};
node1 edge[3 * maxn];
priority_queue<node2> que;
long long dis[maxn];
int first[maxn], book[maxn];
int n, m, num;
void addedge(int u, int v, long long w) {
edge[num].v = v;
edge[num].w = w;
edge[num].next = first[u];
first[u] = num++;
}
void dijkstra() {
node2 cur, tmp;
long long w;
int i, u, v;
for (i = 0; i <= n; i++) {
dis[i] = 1e18;
}
dis[0] = 0;
tmp.id = 0, tmp.val = 0;
que.push(tmp);
while (!que.empty()) {
cur = que.top();
que.pop();
u = cur.id;
if (book[u]) continue;
book[u] = 1;
for (i = first[u]; i != -1; i = edge[i].next) {
v = edge[i].v, w = edge[i].w;
if (!book[v] && dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
tmp.id = v, tmp.val = dis[v];
que.push(tmp);
}
}
}
}
int main() {
long long w;
int i, u, v;
scanf("%d%d", &n, &m);
memset(first, -1, sizeof(first));
num = 0;
for (i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, 2 * w), addedge(v, u, 2 * w);
}
for (i = 1; i <= n; i++) {
scanf("%lld", &w);
addedge(0, i, w);
}
dijkstra();
for (i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, w;
long long dis[200005];
vector<pair<long long, long long> > g[200005];
void solve() {
cin >> n >> m;
set<pair<long long, long long> > pq;
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
g[x].push_back({y, 2 * w});
g[y].push_back({x, 2 * w});
}
for (long long i = 1; i <= n; i++) {
cin >> dis[i];
pq.insert({dis[i], i});
}
while (!pq.empty()) {
long long u = pq.begin()->second;
pq.erase(pq.begin());
for (auto to : g[u]) {
if (dis[to.first] > dis[u] + to.second) {
pq.erase({dis[to.first], to.first});
dis[to.first] = dis[u] + to.second;
pq.insert({dis[to.first], to.first});
}
}
}
for (int i = 1; i < n + 1; i++) cout << dis[i] << " ";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0), cerr.tie(0);
;
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline long long read() {
bool sign = 0;
char ch = nc();
long long x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return 0;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
return x;
}
}; // namespace fastIO
using namespace fastIO;
struct node {
long long v, dis;
node(long long aa, long long bb) { v = aa, dis = bb; }
bool operator<(const node& bb) const { return dis > bb.dis; }
};
struct edge {
long long v, w;
};
long long n, m, k, dis[1000010], vis[1000010], num[1000010], x[1000010],
s[1000010], a[1000010];
vector<edge> e[1000010];
priority_queue<node> q;
void dij(long long x) {
for (long long i = 1; i <= n + 1; i++) dis[i] = 1e16;
dis[x] = 0;
q.push(node(x, 0));
while (!q.empty()) {
node now = q.top();
q.pop();
if (vis[now.v]) continue;
vis[now.v] = 1;
for (auto i : e[now.v]) {
if (dis[i.v] > dis[now.v] + i.w) {
dis[i.v] = dis[now.v] + i.w;
q.push(node(i.v, dis[i.v]));
}
}
}
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= m; i++) {
long long u = read(), v = read(), w = read();
e[u].push_back((edge){v, 2 * w});
e[v].push_back((edge){u, 2 * w});
}
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) {
e[n + 1].push_back((edge){i, a[i]});
}
dij(n + 1);
for (long long i = 1; i <= n; i++) cout << dis[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n, m;
long long dist[N], vis[N], parent[N];
vector<pair<long long, long long> > g[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
cin >> dist[i];
s.insert({dist[i], i});
}
while (!s.empty()) {
auto x = *(s.begin());
s.erase(x);
vis[x.second] = 1;
vector<pair<long long, long long> > v;
for (auto it : g[x.second]) {
v.push_back(it);
if (dist[it.first] > dist[x.second] + it.second * 2) {
s.erase({dist[it.first], it.first});
dist[it.first] = dist[x.second] + it.second * 2;
s.insert({dist[it.first], it.first});
parent[it.first] = x.second;
}
}
}
for (long long i = 1; i <= n; i++) cout << dist[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18L;
long long int n, m;
vector<pair<long long int, long long int> > G[200002];
long long int dist[200002];
void dijkastra() {
for (long long int i = 0; i <= n; i++) dist[i] = inf;
dist[n] = 0;
set<pair<long long int, long long int> > Set;
Set.insert({0, n});
while (Set.size() > 0) {
auto [d, curr] = *Set.begin();
Set.erase({d, curr});
for (long long int i = 0; i < G[curr].size(); i++) {
auto [nbr, wt] = G[curr][i];
if (dist[curr] + wt < dist[nbr]) {
if (Set.find({dist[nbr], nbr}) != Set.end())
Set.erase({dist[nbr], nbr});
dist[nbr] = dist[curr] + wt;
Set.insert({dist[nbr], nbr});
}
}
}
}
int32_t main() {
cin >> n >> m;
long long int a, b, w;
for (long long int i = 0; i < m; i++) {
cin >> a >> b >> w;
a--, b--;
G[a].push_back({b, 2 * w});
G[b].push_back({a, 2 * w});
}
for (long long int i = 0; i < n; i++) {
cin >> a;
G[n].push_back({i, a});
G[i].push_back({n, a});
}
dijkastra();
for (long long int i = 0; i < n; i++) cout << dist[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9223372036854775807;
vector<vector<pair<int, long long>>> gr;
vector<long long> d;
int n;
void Dijkstra() {
d.resize(n);
priority_queue<pair<long long, int>> q;
for (int i = 0; i < n; ++i) {
cin >> d[i];
q.push(make_pair(d[i], i));
}
while (!q.empty()) {
int v = q.top().second;
long long ok = -q.top().first;
q.pop();
if (ok > d[v]) {
continue;
}
for (int j = 0; j < gr[v].size(); ++j) {
int to = gr[v][j].first;
long long len = gr[v][j].second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
q.push(make_pair(-d[to], to));
}
}
}
for (int i = 0; i < n; ++i) {
cout << d[i] << ' ';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int m;
cin >> n >> m;
gr.resize(n);
for (int i = 0; i < m; ++i) {
int u, v;
long long a;
cin >> u >> v >> a;
gr[u - 1].push_back(make_pair(v - 1, 2 * a));
gr[v - 1].push_back(make_pair(u - 1, 2 * a));
}
Dijkstra();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> adj[200005];
vector<pair<long long, long long>> cost;
vector<bool> vis(200005, false);
vector<long long> dist(200005, LONG_MAX);
void dij(long long n) {
set<pair<long long, long long>> st;
for (long long i = 0; i < n; i++) st.insert(make_pair(dist[i], i));
while (!st.empty()) {
auto f = st.begin();
long long l = f->first, r = f->second;
st.erase(f);
vis[r] = true;
for (auto e : adj[r]) {
if (vis[e.first] == false && dist[e.first] > l + 2 * e.second) {
st.erase(st.find(make_pair(dist[e.first], e.first)));
dist[e.first] = l + 2 * e.second;
st.insert(make_pair(dist[e.first], e.first));
}
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, a, b, w;
cin >> n >> m;
cost.resize(n);
for (long long i = 0; i < m; i++) {
cin >> a >> b >> w;
a--, b--;
adj[a].push_back(make_pair(b, w));
adj[b].push_back(make_pair(a, w));
}
long long mn = 1e18, mni = -1;
for (long long i = 0; i < n; i++) {
cin >> dist[i];
if (mn > dist[i]) mn = dist[i], mni = i;
}
dij(n);
for (long long i = 0; i < n; i++) cout << dist[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long w = 0, x = 0;
char c = getchar();
while (!isdigit(c)) w |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return w ? -x : x;
}
namespace star {
const long long maxn = 3e5 + 10;
long long ecnt, head[maxn], nxt[maxn << 2], to[maxn << 2], v[maxn << 2];
inline void addedge(long long a, long long b, long long c) {
to[++ecnt] = b, nxt[ecnt] = head[a], head[a] = ecnt, v[ecnt] = c;
}
long long n, m, s, dis[maxn];
inline void dijkstra(long long s) {
memset(dis, 0x3f, sizeof dis);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(dis[s] = 0, s));
while (!q.empty()) {
long long x = q.top().second, y = q.top().first;
q.pop();
if (y != dis[x]) continue;
for (long long i = head[x]; i; i = nxt[i]) {
long long u = to[i];
if (dis[u] > dis[x] + v[i]) q.push(make_pair(dis[u] = dis[x] + v[i], u));
}
}
}
inline void work() {
n = read();
m = read();
for (long long u, v, w, i = 1; i <= m; i++)
u = read(), v = read(), w = read() << 1, addedge(u, v, w), addedge(v, u, w);
s = n + 1;
for (long long i = 1; i <= n; i++) addedge(s, i, read());
dijkstra(s);
for (long long i = 1; i <= n; i++) printf("%lld ", dis[i]);
}
} // namespace star
signed main() {
star::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000 + 10;
struct Edge {
long long from, to;
long long dist;
Edge(long long f = 0, long long t = 0, long long d = 0)
: from(f), to(t), dist(d) {}
};
struct HeapNode {
long long d;
long long u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
Edge E[2 * maxn];
vector<long long> G[maxn];
long long n, m, done[maxn], vis[maxn];
long long d[maxn];
pair<long long, long long> arr[maxn];
priority_queue<HeapNode> Q;
void Dijkstra() {
while (!Q.empty()) {
HeapNode x = Q.top();
Q.pop();
long long u = x.u, val = x.d;
if (val != d[u]) continue;
for (long long i = 0; i < G[u].size(); i++) {
Edge e = E[G[u][i]];
if (d[e.to] > d[u] + 2 * e.dist)
d[e.to] = d[u] + 2 * e.dist, Q.push((HeapNode){d[e.to], e.to});
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (long long i = 0; i < m; i++) {
long long x, y, z;
scanf("%I64d%I64d%I64d", &x, &y, &z);
E[2 * i] = Edge(x, y, z);
E[2 * i + 1] = Edge(y, x, z);
G[x].push_back(2 * i);
G[y].push_back(2 * i + 1);
}
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &d[i]);
Q.push((HeapNode){d[i], i});
}
Dijkstra();
for (long long i = 1; i <= n; i++) printf("%I64d ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18 + 7;
const long long MAXN = 2e5 + 7;
vector<pair<long long, long long>> g[MAXN];
long long a[MAXN];
long long dist[MAXN];
set<pair<long long, long long>> ms;
signed main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long u, v, c;
cin >> u >> v >> c;
c *= 2;
g[u - 1].push_back({v - 1, c});
g[v - 1].push_back({u - 1, c});
}
for (long long i = 0; i < n; ++i) {
cin >> a[i];
g[n].push_back({i, a[i]});
}
for (long long i = 0; i < MAXN; ++i) dist[i] = INF;
dist[n] = 0;
ms.insert({0, n});
while (ms.size() != 0) {
long long u = ms.begin()->second;
ms.erase(ms.begin());
for (pair<long long, long long> e : g[u]) {
long long v = e.first;
long long c = e.second;
if (dist[u] + c < dist[v]) {
ms.erase({dist[v], v});
dist[v] = dist[u] + c;
ms.insert({dist[v], v});
}
}
}
for (long long i = 0; i < n; ++i) {
cout << dist[i] << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
namespace opl {
namespace random {
class Random {
using engine_t = std::mt19937;
engine_t engine;
public:
Random(bool no_random = true) : engine(no_random ? 0 : (int)(time(0))) {}
int getInt() { return engine(); }
double getDouble() { return getInt() * 1.0 / engine_t::max(); }
};
static Random rand(0 != 0 ? true : false);
} // namespace random
using random::rand;
using random::Random;
} // namespace opl
namespace opl {
namespace comparator {
enum class Result { LESS = -1, EQUAL = 0, GREATER = 1 };
struct SupportsSpaceshipTag {};
template <typename T, typename Less = std::less<T>>
struct SpaceshipComparator {
Less less;
Result operator()(const T& lhs, const T& rhs) const {
if (less(lhs, rhs)) {
return Result::LESS;
}
if (less(rhs, lhs)) {
return Result::GREATER;
}
return Result::EQUAL;
}
int compare(const T& lhs, const T& rhs) const {
auto r = (*this)(lhs, rhs);
if (r == Result::LESS) return -1;
if (r == Result::EQUAL) return 0;
if (r == Result::GREATER) return 1;
}
};
} // namespace comparator
} // namespace opl
namespace opl {
namespace treap {
template <typename Key, typename Prior = int>
struct node {
using key_t = Key;
using priority_t = Prior;
key_t key;
priority_t priority;
node *left, *right;
virtual void push() {}
virtual void relax() {}
node(key_t _key) {
key = _key;
priority = opl::rand.getInt();
left = right = nullptr;
}
};
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
std::pair<N*, N*> split(N* v, const typename N::key_t& x, bool split_eq_to_left,
Comp comp) {
N* l;
N* r;
if (!v) {
l = r = nullptr;
return std::make_pair(l, r);
}
v->push();
comparator::Result res = comp(v->key, x);
bool split_cur_to_left = res == comparator::Result::LESS;
if (res == comparator::Result::EQUAL && split_eq_to_left)
split_cur_to_left = true;
if (!split_cur_to_left) {
std::tie(l, v->left) = split<N>((N*)v->left, x, split_eq_to_left, comp);
r = v;
} else {
std::tie(v->right, r) = split<N>((N*)v->right, x, split_eq_to_left, comp);
l = v;
}
if (l) l->relax();
if (r) r->relax();
return std::make_pair(l, r);
}
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
std::tuple<N*, N*, N*> split3(N* tree, const typename N::key_t& x, Comp comp) {
N *t1, *t2, *t12, *t3;
std::tie(t12, t3) = split<N>(tree, x, true, comp);
std::tie(t1, t2) = split<N>(t12, x, false, comp);
return std::make_tuple(t1, t2, t3);
}
template <typename N>
N* merge(N* left, N* right) {
if (left) left->push();
if (right) right->push();
if (!left) return right;
if (!right) return left;
if (left->priority < right->priority) {
left->right = merge((N*)left->right, (N*)right);
left->relax();
return left;
} else {
right->left = merge((N*)left, (N*)right->left);
right->relax();
return right;
}
}
template <typename N>
N* merge3(N* t1, N* t2, N* t3) {
t2 = merge(t1, t2);
t2 = merge(t2, t3);
return t2;
}
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
N* insert(N* v, N* u, Comp comp) {
N *t1, *t2;
split(v, u->key, t1, t2, comp);
t1 = merge(t1, u);
return merge(t1, t2);
}
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
N* insert(N* v, typename N::key_t x, Comp comp) {
return insert(v, &N(x), comp);
}
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
N* erase(N* v, N* u, Comp comp) {
N *t1, *t2, *t3;
std::tie(t1, t2, t3) = split3(v, u->key, comp);
return merge(t1, t3);
}
template <typename N>
N* most_left_node(N* v) {
if (!v) return nullptr;
v->push();
while (v->left != nullptr) {
v = (N*)v->left;
v->push();
}
return v;
}
template <typename N>
void delete_tree(N* v) {
if (!v) return;
delete_tree(v->left);
delete_tree(v->right);
delete v;
}
template <typename N,
typename Comp = comparator::SpaceshipComparator<typename N::key_t>>
N* find(N* v, typename N::key_t key, Comp comp) {
while (v) {
comparator::Result res = comp(v->key, key);
if (res == comparator::Result::EQUAL) break;
if (res == comparator::Result::LESS) {
v = v->left;
} else {
v = v->right;
}
}
return v;
}
} // namespace treap
} // namespace opl
namespace opl {
namespace map {
template <typename K, typename V>
struct node : public treap::node<K, int> {
node(const K& _key) : treap::node<K, int>(_key) {}
std::size_t subtree_node_count = 1;
V value;
void push() {}
static std::size_t getSubtreeNodeCount(node* v) {
if (!v) return 0;
return v->subtree_node_count;
}
void relax() {
subtree_node_count = 1 + node::getSubtreeNodeCount((node*)this->left) +
node::getSubtreeNodeCount((node*)this->right);
}
static std::size_t position(node* tree, node* v) {
if (!v) return node::getSubtreeNodeCount(tree);
node *le, *gte;
std::tie(le, gte) = treap::split(tree, v->key, false);
auto ret = node::getSubtreeNodeCount(le);
tree = treap::merge(le, gte);
return ret;
}
static node* index(node* v, size_t i) {
if (node::getSubtreeNodeCount(v) <= i) {
return nullptr;
}
while (true) {
std::size_t left_cnt = node::getSubtreeNodeCount(v->left);
if (i == left_cnt) {
return v;
}
if (i < left_cnt) {
v = v->left;
continue;
}
if (i > left_cnt) {
v = v->right;
i -= (left_cnt + 1);
}
}
}
};
template <typename K, typename V>
struct map_iterator {
using iterator_category = std::random_access_iterator_tag;
using difference_type = std::size_t;
using value_type = std::pair<const K&, V>;
using reference = value_type&;
using pointer = value_type*;
using node_t = node<K, V>;
node_t* tree_node = nullptr;
node_t* tree = nullptr;
value_type deref() const {
return value_type(tree_node->key, tree_node->value);
}
value_type operator*() const { return deref(); }
bool operator==(const map_iterator& other) const {
return tree_node == other.tree_node && tree == other.tree;
}
bool operator!=(const map_iterator& other) const { return !(*this == other); }
std::size_t position() const { return node_t::position(tree, tree_node); }
difference_type operator-(const map_iterator& other) const {
auto my_position = position();
auto other_position = other.position();
return my_position - other_position;
}
};
template <typename K, typename V>
map_iterator<K, V> operator+(map_iterator<K, V> it, size_t x) {
auto it_pos = it.position();
auto new_pos = it_pos + x;
auto new_node = node<K, V>::index(it.tree, x);
}
template <typename K, typename V, typename Less = std::less<K>>
class Map {
using spaceship_comparator_t = comparator::SpaceshipComparator<K, Less>;
using node_t = node<K, V>;
mutable node_t* tree = nullptr;
using key_t = K;
using value_t = V;
using iterator_t = map_iterator<key_t, value_t>;
spaceship_comparator_t keyComparator;
iterator_t constructIterator() const {
iterator_t it;
it.tree = tree;
return it;
}
iterator_t constructIterator(node_t* v) const {
iterator_t it = constructIterator();
it.tree_node = v;
return it;
}
public:
using key_type = key_t;
using value_type = value_t;
using iterator_type = iterator_t;
node_t* getTree() const { return tree; }
void clear() {
treap::delete_tree(tree);
tree = nullptr;
}
void detach() { tree = nullptr; }
iterator_t find(const key_t& key) const {
node_t *t_lt, *t_eq, *t_gt;
std::tie(t_lt, t_eq, t_gt) = treap::split3(tree, key, keyComparator);
iterator_t it = constructIterator();
it.tree_node = t_eq;
tree = treap::merge3(t_lt, t_eq, t_gt);
return it;
}
iterator_t bound(const key_t& key, bool is_upper) const {
node_t *left, *right;
std::tie(left, right) = treap::split(tree, key, is_upper, keyComparator);
node_t* ret = treap::most_left_node(right);
iterator_t it = constructIterator();
it.tree_node = ret;
tree = treap::merge(left, right);
return it;
}
iterator_t lowerBound(const key_t& key) const { return bound(key, false); }
iterator_t upperBound(const key_t& key) const { return bound(key, true); }
iterator_t begin() const {
iterator_t it = constructIterator(treap::most_left_node(tree));
return it;
}
iterator_t end() const {
iterator_t it = constructIterator();
it.tree_node = nullptr;
return it;
}
bool erase(const key_t& key) {
node_t *lt, *eq, *gt;
std::tie(lt, eq, gt) = treap::split3(tree, key, keyComparator);
if (!eq) {
return false;
}
delete eq;
tree = treap::merge(lt, gt);
return true;
}
bool erase(iterator_t it) { return erase((*it).first); }
std::pair<iterator_t, bool> insert(const key_t& key, const value_t& value) {
node_t *lt, *eq, *gt;
std::tie(lt, eq, gt) = treap::split3(tree, key, keyComparator);
bool new_node_created = false;
if (!eq) {
new_node_created = true;
eq = new node_t(key);
}
eq->value = value;
tree = treap::merge3(lt, eq, gt);
iterator_t it = constructIterator();
it.tree_node = eq;
return std::make_pair(it, new_node_created);
}
std::pair<iterator_t, bool> insert(const key_t& key) {
return insert(key, value_t());
}
int count(const key_t& key) const {
node_t *lt, *eq, *gt;
std::tie(lt, eq, gt) = treap::split3(tree, key, keyComparator);
int ret = 0;
if (eq) ret = 1;
tree = treap::merge3(lt, eq, gt);
return ret;
}
size_t size() const { return node_t::getSubtreeNodeCount(tree); }
bool empty() const { return size() == 0; }
};
} // namespace map
template <typename K, typename V>
using Map = map::Map<K, V>;
} // namespace opl
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
using P = pair<ll, int>;
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
opl::map::Map<P, double> q;
for (int i = 0; i < n; ++i) {
q.insert(P(ans[i], i));
}
while (!q.empty()) {
auto ev = (*q.begin()).first;
q.erase(ev);
auto [ansv, v] = ev;
if (ansv > ans[v]) continue;
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
q.insert(P(cans, edge.first));
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m;
int long long dp[maxn];
vector<pair<int long long, int long long>> veci[maxn];
set<pair<int long long, int long long>> st;
bool mark[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
fill_n(dp, maxn, 1e18);
while (m--) {
int long long a, b, c;
cin >> a >> b >> c;
veci[a].push_back({b, c});
veci[b].push_back({a, c});
}
for (int i = 1; i <= n; i++) {
int long long a;
cin >> a;
st.insert({a, i});
}
while (st.size() > 0) {
auto x = *st.begin();
st.erase(x);
if (mark[x.second]) continue;
dp[x.second] = x.first;
mark[x.second] = 1;
for (auto y : veci[x.second])
st.insert({dp[x.second] + (2 * y.second), y.first});
}
for (int i = 1; i <= n; i++) cout << dp[i] << " ";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
using P = ll;
struct Node {
P value;
int il, ir;
int ansi;
Node* nl = nullptr;
Node* nr = nullptr;
void push() {
if (ir - il > 1) {
value = min(nl->value, nr->value);
if (nl->value < nr->value) {
ansi = nl->ansi;
value = nl->value;
} else {
ansi = nr->ansi;
value = nr->value;
}
}
}
};
Node* build(int l, int r) {
Node* n = new Node;
n->il = l;
n->ir = r;
n->ansi = l;
if (r - l > 1) {
int m = (l + r) / 2;
n->nl = build(l, m);
n->nr = build(m, r);
n->push();
}
return n;
}
pair<P, int> extract(Node* node, int ql, int qr) {
if (ql >= node->ir || node->il >= qr) return {1e18, -1};
if (ql <= node->il && node->ir <= qr) {
auto ret = make_pair(node->value, node->ansi);
return ret;
}
auto ret = min(extract(node->nl, ql, qr), extract(node->nr, ql, qr));
node->push();
return ret;
}
void update(Node* node, int i, P x) {
if (i >= node->ir || node->il >= i + 1) return;
if (i <= node->il && node->ir <= i + 1) {
node->value = x;
return;
}
update(node->nl, i, x);
update(node->nr, i, x);
node->push();
}
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
Node* tree = build(0, n);
for (int i = 0; i < n; ++i) {
update(tree, i, ans[i]);
}
int nextFree = n;
while (nextFree > 0) {
auto t = extract(tree, 0, n);
auto [ev, v] = t;
auto ansv = ev;
assert(ansv == ans[v]);
--nextFree;
update(tree, v, 1e18);
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
update(tree, edge.first, cans);
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const int maxm = 800100;
const long long infinit = 0x0f3f3f3f3f3f3f3fll;
class SPFA {
public:
struct edge {
int u, v;
long long len;
edge *next;
};
edge epool[maxm], *edges[maxn];
int n, ecnt;
long long dist[maxn];
void add_edge(int u, int v, long long len) {
edge *p = &epool[++ecnt], *q = &epool[++ecnt];
p->u = u;
p->v = v;
p->len = len;
p->next = edges[u];
edges[u] = p;
q->u = v;
q->v = u;
q->len = len;
q->next = edges[v];
edges[v] = q;
return;
}
void eval(int s) {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = (0); i <= (n); i += (1)) dist[i] = infinit;
dist[s] = 0;
pq.push(make_pair(dist[s], s));
while (!pq.empty()) {
pair<long long, int> pr = pq.top();
int p = pr.second;
pq.pop();
if (dist[p] < pr.first) continue;
for (edge *ep = edges[p]; ep; ep = ep->next)
if (dist[p] + ep->len < dist[ep->v]) {
dist[ep->v] = dist[p] + ep->len;
pq.push(make_pair(dist[ep->v], ep->v));
}
}
return;
}
void init(int n) {
this->n = n;
ecnt = 0;
for (int i = (1); i <= (n); i += (1)) edges[i] = NULL;
return;
}
} graph;
int n, m;
int main(int argc, char **argv) {
scanf("%d%d", &n, &m);
graph.init(n + 1);
for (int i = (1); i <= (m); i += (1)) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
graph.add_edge(u, v, 2 * w);
}
for (int i = (1); i <= (n); i += (1)) {
long long a;
scanf("%lld", &a);
graph.add_edge(n + 1, i, a);
}
graph.eval(n + 1);
for (int i = (1); i <= (n); i += (1)) printf("%lld ", graph.dist[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
vector<vector<pll>> edges;
void solve() {
ll n, m;
cin >> n >> m;
edges.resize(n);
for (int i = 0, _n = (m); i < _n; i++) {
ll u, v, w;
cin >> u >> v >> w;
u--;
v--;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
vector<long long> a(n);
for (int i = 0, _n = (n); i < _n; i++) cin >> a[i];
set<pll> second;
for (int i = 0, _n = (n); i < _n; i++) {
second.insert({a[i], i});
}
vector<bool> vis(n, 0);
while (!second.empty()) {
auto root = *(second.begin());
second.erase(second.begin());
for (auto& child : edges[root.second]) {
if (vis[child.first]) continue;
ll to = child.first;
ll wt = child.second;
if (2 * wt + root.first < a[to]) {
second.erase({a[to], to});
a[to] = 2 * wt + root.first;
second.insert({a[to], to});
}
}
vis[root.second] = 1;
}
for (auto& elem : a) {
cout << elem << ' ';
}
cout << '\n';
return;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v;
long long w;
Edge(int v = 0, long long w = 0) : v(v), w(w) {}
};
struct Node {
int id;
long long d;
Node(int id = 0, long long d = 0) : id(id), d(d) {}
bool operator<(const Node& n1) const { return d > n1.d; }
};
vector<Edge> adj[200005];
int n, m;
long long d[200005];
bool vis[200005];
void dijkstra() {
memset(vis, 0, sizeof(vis));
memset(d, 127, sizeof(d));
d[0] = 0;
priority_queue<Node> q;
q.push(Node(0, 0));
int u, v;
long long w;
while (!q.empty()) {
u = q.top().id;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = 0; i < (int)adj[u].size(); i++) {
v = adj[u][i].v;
w = adj[u][i].w;
if (d[u] + w < d[v]) {
d[v] = d[u] + w;
q.push(Node(v, d[v]));
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
long long w;
for (int u, v, i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
adj[u].push_back(Edge(v, 2 * w));
adj[v].push_back(Edge(u, 2 * w));
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w);
adj[0].push_back(Edge(i, w));
}
dijkstra();
for (int i = 1; i <= n; i++) printf("%lld ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<long long, int> > v[n + 1];
int x, y;
long long w;
for (int i = 0; i < m; i++) {
scanf("%d %d %I64d", &x, &y, &w);
v[x].push_back(pair<long long, int>(w, y));
v[y].push_back(pair<long long, int>(w, x));
}
long long dis[n + 1];
priority_queue<pair<long long, int> > pq;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &dis[i]);
pq.push(pair<long long, int>(-dis[i], i));
}
while (!pq.empty()) {
int j = pq.top().second;
long long d = pq.top().first;
pq.pop();
if (dis[j] != -d) {
continue;
}
for (int k = 0; k < v[j].size(); k++) {
int in = v[j][k].second;
long long w = v[j][k].first;
if (dis[in] > dis[j] + 2 * w) {
dis[in] = dis[j] + 2 * w;
pq.push(pair<long long, int>(-dis[in], in));
}
}
}
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long xyp(long long x, long long y) {
if (y == 0)
return 1;
else if (y == 1)
return x;
else if (y & 1LL) {
long long p = xyp(x, (y - 1) >> 1);
p = (p * p) % 1000000007;
return (x * p) % 1000000007;
}
long long p = xyp(x, y >> 1);
return (p * p) % 1000000007;
}
long long n, m;
vector<vector<pair<long long, long long>>> a;
vector<long long> v;
void solve() {
cin >> n >> m;
a.resize(n + 1);
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
a[x].push_back({z, y});
a[y].push_back({z, x});
}
v.resize(n + 1);
multiset<pair<long long, long long>> ms;
for (long long i = 1; i <= n; i++) {
cin >> v[i];
ms.insert({v[i], i});
}
while (ms.size()) {
pair<long long, long long> tp = *ms.begin();
ms.erase(ms.begin());
long long curr_vertex = tp.second;
for (auto x : a[curr_vertex]) {
if (v[x.second] > v[curr_vertex] + 2 * x.first) {
ms.erase(ms.find({v[x.second], x.second}));
v[x.second] = v[curr_vertex] + 2 * x.first;
ms.insert({v[x.second], x.second});
}
}
}
for (long long i = 1; i <= n; i++) {
cout << v[i] << " ";
}
}
int main() {
int t;
t = 1;
for (int z = 1; z <= t; z++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXCHAR = 26;
struct STATE {
int next[MAXCHAR];
int suf_state;
int out_state;
int id_of_pattern;
int isLeaf;
STATE() {
for (int i = 0; i < MAXCHAR; i++) {
next[i] = -1;
}
suf_state = out_state = id_of_pattern = isLeaf = -1;
}
};
void add_string(vector<struct STATE>& states, const string& s, const int& id) {
int curr_state = 0, c;
for (auto ch : s) {
c = ch - 'a';
if (states[curr_state].next[c] == -1) {
states[curr_state].next[c] = (int)states.size();
states.emplace_back();
}
curr_state = states[curr_state].next[c];
}
states[curr_state].isLeaf = 1;
states[curr_state].id_of_pattern = id;
}
void construct_trie(vector<struct STATE>& states, const vector<string>& query) {
for (int i = 0; i < (int)query.size(); i++) {
add_string(states, query[i], i);
}
}
void build_automaton(vector<struct STATE>& states) {
queue<pair<int, pair<int, int> > > q;
for (int i = 0; i < MAXCHAR; i++) {
if (states[0].next[i] != -1) {
states[states[0].next[i]].suf_state = 0;
q.push({i, {0, states[0].next[i]}});
}
}
while (!q.empty()) {
pair<int, pair<int, int> > pt = q.front();
q.pop();
int c = pt.first;
int prev_state = pt.second.first;
int curr_state = pt.second.second;
if (states[curr_state].suf_state == -1) {
int state_x = states[prev_state].suf_state;
while (state_x != -1 && states[state_x].next[c] == -1) {
state_x = states[state_x].suf_state;
}
states[curr_state].suf_state =
(state_x == -1) ? 0 : states[state_x].next[c];
}
if (states[curr_state].out_state == -1) {
if (states[states[curr_state].suf_state].isLeaf == 1) {
states[curr_state].out_state = states[curr_state].suf_state;
} else {
states[curr_state].out_state =
states[states[curr_state].suf_state].out_state;
}
}
for (int i = 0; i < MAXCHAR; i++) {
if (states[curr_state].next[i] != -1) {
q.push({i, {curr_state, states[curr_state].next[i]}});
}
}
}
}
void search_(const vector<struct STATE>& states, const string& s,
vector<vector<int> >& index) {
int curr_state = 0;
for (int i = 0; i < (int)s.size(); i++) {
int c = s[i] - 'a';
while (curr_state != 0 && states[curr_state].next[c] == -1) {
curr_state = states[curr_state].suf_state;
}
if (states[curr_state].next[c] != -1) {
curr_state = states[curr_state].next[c];
if (states[curr_state].isLeaf == 1) {
index[states[curr_state].id_of_pattern].push_back(i);
}
int out_s = states[curr_state].out_state;
while (out_s != -1) {
index[states[out_s].id_of_pattern].push_back(i);
out_s = states[out_s].out_state;
}
}
}
}
int solve(int k, vector<int>& id, int len) {
int mn = INT_MAX;
for (int i = 0; k + i - 1 < (int)id.size(); i++) {
mn = min(id[k + i - 1] - id[i] + 1, mn);
}
if (mn == INT_MAX) return -1;
mn += (len - 1);
return mn;
}
int main() {
string s;
cin >> s;
int m;
cin >> m;
vector<string> query(m);
vector<int> k(m);
for (int i = 0; i < m; i++) {
cin >> k[i] >> query[i];
}
vector<struct STATE> states(1);
construct_trie(states, query);
build_automaton(states);
vector<vector<int> > index(m);
search_(states, s, index);
for (int i = 0; i < m; i++) {
cout << solve(k[i], index[i], (int)query[i].size()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int g[N][26], f[N], e[N], nc;
int ID[N], K[N], ans[N], L[N];
int gn() {
int p = nc++;
f[p] = e[p] = 0;
memset(g[p], 0, sizeof(g[p]));
return p;
}
void clr() {
nc = 0;
gn();
}
void ins(const string& s, int k, int id) {
int p = 0;
for (int i = 0; i != s.size(); ++i) {
int o = s[i] - 'a';
if (!g[p][o]) g[p][o] = gn();
L[g[p][o]] = L[p] + 1;
p = g[p][o];
}
e[p] = 1;
ID[p] = id;
K[p] = k;
ans[p] = INT_MAX;
}
int nex[N];
void build() {
queue<int> q;
for (int o = 0; o != 26; ++o)
if (g[0][o]) q.push(g[0][o]);
while (!q.empty()) {
int u = q.front();
q.pop();
if (e[f[u]])
nex[u] = f[u];
else
nex[u] = nex[f[u]];
for (int o = 0; o != 26; ++o) {
int& v = g[u][o];
if (!v)
v = g[f[u]][o];
else {
f[v] = g[f[u]][o];
q.push(v);
}
}
}
}
int n;
string s, temp;
vector<int> vc[N];
int res[N];
int main() {
cin >> s;
clr();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k;
cin >> k >> temp;
ins(temp, k, i);
}
build();
int len = s.size();
int u = 0;
for (int i = 0; i < len; i++) {
u = g[u][s[i] - 'a'];
for (int p = u; p; p = nex[p]) {
if (ID[p]) {
vc[p].push_back(i);
if (vc[p].size() >= K[p]) {
int sz = vc[p].size(), k = K[p];
ans[p] = min(ans[p], i - (vc[p][sz - k] - L[p]));
}
}
}
}
for (int i = 0; i <= nc; i++)
if (e[i]) res[ID[i]] = ans[i] == INT_MAX ? -1 : ans[i];
for (int i = 1; i <= n; i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limN = 1e5 + 5;
struct AhoCorasick {
enum { alpha = 26, first = 'a' };
struct Node {
int back, next[alpha], start = -1, end = -1, nmatches = 0;
Node(int v) { memset(next, v, sizeof(next)); }
};
vector<Node> N;
vector<int> backp;
void insert(string& s, int j) {
assert(!s.empty());
int n = 0;
for (auto& c : s) {
int& m = N[n].next[c - first];
if (m == -1) {
n = m = (int)(N).size();
N.emplace_back(-1);
} else
n = m;
}
if (N[n].end == -1) N[n].start = j;
backp.push_back(N[n].end);
N[n].end = j;
N[n].nmatches++;
}
AhoCorasick(vector<string>& pat) {
N.emplace_back(-1);
for (int i = 0; i < ((int)(pat).size()); ++i) insert(pat[i], i);
N[0].back = (int)(N).size();
N.emplace_back(0);
queue<int> q;
for (q.push(0); !q.empty(); q.pop()) {
int n = q.front(), prev = N[n].back;
for (int i = 0; i < (alpha); ++i) {
int &ed = N[n].next[i], y = N[prev].next[i];
if (ed == -1)
ed = y;
else {
N[ed].back = y;
(N[ed].end == -1 ? N[ed].end : backp[N[ed].start]) = N[y].end;
N[ed].nmatches += N[y].nmatches;
q.push(ed);
}
}
}
}
vector<int> find(string word) {
int n = 0;
vector<int> res;
for (auto& c : word) {
n = N[n].next[c - first];
res.push_back(N[n].end);
}
return res;
}
vector<vector<int> > findAll(vector<string>& pat, string word) {
vector<int> r = find(word);
vector<vector<int> > res((int)(word).size());
for (int i = 0; i < ((int)(word).size()); ++i) {
int ind = r[i];
while (ind != -1) {
res[i - (int)(pat[ind]).size() + 1].push_back(ind);
ind = backp[ind];
}
}
return res;
}
};
int main() {
char tmp[limN];
string orgo;
int N;
vector<int> req;
vector<string> wds;
vector<vector<int> > aprs;
vector<vector<int> > revo;
scanf("%s", tmp);
orgo = tmp;
scanf("%d", &N);
wds.resize(N), req.resize(N), revo.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &req[i]);
scanf("%s", tmp);
wds[i] = tmp;
}
AhoCorasick A = {wds};
aprs = A.findAll(wds, orgo);
int L = (int)aprs.size();
for (int i = 0; i < L; i++) {
for (int& c : aprs[i]) {
revo[c].push_back(i);
}
}
for (int i = 0; i < N; i++) {
if ((int)revo[i].size() < req[i]) {
printf("-1\n");
continue;
}
int k = req[i], ans = (1 << 30), len = wds[i].size();
for (int j = revo[i].size() - 1; j >= k - 1; j--) {
ans = min(ans, (revo[i][j] + len) - revo[i][j - k + 1]);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt_rand(chrono::system_clock::now().time_since_epoch().count());
template <typename T1, typename T2>
inline bool upmax(T1& a, T2 b) {
return (a < b ? (a = b, true) : false);
}
template <typename T1, typename T2>
inline bool upmin(T1& a, T2 b) {
return (b < a ? (a = b, true) : false);
}
const int maxn = (int)3e5 + 20;
const int maxlog = 21;
const int base = (int)1e9 + 7;
const long double eps = (long double)1e-7;
const long double PI = acos(-1.);
struct Koras {
struct Node {
vector<int> nxt, go;
int pred, ch, link;
vector<int> q;
Node() : nxt(26, -1), go(26, -1), pred(0), ch(0), link(-1){};
};
vector<Node> t;
Koras() { t.emplace_back(); }
int AddVertex(int pred, int ch) {
int v = ((int)(t).size());
t.emplace_back();
t.back().pred = pred;
t.back().ch = ch;
return v;
}
int AddString(const std::string& s, int ind) {
int v = 0;
for (char c : s) {
int cc = c - 'a';
if (t[v].nxt[cc] == -1) {
t[v].nxt[cc] = AddVertex(v, cc);
}
v = t[v].nxt[cc];
}
t[v].q.push_back(ind);
return v;
}
int Go(int v, int c) {
if (t[v].go[c] != -1) return t[v].go[c];
return t[v].go[c] = t[v].nxt[c] != -1 ? t[v].nxt[c]
: (v == 0 ? v : Go(GetLink(v), c));
}
int GetLink(int v) {
if (t[v].link != -1) return t[v].link;
return t[v].link =
v == 0 || t[v].pred == 0 ? 0 : Go(GetLink(t[v].pred), t[v].ch);
}
bool Empty() { return ((int)(t).size()) == 1; }
};
string s;
Koras st[maxn];
vector<string> queries;
int k[maxn];
int vertex[maxn];
vector<int> pos[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string t;
cin >> k[i] >> t;
queries.push_back(t);
int len = ((int)(t).size());
vertex[i] = st[len].AddString(t, i);
}
for (int len = 1; len < maxn; len++) {
if (st[len].Empty()) continue;
int v = 0;
for (int i = 0; i < ((int)(s).size()); i++) {
int c = s[i] - 'a';
v = st[len].Go(v, c);
for (int id : st[len].t[v].q) {
pos[id].push_back(i);
}
}
}
for (int i = 0; i < n; i++) {
if ((int)pos[i].size() < k[i]) {
cout << "-1\n";
continue;
}
int ans = (int)1e9;
for (int j = k[i] - 1; j < (int)pos[i].size(); j++) {
ans = min(ans, pos[i][j] - pos[i][j - k[i] + 1]);
}
cout << ans + ((int)(queries[i]).size()) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tax[100100], SA[100100], tp[100100], rk[100100], m[100100], s[100100], l, n,
w, top, t, a[100100], cnt;
char c[100100];
void rsort() {
memset(tax, 0, sizeof tax);
for (int i = 1; i <= n; i++) ++tax[rk[tp[i]]];
for (int i = 2; i <= n; i++) tax[i] += tax[i - 1];
for (int i = n; i; i--) SA[tax[rk[tp[i]]]--] = tp[i];
}
bool check(int x, int y) { return tp[x] == tp[y] && tp[x + w] == tp[y + w]; }
void _SA() {
for (int i = 1; i <= n; i++) rk[i] = s[i], tp[i] = i;
rsort();
int p = 0;
for (w = 1; p < n; w <<= 1) {
for (int i = 1; i <= n; i++) tp[i] = n - i + 1;
p = w;
for (int i = 1; i <= n; i++)
if (SA[i] > w) tp[++p] = SA[i] - w;
rsort();
memcpy(tp, rk, sizeof tp);
rk[SA[1]] = p = 1;
for (int i = 2; i <= n; i++) rk[SA[i]] = check(SA[i], SA[i - 1]) ? p : ++p;
}
}
int pd(int w) {
for (int i = 0; i < l; i++) {
if (i + w > n) return 0;
if (s[i + w] < m[i + 1]) return 0;
if (s[i + w] > m[i + 1]) return 2;
}
return 1;
}
int main() {
scanf("%s\n", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) s[i] = c[i] - 'a' + 1;
for (int i = 1; i <= n; i++) c[i] = 0;
_SA();
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
int k;
scanf("%d ", &k);
int ans = n + 1245;
scanf("%s\n", c + 1);
l = strlen(c + 1);
for (int j = 1; j <= l; j++) m[j] = c[j] - 'a' + 1, c[j] = 0;
int H, T, L, R, mid;
H = 1;
T = n;
L = T + 1;
while (H <= T)
if (pd(SA[mid = H + T >> 1]))
L = mid, T = mid - 1;
else
H = mid + 1;
H = 1;
T = n;
R = 0;
while (H <= T)
if (pd(SA[mid = H + T >> 1]) < 2)
R = mid, H = mid + 1;
else
T = mid - 1;
cnt = 0;
for (int j = L; j <= R; j++) a[++cnt] = SA[j];
sort(a + 1, a + cnt + 1);
for (int j = 0; j + k <= cnt; j++) ans = min(ans, a[j + k] - a[j + 1] + l);
if (ans > n)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug() { cerr << "\n"; }
template <typename H, typename... T>
void debug(H h, T... t) {
cerr << h;
if (sizeof...(t)) cerr << ", ";
debug(t...);
}
const int INF = 1e9 + 5, mod = 1e9 + 7;
const int A = 26, N = 1e6 + 5, M = 1005;
int edg[N][A];
int fail[N];
pair<int, int> par[N];
vector<int> term[N];
int SIZ = 1;
void add2(string &s, int k, int *node) {
while (k < (int)(s).size()) {
par[SIZ] = make_pair(*node, s[k] - 'a');
edg[*node][s[k] - 'a'] = SIZ;
*node = SIZ;
SIZ++;
k++;
}
}
void add(string &s, int num) {
int node = 0;
for (int i = 0; i < (int)(s).size(); i++) {
if (edg[node][s[i] - 'a'])
node = edg[node][s[i] - 'a'];
else {
add2(s, i, &node);
break;
}
}
term[node].push_back(num);
}
void calc_fail() {
vector<int> V(1);
for (int j = 0; j < (int)(V).size(); j++) {
int v = V[j];
if (par[v].first) {
fail[v] = fail[par[v].first];
while (fail[v] && !edg[fail[v]][par[v].second]) fail[v] = fail[fail[v]];
fail[v] = edg[fail[v]][par[v].second];
for (int i : term[fail[v]]) {
term[v].push_back(i);
}
}
for (int i = 0; i < A; i++)
if (edg[v][i]) V.push_back(edg[v][i]);
}
}
int Q[N], siz[N];
vector<int> ans[N];
void travel(string &s) {
int node = 0;
for (int i = 0; i < (int)(s).size(); i++) {
while (node && !edg[node][s[i] - 'a']) node = fail[node];
node = edg[node][s[i] - 'a'];
for (int j : term[node]) {
ans[j].push_back(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s;
cin >> s;
int q;
cin >> q;
for (int i = 0; i < q; i++) {
string t;
cin >> Q[i] >> t;
add(t, i);
siz[i] = (int)(t).size();
}
calc_fail();
travel(s);
for (int i = 0; i < q; ++i) {
int res = INF;
for (int j = 0; j <= (int)(ans[i]).size() - Q[i]; j++) {
res = min(res, ans[i][j + Q[i] - 1] - ans[i][j]);
}
if (res != INF)
cout << res + siz[i] << "\n";
else
cout << -1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int id = 1, ch[100010][27], fail[100010], K[100010], Len[100010], Q[100010],
bel[100010], tot;
char s[100010];
set<int> V[100010];
vector<int> G[100010];
void insert(char *s, int op) {
int len = strlen(s + 1);
int u = 1;
for (int i = 1; i <= len; i++) {
if (!ch[u][s[i] - 'a']) ch[u][s[i] - 'a'] = ++id;
u = ch[u][s[i] - 'a'];
}
V[u].insert(op);
}
void build_fail() {
for (int i = 0; i < 26; i++) ch[0][i] = 1;
fail[1] = 0;
int h = 0, t = 0;
Q[++t] = 1;
while (h != t) {
int p = Q[++h];
for (int i = 0; i < 26; i++) {
int y = ch[p][i];
if (!y) {
ch[p][i] = ch[fail[p]][i];
continue;
}
int K = fail[p];
for (; K && !ch[K][i]; K = fail[K])
;
fail[y] = ch[K][i];
for (auto i : V[fail[y]]) V[y].insert(i);
Q[++t] = y;
}
}
}
void getans() {
int n = strlen(s + 1);
int u = 1;
for (int i = 1; i <= n; i++) {
u = ch[u][s[i] - 'a'];
for (auto j : V[u]) G[j].push_back(i);
}
}
char t[100010];
int main() {
scanf("%s", s + 1);
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%s", &K[i], t + 1);
Len[i] = strlen(t + 1);
insert(t, i);
}
build_fail();
getans();
for (int i = 1; i <= Q; i++) {
int ans = 1e9;
for (int j = 0; j + K[i] - 1 < G[i].size(); j++)
ans = min(ans, G[i][j + K[i] - 1] - G[i][j] + Len[i]);
if (ans == 1e9)
puts("-1");
else
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
vector<int> res[100005];
struct ACfixed {
static const int ASZ = 26;
struct node {
array<int, ASZ> to;
int link = -1;
int tlink = -1;
int id = -1;
};
vector<node> d = {{}};
int add(string s, int id) {
int v = 0;
for (auto C : s) {
int c = C - 'a';
if (!d[v].to[c]) d[v].to[c] = d.size(), d.emplace_back();
v = d[v].to[c];
}
d[v].id = id;
return v;
}
void init() {
d[0].link = -1;
queue<int> q;
q.push(0);
while (q.size()) {
int v = q.front();
q.pop();
for (int c = 0; c < ASZ; c++) {
int u = d[v].to[c];
if (!u) continue;
d[u].link = d[v].link == -1 ? 0 : d[d[v].link].to[c];
d[u].tlink = (d[d[u].link].id == -1) ? d[d[u].link].tlink : d[u].link;
q.push(u);
}
if (v)
for (int c = 0; c < ASZ; c++)
if (!d[v].to[c]) d[v].to[c] = d[d[v].link].to[c];
}
}
void getAll(string &word) {
int v = 0;
for (int i = 0; i < word.length(); i++) {
v = d[v].to[word[i] - 'a'];
int cur = v;
while (cur >= 0) {
if (d[cur].id != -1) {
res[d[cur].id].push_back(i);
}
cur = d[cur].tlink;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n;
cin >> n;
string pat[n];
int num[n];
ACfixed ac;
for (int i = 0; i < n; i++) {
int nn;
cin >> nn;
string ss;
cin >> ss;
num[i] = nn;
pat[i] = ss;
ac.add(ss, i);
}
ac.init();
ac.getAll(s);
for (int i = 0; i < n; i++) {
if (res[i].size() < num[i]) {
cout << -1 << endl;
continue;
}
int ans = res[i][num[i] - 1] - res[i][0] + pat[i].length();
for (int j = 1; j + num[i] - 1 < res[i].size(); j++) {
ans = min(ans, res[i][num[i] - 1 + j] - res[i][j] + (int)pat[i].length());
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, kk[N], trie[N][26], fail[N], idx, w[N], len[N];
vector<int> p[N];
char s[N], ss[N];
void insert(int id) {
int pos = 0;
len[id] = strlen(s + 1);
for (int i = 1; i <= len[id]; i++) {
if (!trie[pos][s[i] - 'a']) trie[pos][s[i] - 'a'] = ++idx;
pos = trie[pos][s[i] - 'a'];
}
w[pos] = id;
}
void build() {
queue<int> q;
for (int i = 0; i < 26; i++)
if (trie[0][i]) q.push(trie[0][i]);
while (!q.empty()) {
int nd = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (trie[nd][i])
fail[trie[nd][i]] = trie[fail[nd]][i], q.push(trie[nd][i]);
else
trie[nd][i] = trie[fail[nd]][i];
}
for (int i = 1; i <= idx; i++)
while (fail[i] && !w[fail[i]]) fail[i] = fail[fail[i]];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> (ss + 1) >> n;
int m = strlen(ss + 1);
for (int i = 1; i <= n; i++) {
cin >> kk[i] >> (s + 1);
insert(i);
}
build();
int cur = 0;
for (int i = 1; i <= m; i++) {
cur = trie[cur][ss[i] - 'a'];
for (int j = cur; j != 0; j = fail[j])
if (w[j]) p[w[j]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (int(p[i].size()) < kk[i]) {
cout << -1 << endl;
continue;
}
int ans = m;
for (int j = 0, k = kk[i] - 1; k < int(p[i].size()); j++, k++)
ans = min(ans, p[i][k] - (p[i][j] - len[i]));
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 400040;
int ggg[M], tt[M], f[M], Rank[M], t[M], sa[M];
int q[M], ll[M], last[M], tot, l, s, m, n;
char c[M];
int len[N], nn, st[N], ans, height[M], L, R;
int A[N], K[N], LL;
int SQ, B[N];
void Sort(int x) {
if (x <= SQ)
sort(A + 1, A + 1 + x);
else {
for (int i = 0; i <= SQ; i++) f[i] = 0;
for (int i = 1; i <= x; i++) f[(A[i] % SQ) + 1]++;
for (int i = 1; i <= SQ; i++) f[i] += f[i - 1];
for (int i = 1; i <= x; i++) B[++f[A[i] % SQ]] = A[i];
for (int i = 0; i <= SQ; i++) f[i] = 0;
for (int i = 1; i <= x; i++) f[(B[i] / SQ) + 1]++;
for (int i = 1; i <= SQ; i++) f[i] += f[i - 1];
for (int i = 1; i <= x; i++) A[++f[B[i] / SQ]] = B[i];
}
}
inline int work(int x, int y, int z) {
if (y > x) return -1;
Sort(x);
int ans = n + 1;
for (int i = y; i <= x; i++) ans = min(ans, A[i] - A[i - y + 1] + z);
return ans;
}
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
LL = n;
c[++n] = '&';
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &K[i]);
scanf("%s", c + n + 1);
st[i] = n + 1;
len[i] = strlen(c + n + 1);
n = strlen(c + 1);
c[++n] = '&';
}
for (int i = 1; i <= n; i++) {
Rank[i] = int(c[i]);
ggg[Rank[i]]++;
}
for (int i = 1; i <= M - 5; i++) f[i] = f[i - 1] + ggg[i], ggg[i] = 0;
for (int i = 1; i <= n; i++) {
t[Rank[i]]++;
sa[f[Rank[i] - 1] + t[Rank[i]]] = i;
}
for (int tot = 0, j = 1; j < n; j *= 2, tot = 0) {
for (int i = n; i > n - j; i--) q[++tot] = i, tt[i] = 0;
for (int i = 1; i <= n; i++)
if (sa[i] - j > 0) {
q[++tot] = sa[i] - j;
tt[q[tot]] = Rank[sa[i]];
}
for (int i = 1; i <= n; i++) ggg[Rank[q[i]]]++;
for (int i = 1; i <= M - 5; i++)
f[i] = f[i - 1] + ggg[i], ggg[i] = 0, t[i] = ll[i] = 0, last[i] = -1;
for (int i = 1; i <= tot; i++) {
int yy = Rank[q[i]];
if (last[yy] < tt[q[i]]) ll[yy]++;
Rank[q[i]] = f[yy - 1] + ll[yy];
t[yy]++;
sa[f[yy - 1] + t[yy]] = q[i];
last[yy] = tt[q[i]];
}
}
int k = 0;
for (int i = 1; i <= n; i++) {
k -= (k > 0);
int j = sa[Rank[i] - 1], l1 = i + k, l2 = j + k;
while (l1 <= n && l2 <= n) {
if (c[l1] == c[l2]) {
l1++;
l2++;
k++;
} else
break;
}
height[Rank[i]] = k;
}
SQ = int(sqrt(100000)) + 1;
for (int i = 1; i <= m; i++) {
L = Rank[st[i]] - 1;
while (L && height[L + 1] >= len[i]) L--;
R = Rank[st[i]] + 1;
while (R <= n && height[R] >= len[i]) R++;
L++, R--;
tot = 0;
for (int j = L; j <= R; j++)
if (sa[j] <= LL) A[++tot] = sa[j];
printf("%d\n", work(tot, K[i], len[i]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > occurr;
struct Node {
int leaf;
int link;
int next[26];
set<int> out;
Node() {
for (int i = 0; i < 26; ++i) {
next[i] = 0;
}
leaf = link = 0;
}
};
vector<Node> trie(1);
void insert(string &s, int id) {
int node = 0;
for (char ch : s) {
if (!trie[node].next[ch - 'a']) {
trie[node].next[ch - 'a'] = trie.size();
trie.emplace_back();
}
node = trie[node].next[ch - 'a'];
}
trie[node].leaf = 1;
trie[node].out.insert(id);
}
void build() {
queue<int> q;
for (int i = 0; i < 26; ++i) {
if (trie[0].next[i]) {
q.push(trie[0].next[i]);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int ch = 0; ch < 26; ++ch) {
int v = trie[u].next[ch];
if (v) {
q.push(v);
int &link = trie[v].link;
link = trie[u].link;
while (link && trie[link].next[ch] == 0) {
link = trie[link].link;
}
if (trie[link].next[ch]) {
link = trie[link].next[ch];
}
if (trie[link].leaf) {
trie[v].leaf |= 2;
trie[v].out.insert(trie[link].out.begin(), trie[link].out.end());
}
} else {
trie[u].next[ch] = trie[trie[u].link].next[ch];
}
}
}
}
int n;
string text;
vector<int> matches;
void find_matches(int u, int idx) {
if (idx == text.size()) return;
int v = trie[u].next[text[idx] - 'a'];
if (trie[v].leaf) {
for (int i : trie[v].out) {
occurr[i].emplace_back(idx);
}
}
find_matches(v, idx + 1);
}
void print(string &txt) {
for (int i = 0; i < txt.size(); ++i) {
cout << setw(2) << i << ' ';
}
cout << '\n';
for (char &c : txt) {
cout << setw(2) << c << ' ';
}
cout << '\n';
}
int x, v[100123];
string s[100123];
int main() {
cin >> text;
cin >> n;
occurr = vector<vector<int> >(n, vector<int>());
for (int i = 0; i < n; ++i) {
cin >> v[i] >> s[i];
insert(s[i], i);
}
build();
find_matches(0, 0);
for (int i = 0; i < n; ++i) {
if (occurr[i].size() < v[i]) {
cout << "-1" << '\n';
} else {
int ans = text.size();
if (v[i] == 1) {
cout << s[i].size() << '\n';
continue;
}
for (int j = v[i] - 1; j < occurr[i].size(); ++j) {
ans =
min(ans, occurr[i][j] - occurr[i][j - v[i] + 1] + (int)s[i].size());
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using u64 = uint64_t;
using u32 = uint32_t;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vpi = vector<pi>;
static constexpr int INF = (int)1e9 + 5;
static constexpr ll INFL = (ll)INF * INF;
static mt19937 rng((u32)chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
namespace snippets_ahocorasick {
template <size_t K>
using AcTree = vector<array<int, K>>;
template <size_t K, class Iter, class F>
int ac_add(AcTree<K>& t, Iter it, Iter it_end, F f) {
if (!((int)(t).size())) t.emplace_back(), t.back().fill(-1);
int v = 0;
while (it != it_end) {
int i = f(*it++);
if (t[v][i] == -1)
t[v][i] = ((int)(t).size()), t.emplace_back(), t.back().fill(-1);
v = t[v][i];
}
return v;
}
template <size_t K>
int ac_add(AcTree<K>& t, string_view s, char base) {
return ac_add(t, (s).begin(), (s).end(), [&](char c) { return c - base; });
}
template <size_t K, class F>
void ac_finalize(AcTree<K>& t, F on_node) {
if (!((int)(t).size())) return;
queue<array<int, 4>> q;
q.push({0, -1, -1, -1});
while (((int)(q).size())) {
auto [v, c, p, plink] = q.front();
q.pop();
int link = (!v || !p ? 0 : t[plink][c]);
on_node(v, link, c, p);
for (int i = 0; i < (K); ++i) {
if (t[v][i] == -1)
t[v][i] = (v ? t[link][i] : 0);
else
q.push({t[v][i], i, v, link});
}
}
}
} // namespace snippets_ahocorasick
using namespace snippets_ahocorasick;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
int n;
cin >> s >> n;
vector<pair<int, string>> q(n);
AcTree<26> t;
vvi ends;
for (int i = 0; i < (n); ++i) {
auto& [ki, si] = q[i];
cin >> ki >> si;
int v = ac_add(t, si, 'a');
if (v >= ((int)(ends).size())) ends.resize(v + 1);
ends[v].push_back(i);
}
ac_finalize(t, [&](int v, int link, int, int) {
copy((ends[link]).begin(), (ends[link]).end(), back_inserter(ends[v]));
});
vi ans(n, INF);
vector<queue<int>> qs(n);
int v = 0;
for (int i = 0; i < (((int)(s).size())); ++i) {
v = t[v][s[i] - 'a'];
for (auto& j : ends[v]) {
qs[j].push(i);
if (((int)(qs[j]).size()) == q[j].first) {
int k = qs[j].front();
qs[j].pop();
ans[j] = min(ans[j], i - k + ((int)(q[j].second).size()));
}
}
}
for (int i = 0; i < (n); ++i) cout << (ans[i] == INF ? -1 : ans[i]) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using std::queue;
using std::vector;
const int N = 1e5 + 5;
const int LEN = 350;
const int inf = 0x3f3f3f3f;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
int son[26][N], n, m[N], idx = 1, fail[N], end[N], id, rans[N], kmp[N], len[N],
ANS[N], fa[N];
char s[N], t[N];
inline void insert(char *S, int LEN) {
int ps = 1, nxt;
for (int i = 1; i <= LEN; i++) {
nxt = (S[i] - 'a');
if (!son[nxt][ps]) son[nxt][ps] = (++idx);
ps = son[nxt][ps];
}
end[id] = ps;
}
queue<int> Q;
vector<int> e[N];
vector<int> g[N];
inline void bfs() {
for (int i = 0; i <= 25; i++)
if (son[i][1])
fail[son[i][1]] = 1, Q.push(son[i][1]);
else
son[i][1] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
e[fail[u]].emplace_back(u);
for (int i = 0; i <= 25; i++) {
if (son[i][u])
fail[son[i][u]] = son[i][fail[u]], Q.push(son[i][u]);
else
son[i][u] = son[i][fail[u]];
}
}
}
inline void dfs(int x) {
for (int v : e[x]) dfs(v), fa[v] = x;
}
inline void fz() {
for (int i = 1; i <= len[id]; i++) kmp[i] = 0;
kmp[1] = 0;
int Ans = inf;
for (int i = 2, j = 0; i <= len[id]; i++) {
while (j && t[j + 1] != t[i]) j = kmp[j];
if (t[j + 1] == t[i]) j++;
kmp[i] = j;
}
int LEN = strlen(s + 1), cnt = 0;
for (int i = 1, j = 0; i <= LEN; i++) {
while (j && t[j + 1] != s[i]) j = kmp[j];
if (t[j + 1] == s[i]) j++;
if (j == len[id]) {
ANS[++cnt] = i;
j = kmp[j];
if (cnt >= m[id]) Ans = std::min(Ans, ANS[cnt] - ANS[cnt - m[id] + 1]);
}
}
if (Ans == inf)
rans[id] = -1;
else
rans[id] = Ans + len[id];
}
int main() {
int ps = 1, nxt, tmp, Len;
scanf("%s", s + 1);
read(n);
for (int i = 1; i <= n; i++) {
read(m[i]);
scanf("%s", t + 1);
len[i] = strlen(t + 1);
id = i;
if (len[i] >= LEN) {
fz();
continue;
}
insert(t, len[id]);
}
bfs();
dfs(1);
ps = 1;
Len = strlen(s + 1);
for (int i = 1; i <= Len; i++) {
nxt = s[i] - 'a';
ps = son[nxt][ps];
tmp = ps;
while (tmp != 1) g[tmp].emplace_back(i), tmp = fa[tmp];
}
for (int i = 1; i <= n; i++) {
if (rans[i] != 0) continue;
if ((int)(g[end[i]].size()) < m[i]) {
rans[i] = -1;
continue;
}
int Ans = inf;
for (int j = m[i]; j <= (int)(g[end[i]].size()); j++)
Ans = std::min(Ans, g[end[i]][j - 1] - g[end[i]][j - m[i]]);
rans[i] = Ans + len[i];
}
for (int i = 1; i <= n; i++) printf("%d\n", rans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000009;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
int Ans[100005], K[100005], L[100005], Q;
string S;
vector<int> Pos[100005];
struct AhoCorasick {
struct Node {
bool dictionary_fail;
int fail, parent, word;
vector<int> next;
Node() {
next.resize(26, 0);
dictionary_fail = false;
fail = parent = word = 0;
}
};
int root, total;
vector<Node> nodes;
AhoCorasick() {
nodes.push_back(Node());
root = 0;
total = 1;
}
void add(string s, int id) {
int n = root;
for (int i = (0); i <= (((int)s.size()) - 1); i++) {
int l = s[i] - 'a';
if (nodes[n].next[l] == 0) {
nodes[n].next[l] = total++;
nodes.push_back(Node());
nodes[nodes[n].next[l]].parent = n;
}
n = nodes[n].next[l];
}
nodes[n].word = id;
}
string getWord(int n) {
string ret;
while (n != root) {
int p = nodes[n].parent;
for (int l = (0); l <= (25); l++)
if (nodes[p].next[l] == n) ret += (char)(l + 'a');
n = nodes[n].parent;
}
reverse(ret.begin(), ret.end());
return ret;
}
void printWords() {
queue<int> q;
q.push(root);
while (!q.empty()) {
int n = q.front();
q.pop();
if (nodes[n].word) cout << getWord(n) << "\n";
for (int l = (0); l <= (25); l++)
if (nodes[n].next[l] > 0) q.push(nodes[n].next[l]);
}
}
void makeFail() {
queue<int> q;
nodes[root].fail = root;
q.push(root);
while (!q.empty()) {
int n = q.front();
q.pop();
for (int l = (0); l <= (25); l++)
if (nodes[n].next[l] > 0) {
int child = nodes[n].next[l];
int suf = nodes[n].fail;
while (nodes[suf].next[l] == 0) {
if (suf == root) break;
suf = nodes[suf].fail;
}
if (nodes[suf].next[l] > 0 && nodes[suf].next[l] != child)
nodes[child].fail = nodes[suf].next[l];
else
nodes[child].fail = suf;
nodes[child].dictionary_fail =
nodes[nodes[child].fail].word |
nodes[nodes[child].fail].dictionary_fail;
q.push(nodes[n].next[l]);
}
}
}
void match(string t) {
int n = root;
for (int i = (0); i <= (((int)t.size()) - 1); i++) {
int l = t[i] - 'a';
while (nodes[n].next[l] == 0) {
if (n == root) break;
n = nodes[n].fail;
}
if (nodes[n].next[l] > 0) n = nodes[n].next[l];
int suf = n;
while (nodes[suf].word || nodes[suf].dictionary_fail) {
if (nodes[suf].word) Pos[nodes[suf].word].push_back(i);
suf = nodes[suf].fail;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
AhoCorasick aho;
cin >> S >> Q;
for (int q = (1); q <= (Q); q++) {
string t;
cin >> K[q] >> t;
L[q] = ((int)t.size());
aho.add(t, q);
}
aho.makeFail();
aho.match(S);
for (int q = (1); q <= (Q); q++) {
if (((int)Pos[q].size()) < K[q]) {
cout << "-1\n";
continue;
}
int ans = INF;
for (int i = (K[q] - 1); i <= (((int)Pos[q].size()) - 1); i++)
ans = min(ans, Pos[q][i] - Pos[q][i - K[q] + 1]);
cout << ans + L[q] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 14, sq = 200, maxt = maxn, z = 26;
int q, k[maxn], m[maxn], po[maxn], h[maxn], len[maxn], sz = 1, nxt[maxt][z];
int to[maxn];
vector<int> where[maxn];
string s, p[maxn];
int f[maxn];
int insert(string &s) {
int v = 0;
for (int i = 0; i < s.size(); i++) {
if (!nxt[v][s[i] - 'a']) nxt[v][s[i] - 'a'] = sz++;
v = nxt[v][s[i] - 'a'];
}
return v;
}
vector<int> kmp(string &s, string &p) {
vector<int> ret;
int k = 0;
for (int i = 1; i < p.size(); i++) {
while (k && p[k] != p[i]) k = f[k];
if (p[k] == p[i]) k++;
f[i + 1] = k;
}
k = 0;
for (int i = 0; i < s.size(); i++) {
while (k && p[k] != s[i]) k = f[k];
if (p[k] == s[i]) k++;
if (k == p.size()) {
ret.push_back(i);
k = f[k];
}
}
return ret;
}
int solve(const vector<int> &v, int k, int len) {
if (v.size() < k) return -1;
int ans = s.size();
for (int j = k - 1; j < v.size(); j++)
ans = min(ans, v[j] - v[j - k + 1] + len);
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
memset(to, -1, sizeof to);
cin >> s;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> k[i] >> p[i];
if (p[i].size() < sq) to[insert(p[i])] = i;
}
for (int i = 0; i < s.size(); i++) {
int p = 0;
for (int j = i; j < min<int>(s.size(), i + sq); j++) {
if (!nxt[p][s[j] - 'a']) break;
p = nxt[p][s[j] - 'a'];
if (to[p] != -1) where[to[p]].push_back(i);
}
}
for (int i = 0; i < q; i++)
cout << solve(p[i].size() < sq ? where[i] : kmp(s, p[i]), k[i], p[i].size())
<< '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
const int csize = 26;
int f[maxn][csize + 1];
int m = 2, id[maxn];
int val[maxn];
char ss[maxn], s0[maxn];
void insert(char s[], int u) {
int l = strlen(s);
int i, c, t = 1;
for (i = 0; i < l; i++) {
c = s[i] - 'a';
if (!f[t][c]) {
memset(f[m], 0, sizeof(f[m]));
f[t][c] = m++;
}
t = f[t][c];
}
val[t] = 1;
id[t] = u;
}
queue<int> q;
void build() {
int u, v, i;
q.push(1);
while (!q.empty()) {
u = q.front();
q.pop();
val[u] |= val[f[u][csize]];
for (i = 0; i < csize; i++) {
if (f[u][i]) {
v = f[u][csize];
while (v && !f[v][i]) v = f[v][csize];
f[f[u][i]][csize] = v ? f[v][i] : 1;
q.push(f[u][i]);
} else
f[u][i] = (u != 1) ? f[f[u][csize]][i] : 1;
}
}
}
int k[maxn], ans[maxn];
set<int> g[maxn];
vector<int> dt[maxn];
void funion(int x, int y) {
if (g[x].size() < g[y].size()) swap(g[x], g[y]);
for (auto e : g[y]) g[x].insert(e);
}
void dfs(int u) {
for (auto v : dt[u]) {
dfs(v);
funion(u, v);
}
if (id[u]) {
int r = id[u];
if ((int)g[u].size() <= k[r])
ans[r] = -1;
else {
auto l1 = g[u].begin();
auto l2 = l1;
for (int i = 0; i < k[r]; i++) l2++;
int res = mod;
while (l2 != g[u].end()) {
res = min((*l2) - (*l1), res);
l1++;
l2++;
}
ans[r] += res;
}
}
}
int main() {
scanf("%s", s0);
int n, num, i, j;
scanf(" %d", &n);
for (i = 1; i <= n; i++) {
scanf(" %d %s", &k[i], ss);
ans[i] = strlen(ss);
k[i]--;
insert(ss, i);
}
build();
num = strlen(s0);
for (i = 0, j = 1; i < num; i++) {
j = f[j][s0[i] - 'a'];
if (val[j]) g[j].insert(i);
}
for (i = 2; i < m; i++) dt[f[i][csize]].push_back(i);
dfs(1);
for (i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
void chmin(T1& a, T2 b) {
if (a > b) a = b;
}
template <class T1, class T2>
void chmax(T1& a, T2 b) {
if (a < b) a = b;
}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = INT_MAX;
const int mod = 1e9 + 7;
struct SuffixArray {
int n;
string s;
vector<int> sa;
SuffixArray(const string& s) : n(s.size()), s(s), sa(s.size() + 1) {
vector<int> rank(n + 1);
vector<int> tmp(n + 1);
for (int i = 0; i <= n; ++i) {
sa[i] = i;
rank[i] = i < n ? s[i] : -1;
}
for (int k = 1; k <= n; k <<= 1) {
auto cmp = [&](int i, int j) {
if (rank[i] != rank[j]) return rank[i] < rank[j];
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
};
sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; ++i) {
tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]);
}
swap(rank, tmp);
}
}
int lower_bound(const string& t) {
int lb = 0, ub = n + 1;
while (lb + 1 < ub) {
int mb = (lb + ub) / 2;
if (s.compare(sa[mb], t.size(), t) < 0)
lb = mb;
else
ub = mb;
}
return ub;
}
int upper_bound(const string& t) {
int lb = 0, ub = n + 1;
while (lb + 1 < ub) {
int mb = (lb + ub) / 2;
if (s.compare(sa[mb], t.size(), t) <= 0)
lb = mb;
else
ub = mb;
}
return ub;
}
int query(const string& t, const int k) {
int lb = lower_bound(t);
if (lb > n || s.compare(sa[lb], t.size(), t) != 0) return -1;
int ub = upper_bound(t);
if (ub - lb < k) return -1;
if (k == 1) return t.size();
vint vec;
for (int i = lb; i < ub; ++i) vec.push_back(sa[i]);
sort((vec).begin(), (vec).end());
int ans = inf;
for (int i = 0; i + k - 1 < (int)vec.size(); ++i) {
chmin(ans, vec[i + k - 1] - vec[i] + (int)t.size());
}
return ans;
}
};
signed main() {
char buf[100010];
scanf("%s", buf);
string s(buf);
SuffixArray SA(s);
int n;
scanf("%d", &n);
for (int i = (int)(0); i < (int)(n); i++) {
int k;
scanf("%d %s", &k, buf);
string m(buf);
printf("%d\n", SA.query(m, k));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
bool f = false;
char c;
int p = -1, link = -1, ex = -1;
int to[26], go[26];
vector<int> id;
node() {
memset(to, -1, sizeof(to));
memset(go, -1, sizeof(go));
}
};
int size = 1;
vector<node> trie(1);
void insert(string &s, int len, int j) {
int u, v = 0;
for (int i = 0; i < len; i++) {
int c = s[i] - 97;
if (trie[v].to[c] == -1) {
trie.emplace_back();
trie[v].to[c] = size++;
}
u = v;
v = trie[v].to[c];
trie[v].p = u, trie[v].c = s[i];
}
trie[v].f = true;
trie[v].id.push_back(j);
}
int go(int v, char c);
int get_link(int v) {
if (trie[v].link == -1) {
if (v == 0 || trie[v].p == 0)
trie[v].link = 0;
else
trie[v].link = go(get_link(trie[v].p), trie[v].c);
}
return trie[v].link;
}
int get_exit_link(int v) {
if (trie[v].ex == -1) {
if (v == 0)
trie[v].ex = 0;
else {
int u = get_link(v);
trie[v].ex = trie[u].f ? u : get_exit_link(u);
}
}
return trie[v].ex;
}
int go(int v, char c) {
int x = c - 97;
if (trie[v].go[x] == -1) {
if (trie[v].to[x] != -1)
trie[v].go[x] = trie[v].to[x];
else
trie[v].go[x] = v ? go(get_link(v), c) : 0;
}
return trie[v].go[x];
}
string s, t;
vector<int> a[100005];
int n, k[100005], len, ln[100005];
void get_id(int v, int i) {
int sz = trie[v].id.size();
for (int j = 0; j < sz; j++) {
int p = trie[v].id[j];
a[p].push_back(i - ln[p]);
}
}
void fun(string &s, int len, int i, int v) {
if (trie[v].f) get_id(v, i);
int u = get_exit_link(v);
while (u > 0) {
if (trie[u].f) get_id(u, i);
u = get_exit_link(u);
}
if (i < len) fun(s, len, i + 1, go(v, s[i]));
}
int query(int i) {
int s = a[i].size(), ans = -1;
for (int j = k[i] - 1, p = 0; j < s; j++, p++) {
int x = a[i][j] + ln[i] - a[i][p];
ans = (ans == -1) ? x : min(ans, x);
}
return ans;
}
int main() {
cin >> s >> n;
len = s.length();
for (int i = 0; i < n; i++) {
cin >> k[i] >> t;
ln[i] = t.length();
insert(t, ln[i], i);
}
fun(s, len, 0, 0);
for (int i = 0; i < n; i++) cout << query(i) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& n) {
char ch;
int sign = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') sign = -1;
n = ch - '0';
while (isdigit(ch = getchar())) n = n * 10 + ch - '0';
n *= sign;
}
const int INF = 1e9 + 7;
const int N = 322222;
int n, m;
char s[N];
int k[N], ans[N];
int rt(1), tt(1), p(1), ch[N][26], pa[N], len[N];
int id[N];
struct edge {
int to, nxt;
} g[N];
int ghead[N], gtail;
void add(int l, int r) { g[++gtail] = (edge){r, ghead[l]}, ghead[l] = gtail; }
void extend(int first, int pos) {
int np = ++tt;
len[np] = len[p] + 1, id[np] = pos;
for (; p && !ch[p][first]; p = pa[p]) ch[p][first] = np;
if (!p)
pa[np] = rt;
else {
int q = ch[p][first];
if (len[q] == len[p] + 1)
pa[np] = q;
else {
int nq = ++tt;
len[nq] = len[p] + 1;
memcpy(ch[nq], ch[q], sizeof(ch[q]));
pa[nq] = pa[q], pa[q] = pa[np] = nq;
for (; p && ch[p][first] == q; p = pa[p]) ch[p][first] = nq;
}
}
p = np;
}
void dfs(int first, vector<int>& seq) {
if (id[first]) seq.push_back(id[first]);
for (int p = ghead[first]; p; p = g[p].nxt) {
int v = g[p].to;
dfs(v, seq);
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (1); i <= (n); ++i) extend(s[i] - 'a', i);
for (int i = (1); i <= (tt); ++i)
if (pa[i]) add(pa[i], i);
read(m);
for (int i = (1); i <= (m); ++i) {
read(k[i]), scanf("%s", s + 1);
int l = strlen(s + 1), cur = rt;
for (int j = (1); j <= (l); ++j) {
int first = s[j] - 'a';
if (!ch[cur][first]) {
ans[i] = -1;
break;
}
cur = ch[cur][first];
}
if (ans[i] != -1) {
vector<int> seq;
dfs(cur, seq);
sort(seq.begin(), seq.end());
int res = INF;
for (int t = k[i] - 1; t < seq.size(); ++t)
res = min(res, seq[t] - seq[t - k[i] + 1]);
res += l;
if (res >= INF) res = -1;
ans[i] = res;
}
}
for (int i = (1); i <= (m); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxnode = 1e5 + 10, z = 26, inf = 1e9 + 10;
vector<int> ocr[maxn];
char s[maxn], t[maxn];
int n, m, ted[maxn], sz[maxn], ans[maxn];
struct Trie {
int to[maxnode][z], last = 1, val[maxnode], f[maxnode], Q[maxnode],
par[maxnode];
void add(int ii, char s[maxn], int size) {
int id = 0;
for (int i = 0; i < size; i++) {
if (to[id][s[i] - 'a'] == 0) {
to[id][s[i] - 'a'] = last++;
}
id = to[id][s[i] - 'a'];
}
val[id] = ii + 1;
}
void bfs() {
int l = 0, r = 0;
Q[r++] = 0;
while (l < r) {
int a = Q[l++];
if (val[a] > 0) {
if (val[f[a]] == 0) {
par[a] = 0;
} else {
par[a] = f[a];
}
} else {
val[a] = val[f[a]];
par[a] = f[a];
}
for (int i = 0; i < z; i++) {
if (to[a][i] == 0) {
to[a][i] = to[f[a]][i];
} else {
f[to[a][i]] = (a > 0) ? to[f[a]][i] : 0;
Q[r++] = to[a][i];
}
}
}
}
void solve() {
int id = 0;
for (int i = 0; i < m; i++) {
id = to[id][s[i] - 'a'];
int ii = id, vl = -1;
while (val[ii] > 0) {
if (vl != val[ii]) {
ocr[val[ii] - 1].push_back(i);
}
vl = val[ii];
ii = par[ii];
}
}
for (int i = 0; i < n; i++) {
for (int j = ted[i] - 1; j < int(ocr[i].size()); j++) {
if (ans[i] == -1 ||
ans[i] > ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i]) {
ans[i] = ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i];
}
}
}
}
} trie;
int32_t main() {
memset(ans, -1, sizeof ans);
scanf("%s%d", s, &n);
m = strlen(s);
for (int i = 0; i < n; i++) {
scanf("%d%s", ted + i, t);
sz[i] = strlen(t);
trie.add(i, t, sz[i]);
}
trie.bfs();
trie.solve();
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct Aho {
enum { ALPHA = 30 };
struct Node {
int p = -1, link = -1, superLink = -1;
int next[ALPHA], go[ALPHA];
bool leaf = false;
vector<int> leaves;
char ch;
Node(int p = -1, char c = '$') : p(p), ch(c) {
fill(begin(next), end(next), -1);
fill(begin(go), end(go), -1);
}
};
vector<Node> nodes;
void insert(string &s, int id) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (nodes[v].next[c] == -1) {
Node aux = Node(v, ch);
nodes[v].next[c] = (int)nodes.size();
nodes.push_back(aux);
}
v = nodes[v].next[c];
}
nodes[v].leaf = true;
nodes[v].leaves.push_back(id);
}
int go(int v, char ch) {
int c = ch - 'a';
if (nodes[v].go[c] == -1) {
if (nodes[v].next[c] != -1) {
nodes[v].go[c] = nodes[v].next[c];
} else {
if (v == 0)
nodes[v].go[c] = 0;
else
nodes[v].go[c] = go(nodes[v].link, ch);
}
}
return nodes[v].go[c];
}
Aho(vector<string> &vs) {
Node root = Node();
nodes.push_back(root);
int id = 0;
for (auto s : vs) insert(s, id++);
queue<int> fila;
nodes[0].link = 0;
for (int &v : nodes[0].next) {
if (v != -1) {
fila.push(v);
nodes[v].link = 0;
} else
v = 0;
}
while (!fila.empty()) {
int v = fila.front();
fila.pop();
for (int u : nodes[v].next) {
if (u != -1) {
int c = nodes[u].ch - 'a';
int fail = nodes[v].link;
while (nodes[fail].next[c] == -1) {
fail = nodes[fail].link;
}
fail = nodes[fail].next[c];
for (int id : nodes[fail].leaves) {
nodes[u].leaves.push_back(id);
}
nodes[u].link = fail;
fila.push(u);
}
}
}
}
int find(int idx, int p) {
if (idx != p and (nodes[idx].leaf or idx == 0)) return idx;
if (nodes[idx].superLink == -1) {
nodes[idx].superLink = find(nodes[idx].link, p);
}
return nodes[idx].superLink;
}
vector<vector<int> > findAll(string s, int n) {
vector<vector<int> > res(n + 5);
int idx = 0;
for (int i = 0; i < (int)s.size(); i++) {
char ch = s[i];
idx = go(idx, ch);
for (int id : nodes[idx].leaves) res[i].push_back(id);
}
return res;
}
};
string s;
string ss[100005];
int n;
int k[100005];
int32_t main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
cin >> s >> n;
vector<string> vs;
for (int i = 0; i < n; i++) {
cin >> k[i] >> ss[i];
vs.push_back(ss[i]);
}
Aho ac = Aho(vs);
auto res = ac.findAll(s, (int)s.size());
vector<vector<int> > pos(n + 5);
for (int i = 0; i < (int)res.size(); i++) {
for (int idx : res[i]) {
pos[idx].push_back(i);
}
}
for (int i = 0; i < n; i++) {
int res = 0x3f3f3f3f;
if ((int)pos[i].size() < k[i]) {
cout << -1 << '\n';
continue;
}
for (int j = 0; j + k[i] <= (int)pos[i].size(); j++) {
res = min(res, pos[i][k[i] + j - 1] - pos[i][j] + (int)ss[i].size());
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
pair<int, int> pr[N];
vector<int> v, occ[N];
int node[N][28], fail[N], path[N], end_pos[N], res[N], cnt, sz, up[N];
void insert(string s, int pos) {
int now = 0;
for (int i = 0; i < s.size(); i++) {
if (!node[now][s[i] - 'a']) node[now][s[i] - 'a'] = ++cnt;
now = node[now][s[i] - 'a'];
}
end_pos[now] = pos;
}
void failure() {
queue<int> q;
for (int i = 0; i < 26; i++)
if (node[0][i]) q.push(node[0][i]), v.push_back(node[0][i]);
while (!q.empty()) {
int u = q.front();
q.pop();
v.push_back(u);
for (int i = 0; i < 26; i++) {
int now = node[u][i];
if (now) {
int qq = fail[u];
while (qq and !node[qq][i]) qq = fail[qq];
if (u != qq and node[qq][i]) fail[node[u][i]] = node[qq][i];
q.push(now);
}
}
}
}
void ans(string s) {
for (auto i : v) {
if (end_pos[i])
up[i] = i;
else
up[i] = up[fail[i]];
}
int now = 0;
for (int i = 0; i < s.size(); i++) {
while (now and !node[now][s[i] - 'a']) now = fail[now];
if (node[now][s[i] - 'a']) now = node[now][s[i] - 'a'];
int x = up[now];
while (x) occ[end_pos[x]].push_back(i), x = up[fail[x]];
}
}
void make_clear() {
cnt = sz = 0;
memset(node, 0, sizeof(node));
memset(end_pos, 0, sizeof(end_pos));
memset(path, 0, sizeof(path));
memset(fail, 0, sizeof(fail));
}
int main() {
int t;
make_clear();
int n, m, i, b, j;
string s, ss;
cin >> s >> n;
for (i = 1; i <= n; i++)
cin >> m >> ss, insert(ss, i), pr[i].first = ss.size(), pr[i].second = m;
failure();
ans(s);
for (i = 1; i <= n; i++) {
int res = 1e9;
for (j = 0; j + pr[i].second - 1 < occ[i].size(); j++)
b = occ[i][j + pr[i].second - 1] - occ[i][j] + pr[i].first,
res = min(res, b);
if (res == 1e9) res = -1;
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long LINF = 2e16;
const int INF = 2e9;
const int magic = 348;
const double eps = 1e-10;
const double pi = 3.14159265;
inline int getint() {
char ch;
int res;
bool f;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
int ans[100048], Len[100048];
int pos_big[100048];
struct AC_Automation {
struct node {
int next[30];
int fail;
vector<int> mark;
int ind, K;
inline void init() {
fail = 0;
ind = 0;
K = 0;
mark.clear();
for (register int i = 1; i <= 26; i++) next[i] = 0;
}
} trie[100048];
int tot = 1;
vector<int> v[100048], allmark[100048];
inline void clear() {
for (register int i = 1; i <= tot; i++) v[i].clear(), allmark[i].clear();
tot = 1;
trie[tot].init();
}
inline void Insert(string s, int ind, int curk) {
int i, len = int(s.size()), cur = 1, w;
for (i = 1; i <= len; i++) {
w = s[i - 1] - 'a' + 1;
if (!trie[cur].next[w]) {
trie[cur].next[w] = ++tot;
trie[tot].init();
}
cur = trie[cur].next[w];
if (i == len) trie[cur].ind = ind, trie[cur].K = curk;
}
}
queue<int> q;
inline void construct_fail() {
q.push(1);
int i, cur, tmp;
while (!q.empty()) {
cur = q.front();
q.pop();
for (i = 1; i <= 26; i++)
if (trie[cur].next[i]) {
tmp = trie[cur].fail;
while (tmp && !trie[tmp].next[i]) tmp = trie[tmp].fail;
trie[trie[cur].next[i]].fail = (tmp ? trie[tmp].next[i] : 1);
v[trie[trie[cur].next[i]].fail].push_back(trie[cur].next[i]);
q.push(trie[cur].next[i]);
} else
trie[cur].next[i] = (cur == 1 ? 1 : trie[trie[cur].fail].next[i]);
}
}
inline void go_big(string s) {
int i, cur = 1, tmp, w, len = int(s.size());
for (i = 1; i <= len; i++) {
w = s[i - 1] - 'a' + 1;
cur = trie[cur].next[w];
trie[cur].mark.push_back(i);
}
}
inline void go_small(string s) {
int i, cur = 1, tmp, w, len = int(s.size());
for (i = 1; i <= len; i++) {
w = s[i - 1] - 'a' + 1;
cur = trie[cur].next[w];
tmp = cur;
while (tmp) trie[tmp].mark.push_back(i), tmp = trie[tmp].fail;
}
}
vector<int> tmp;
inline vector<int> merge(vector<int> a, vector<int> b) {
tmp.clear();
int n1 = int(a.size()) - 1, n2 = int(b.size()) - 1, k1, k2;
for (k1 = 0, k2 = 0; k1 <= n1 && k2 <= n2;)
if (a[k1] < b[k2])
tmp.push_back(a[k1++]);
else
tmp.push_back(b[k2++]);
while (k1 <= n1) tmp.push_back(a[k1++]);
while (k2 <= n2) tmp.push_back(b[k2++]);
return tmp;
}
inline void dfs(int cur) {
tmp = merge(tmp, trie[cur].mark);
for (register int i = 0; i < int(v[cur].size()); i++) dfs(v[cur][i]);
}
inline void solve_big() {
int i, j, cur;
for (cur = 2; cur <= tot; cur++)
if (trie[cur].ind) {
tmp.clear();
dfs(cur);
int k = trie[cur].K;
if (int(tmp.size()) < k) {
ans[trie[cur].ind] = -1;
continue;
}
ans[trie[cur].ind] = INF;
for (i = k - 1; i < int(tmp.size()); i++)
ans[trie[cur].ind] = min(
ans[trie[cur].ind], tmp[i] - tmp[i - k + 1] + Len[trie[cur].ind]);
}
}
inline void solve_small() {
int i, cur;
for (cur = 2; cur <= tot; cur++) {
if (trie[cur].ind) {
int k = trie[cur].K;
if (int(trie[cur].mark.size()) < k) {
ans[trie[cur].ind] = -1;
continue;
}
ans[trie[cur].ind] = INF;
for (i = k - 1; i < int(trie[cur].mark.size()); i++) {
ans[trie[cur].ind] =
min(ans[trie[cur].ind], trie[cur].mark[i] -
trie[cur].mark[i - k + 1] +
Len[trie[cur].ind]);
}
}
}
}
} A;
int n;
string s;
struct node {
string s;
int ind, k;
} big[100048], small[100048];
int btot = 0, stot = 0;
string tmp;
int kk;
int main() {
int i;
cin >> s;
n = getint();
for (i = 1; i <= n; i++) {
cin >> kk >> tmp;
Len[i] = int(tmp.size());
if (Len[i] > magic)
big[++btot] = node{tmp, i, kk};
else
small[++stot] = node{tmp, i, kk};
}
A.clear();
for (i = 1; i <= btot; i++) A.Insert(big[i].s, big[i].ind, big[i].k);
A.construct_fail();
A.go_big(s);
A.solve_big();
A.clear();
for (i = 1; i <= stot; i++) A.Insert(small[i].s, small[i].ind, small[i].k);
A.construct_fail();
A.go_small(s);
A.solve_small();
for (i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
struct node {
int ch[27], len, fa;
} dian[N];
struct edge {
int v, nxt;
} e[N];
int n, q, head[N], cnt, las = 1, tot = 1, fl[N], pos[N], ot, x, m, ans;
char s[N], t[N];
void ad(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void add(int c, int id) {
int np = ++tot, p = las;
fl[np] = id;
dian[np].len = dian[p].len + 1;
for (; p && !dian[p].ch[c]; p = dian[p].fa) dian[p].ch[c] = np;
if (!p)
dian[np].fa = 1;
else {
int q = dian[p].ch[c];
if (dian[q].len == dian[p].len + 1)
dian[np].fa = q;
else {
int nq = ++tot;
dian[nq] = dian[q];
dian[nq].len = dian[p].len + 1;
for (; p && dian[p].ch[c] == q; p = dian[p].fa) dian[p].ch[c] = nq;
dian[np].fa = nq;
dian[q].fa = nq;
}
}
las = np;
}
void dfs(int u) {
if (fl[u]) pos[++ot] = fl[u];
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
dfs(v);
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
add(s[i] - 'a', i);
}
for (int i = 2; i <= tot; i++) {
ad(dian[i].fa, i);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &x);
scanf("%s", t + 1);
ot = 0;
m = strlen(t + 1);
int u = 1, f = 0;
for (int j = 1; j <= m; j++) {
int to = t[j] - 'a';
u = dian[u].ch[to];
if (!u) {
f = 1;
break;
}
}
if (f) {
printf("-1\n");
continue;
}
dfs(u);
sort(pos + 1, pos + 1 + ot);
ans = 999999999;
for (int j = x; j <= ot; j++) {
ans = min(ans, pos[j] - (pos[j - x + 1] - m + 1) + 1);
}
if (ans == 999999999) {
printf("-1\n");
continue;
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXC = 26;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
struct SuffixAutomaton {
int root, size, last;
int child[MAXN][MAXC];
int fail[MAXN], depth[MAXN], num[MAXN];
vector<int> a[MAXN];
int newnode(int dep) {
fail[size] = 0;
depth[size] = dep;
memset(child[size], 0, sizeof(child[size]));
return size++;
}
void extend(int ch, int pos) {
int p = last, np = newnode(depth[last] + 1);
while (child[p][ch] == 0) {
child[p][ch] = np;
p = fail[p];
}
if (child[p][ch] == np)
fail[np] = root;
else {
int q = child[p][ch];
if (depth[q] == depth[p] + 1)
fail[np] = q;
else {
int nq = newnode(depth[p] + 1);
fail[nq] = fail[q];
fail[q] = fail[np] = nq;
memcpy(child[nq], child[q], sizeof(child[q]));
while (child[p][ch] == q) {
child[p][ch] = nq;
p = fail[p];
}
}
}
num[last = np] = pos;
}
void init(char *s) {
size = 0;
root = last = newnode(0);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) extend(s[i] - 'a', i);
for (int i = 1; i < size; i++) a[fail[i]].push_back(i);
}
int tot, pos[MAXN];
void dfs(int root) {
if (num[root]) pos[++tot] = num[root];
for (unsigned i = 0; i < a[root].size(); i++) dfs(a[root][i]);
}
int query(int cnt, char *s) {
int now = root, len = strlen(s + 1);
for (int i = 1; i <= len; i++)
if (child[now][s[i] - 'a'])
now = child[now][s[i] - 'a'];
else
return -1;
tot = 0;
dfs(now);
if (tot < cnt) return -1;
sort(pos + 1, pos + tot + 1);
int ans = MAXN;
for (int i = cnt; i <= tot; i++) chkmin(ans, pos[i] - pos[i - cnt + 1]);
return ans + len;
}
} SAM;
char s[MAXN], t[MAXN];
int main() {
scanf("%s", s + 1);
SAM.init(s);
int q;
read(q);
for (int i = 1; i <= q; i++) {
int cnt;
scanf("%d %s", &cnt, t + 1);
writeln(SAM.query(cnt, t));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
int n, q;
char s[100111];
int go[200111][26], tot = 1;
int pre[200111], len[200111];
int preid[200111];
int append(int p, int c) {
int np = ++tot;
len[np] = len[p] + 1;
while (p && !go[p][c]) go[p][c] = np, p = pre[p];
if (p == 0) {
pre[np] = 1;
return np;
}
int q = go[p][c];
if (len[q] == len[p] + 1) {
pre[np] = q;
return np;
} else {
int nq = ++tot;
len[nq] = len[p] + 1;
pre[nq] = pre[q];
pre[np] = pre[q] = nq;
copy(go[q], go[q] + 26, go[nq]);
while (p && go[p][c] == q) go[p][c] = nq, p = pre[p];
}
return np;
}
vector<int> son[200111];
void init() {
for (int i = 2; i <= tot; i++) {
son[pre[i]].push_back(i);
}
}
int v[100111], vn;
void dfs(int x) {
if (preid[x]) v[vn++] = preid[x];
for (auto u : son[x]) {
dfs(u);
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int st = 1;
for (int i = 1; i <= n; i++) {
st = append(st, s[i] - 'a');
preid[st] = i;
}
init();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int k;
scanf("%d%s", &k, s + 1);
int l = strlen(s + 1);
int p = 1;
for (int j = 1; j <= l; j++) {
p = go[p][s[j] - 'a'];
}
if (p == 0)
puts("-1");
else {
vn = 0;
dfs(p);
sort(v, v + vn);
if (vn < k)
puts("-1");
else {
int ans = mod;
for (int j = k - 1; j < vn; j++) {
ans = min(ans, v[j] - v[j - k + 1]);
}
printf("%d\n", ans + l);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int trie[N][26], tot, fail[N], fg[N], L[N];
char s[N], t[N];
int cnt[N], st[N], nex[N], ans[N];
queue<int> Q[N];
void insert(int ix) {
int len = strlen(t + 1), p = 0;
for (int i = 1; i <= len; i++) {
int c = t[i] - 'a';
if (!trie[p][c]) trie[p][c] = ++tot;
p = trie[p][c];
}
fg[p] = ix;
L[p] = len;
}
void getfail() {
queue<int> q;
for (int i = 0; i < 26; i++) {
if (trie[0][i]) {
fail[trie[0][i]] = 0;
q.push(trie[0][i]);
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
if (fg[fail[now]])
nex[now] = fail[now];
else
nex[now] = nex[fail[now]];
for (int i = 0; i < 26; i++) {
if (trie[now][i]) {
fail[trie[now][i]] = trie[fail[now]][i];
q.push(trie[now][i]);
} else {
trie[now][i] = trie[fail[now]][i];
}
}
}
}
void getans() {
int len = strlen(s + 1), p = 0;
for (int i = 1; i <= len; i++) {
int c = s[i] - 'a';
p = trie[p][c];
for (int j = p; j; j = nex[j]) {
Q[fg[j]].push(i);
if (Q[fg[j]].size() == cnt[fg[j]])
ans[fg[j]] = min(ans[fg[j]], i - Q[fg[j]].front() + L[j]),
Q[fg[j]].pop();
}
}
}
int main() {
scanf("%s", s + 1);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%s", &cnt[i], t + 1);
insert(i);
ans[i] = N;
}
getfail();
getans();
for (int i = 1; i <= n; i++) printf("%d\n", ans[i] == N ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 7;
const int INF = 0x7fffffff;
int r[N], sa[N], rk[N], het[N];
int wa[N], wb[N], wx[N], wv[N];
bool ise(int *r, int a, int b, int len) {
return r[a] == r[b] && r[a + len] == r[b + len];
}
void getSa(int n, int m) {
int *x = wa, *y = wb;
for (int i = (0); i < (m); i++) wx[i] = 0;
for (int i = (0); i < (n); i++) ++wx[x[i] = r[i]];
for (int i = (1); i < (m); i++) wx[i] += wx[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--wx[x[i]]] = i;
for (int j = 1, p = 0; p < n; j <<= 1, m = p) {
p = 0;
for (int i = (n - j); i < (n); i++) y[p++] = i;
for (int i = (0); i < (n); i++) sa[i] >= j ? y[p++] = sa[i] - j : 0;
for (int i = (0); i < (m); i++) wx[i] = 0;
for (int i = (0); i < (n); i++) ++wx[wv[i] = x[y[i]]];
for (int i = (1); i < (m); i++) wx[i] += wx[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--wx[wv[i]]] = y[i];
p = 1, swap(x, y);
x[sa[0]] = 0;
for (int i = (1); i < (n); i++)
x[sa[i]] = ise(y, sa[i], sa[i - 1], j) ? p - 1 : p++;
}
}
void getHeight(int n) {
for (int i = (1); i < (n + 1); i++) rk[sa[i]] = i;
for (int i = 0, k = 0; i < n; het[rk[i++]] = k) {
k = k > 0 ? k - 1 : 0;
for (int j = sa[rk[i] - 1]; r[i + k] == r[j + k]; ++k)
;
}
}
vector<int> V;
string data[100005];
int pos[100005], num[100005];
int main() {
string aa;
cin >> aa;
int flag = 1;
for (int i = (1); i < (aa.length()); i++)
if (aa[i] != aa[0]) flag = 0;
if (flag) {
int n;
cin >> n;
for (int i = (0); i < (n); i++) {
int ans = 0;
pos[i] = aa.length();
cin >> num[i] >> data[i];
for (int j = (0); j < (data[i].length()); j++)
if (data[i][j] != aa[0]) ans = -1;
if (ans == -1)
puts("-1");
else if (aa.length() - data[i].length() + 1 < num[i])
puts("-1");
else
printf("%d\n", data[i].length() + num[i] - 1);
}
return 0;
}
aa = aa + "#";
int n;
cin >> n;
for (int i = (0); i < (n); i++) {
pos[i] = aa.length();
cin >> num[i] >> data[i];
aa = aa + data[i] + "#";
}
for (int i = (0); i < (aa.length()); i++)
r[i] = (aa[i] == '#' ? 27 : aa[i] - 'a' + 1);
r[aa.length()] = 0;
getSa(aa.length() + 1, 30);
getHeight(aa.length());
for (int i = (0); i < (n); i++) {
int ans = 0x3f3f3f3f;
V.clear();
int l = rk[pos[i]], r = rk[pos[i]];
V.push_back(sa[l]);
while (het[l] >= data[i].length()) V.push_back(sa[--l]);
while (het[r + 1] >= data[i].length()) V.push_back(sa[++r]);
sort(V.begin(), V.end());
for (int j = (num[i] - 1); j < ((int)(V).size()); j++) {
if (V[j] >= pos[0]) break;
ans = min(ans, V[j] - V[j - num[i] + 1]);
}
if (ans != 0x3f3f3f3f)
printf("%d\n", ans + data[i].length());
else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using std ::lower_bound;
using std ::sort;
using std ::unique;
using std ::vector;
template <typename T>
T max(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
T min(T x, T y) {
return (x < y) ? x : y;
}
template <typename T>
bool chkmax(T &x, T y) {
return (x >= y) ? 0 : (x = y, 1);
}
template <typename T>
bool chkmin(T &x, T y) {
return (x <= y) ? 0 : (x = y, 1);
}
template <typename T>
T read(T &in) {
in = 0;
char ch;
T f = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) in = in * 10 + ch - '0', ch = getchar();
return in *= f;
}
static const int max1 = 100000 + 11;
int q;
int k[max1], qlen[max1];
int dlen[max1], dl;
char InS[max1], S[max1], *T[max1];
vector<int> SolveAt[max1];
int ch[max1][26], fail[max1], At[max1], q_fail[max1], nd;
vector<int> App[max1];
void Insert(int id) {
int p = 0;
for (int i = (0), ir = (qlen[id] - 1); i <= (ir); ++i) {
int c = T[id][i] - 'a';
if (!ch[p][c]) ch[p][c] = ++nd;
p = ch[p][c];
}
At[p] = id;
}
void BuildFail() {
static int que[max1], *front, *back;
front = back = que;
for (int i = (0), ir = (25); i <= (ir); ++i)
if (ch[0][i]) *(++back) = ch[0][i], fail[ch[0][i]] = 0;
while (front != back) {
int x = *(++front);
q_fail[x] = At[fail[x]] ? fail[x] : q_fail[fail[x]];
for (int i = (0), ir = (25); i <= (ir); ++i)
if (ch[x][i]) {
int np = ch[x][i];
fail[np] = ch[fail[x]][i];
*(++back) = np;
} else
ch[x][i] = ch[fail[x]][i];
}
}
void solve(int dnow) {
memset(At, 0, sizeof(int) * (nd + 1)),
memset(fail, 0, sizeof(int) * (nd + 1)),
memset(q_fail, 0, sizeof(int) * (nd + 1));
for (int i = (0), ir = (nd); i <= (ir); ++i) memset(ch[i], 0, sizeof ch[i]);
nd = 0;
for (vector<int>::iterator i = SolveAt[dnow].begin();
i != SolveAt[dnow].end(); ++i)
Insert(*i);
BuildFail();
static int n = strlen(S);
int p = 0;
for (int i = (0), ir = (n - 1); i <= (ir); ++i) {
p = ch[p][S[i] - 'a'];
for (int j = p; j; j = q_fail[j])
if (At[j]) App[At[j]].push_back(i);
}
}
int GetAns(int id) {
int k = ::k[id];
if ((int)App[id].size() < k) return -1;
int Ans = INT_MAX;
for (int i = (k - 1), ir = ((int)App[id].size() - 1); i <= (ir); ++i)
chkmin(Ans, App[id][i] - App[id][i - k + 1]);
return Ans + qlen[id];
}
int main() {
scanf("%s", S);
read(q);
for (int i = (1), ir = (q); i <= (ir); ++i) {
read(k[i]), scanf("%s", InS);
qlen[i] = strlen(InS);
T[i] = new char[qlen[i]];
memcpy(T[i], InS, sizeof(char) * qlen[i]);
dlen[++dl] = qlen[i];
}
sort(1 + dlen, 1 + dl + dlen),
dl = unique(1 + dlen, 1 + dl + dlen) - dlen - 1;
for (int i = (1), ir = (q); i <= (ir); ++i)
SolveAt[lower_bound(1 + dlen, 1 + dl + dlen, qlen[i]) - dlen].push_back(i);
for (int i = (1), ir = (dl); i <= (ir); ++i) solve(i);
for (int i = (1), ir = (q); i <= (ir); ++i) printf("%d\n", GetAns(i));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int bl = 100;
const int maxi = 1e6;
char ch[1000000];
const long long mo1 = 1e9 + 7;
const long long b1 = 37;
const long long b2 = 71;
const long long mo2 = 1e9 + 8;
int q;
string s;
int k[maxi];
string m[maxi];
int kmp[maxi];
int br[maxi];
vector<int> v[maxi];
map<pair<int, int>, int> mp;
int d[maxi];
long long st1[maxi], st2[maxi];
pair<pair<long long, long long>, int> ar[maxi];
void calc(string t, string s, int num) {
kmp[1] = 0;
string ans = t;
ans += '#';
ans += s;
int start = t.size() + 2;
int len = t.size();
int n = ans.size();
for (int i = 2; i <= n; i++) {
int cur = i - 1;
while (cur > 0 && ans[kmp[cur]] != ans[i - 1]) cur = kmp[cur];
if (ans[kmp[cur]] == ans[i - 1])
kmp[i] = kmp[cur] + 1;
else
kmp[i] = 0;
}
int cnt = 0;
int maxd = 1000000;
for (int i = start; i <= n; i++)
if (kmp[i] == len) {
cnt++;
br[cnt] = i;
if (cnt >= num) maxd = min(maxd, br[cnt] - br[cnt - num + 1] + len);
}
if (cnt < num)
printf("-1\n");
else
printf("%d\n", maxd);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> s;
cin >> q;
st1[0] = 1;
st2[0] = 1;
for (int i = 1; i < maxi; i++) {
st1[i] = (st1[i - 1] * b1) % mo1;
st2[i] = (st2[i - 1] * b2) % mo2;
}
for (int i = 1; i <= q; i++) {
cin >> k[i] >> m[i];
if (m[i].size() <= bl) {
long long hs1 = 0;
long long hs2 = 0;
for (int j = 0; j < m[i].size(); j++) {
hs1 = (hs1 + st1[j] * m[i][j]) % mo1;
hs2 = (hs2 + st2[j] * m[i][j]) % mo2;
}
ar[i] = {{hs1, hs2}, i};
}
}
sort(ar + 1, ar + q + 1);
for (int i = 1; i <= q; i++) d[i] = 1000000;
int sz = s.size();
for (int i = 1; i <= sz; i++) {
string str = "";
long long hs1 = 0;
long long hs2 = 0;
for (int j = i; j <= min(sz, i + bl); j++) {
hs1 = (hs1 + st1[j - i] * s[j - 1]) % mo1;
hs2 = (hs2 + st2[j - i] * s[j - 1]) % mo2;
int l = 0;
int r = q + 1;
while (l < r - 1) {
int mid = l + r >> 1;
if (hs1 > ar[mid].first.first ||
(hs1 == ar[mid].first.first && hs2 > ar[mid].first.second))
l = mid;
else
r = mid;
}
int id = 0;
l++;
if (hs1 == ar[l].first.first && hs2 == ar[l].first.second)
id = ar[l].second;
if (id > 0) {
v[id].push_back(j);
int last = v[id].size();
if (last >= k[id]) {
int ln = m[id].size();
d[id] = min(d[id], j - v[id][last - k[id]] + ln);
}
}
}
}
for (int i = 1; i <= q; i++) {
if (m[i].size() > bl)
calc(m[i], s, k[i]);
else if (d[i] == 1000000)
printf("-1\n");
else
printf("%d\n", d[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Max(int &x, int y) { x = max(x, y); }
void Min(int &x, int y) { x = min(x, y); }
const int N = 1e5 + 5;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << '(' << a.first << ", " << a.second << ')';
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
for (unsigned int i = 0; i < a.size(); i++)
os << a[i] << (i < a.size() - 1 ? ", " : "");
os << ']';
return os;
}
struct ahoCorasick {
int child[N][26];
vector<int> sta, en;
int fail[N];
int term[N];
vector<vector<int> > id;
int peak = 0, Time = 0;
vector<vector<int> > a;
ahoCorasick() {
peak = 0;
Time = 0;
memset(child, 0, sizeof(child));
memset(fail, 0, sizeof(fail));
id.assign(N, vector<int>());
}
void dfs(int u) {
sta[u] = ++Time;
for (auto v : a[u]) dfs(v);
en[u] = Time;
}
private:
void createTree() {
a.assign(peak + 5, vector<int>());
sta.assign(peak + 5, 0);
en.assign(peak + 5, 0);
for (signed i = (1); i <= (peak); i++) a[fail[i]].push_back(i);
dfs(0);
}
public:
int add(string s, int _id) {
int u = 0;
for (auto &it : s) {
if (child[u][it - 'a'] == 0) child[u][it - 'a'] = ++peak;
u = child[u][it - 'a'];
}
id[u].push_back(_id);
return u;
}
void createAho() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
for (signed i = (0); i <= (25); i++) {
int v = child[u][i];
int fv = child[fail[u]][i];
if (v == 0) {
child[u][i] = fv;
} else {
if (fv == v)
fail[v] = 0;
else {
fail[v] = fv;
if (!id[fv].empty())
term[v] = fv;
else
term[v] = term[fv];
}
q.push(v);
}
}
}
}
void findAllOccur(string &s, vector<vector<int> > &app) {
int u = 0;
for (signed i = (0); i <= (s.size() - 1); i++) {
auto c = s[i];
u = child[u][c - 'a'];
int v = u;
while (v != 0) {
for (auto it : id[v]) app[it].push_back(i);
v = term[v];
}
}
}
} Aho;
vector<pair<int, string> > query;
vector<vector<int> > app(N);
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string a;
cin >> a;
int q;
cin >> q;
for (signed i = (1); i <= (q); i++) {
int need;
string s;
cin >> need >> s;
query.push_back(make_pair(need, s));
Aho.add(s, i - 1);
}
Aho.createAho();
Aho.findAllOccur(a, app);
for (signed i = (0); i <= (q - 1); i++) {
if (((signed)app[i].size()) < query[i].first) {
cout << -1 << '\n';
continue;
}
int ans = 1e9;
for (signed j = (query[i].first - 1); j <= (((signed)app[i].size()) - 1);
j++) {
int R = app[i][j];
int L =
app[i][j - query[i].first + 1] - ((signed)query[i].second.size()) + 1;
ans = min(ans, R - L + 1);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int n, k[MAXN], l[MAXN];
char s[MAXN], t[MAXN];
vector<int> pos[MAXN];
struct Trie {
int next[MAXN][26], fail[MAXN], suf[MAXN], end[MAXN];
int cnt;
void insert(char buf[], int k) {
int len = strlen(buf);
int now = 0;
for (int i = 0; i < len; i++) {
if (!next[now][buf[i] - 'a']) next[now][buf[i] - 'a'] = ++cnt;
now = next[now][buf[i] - 'a'];
}
end[now] = k;
}
void build() {
queue<int> q;
for (int i = 0; i < 26; i++)
if (next[0][i]) q.push(next[0][i]);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
if (next[now][i]) {
fail[next[now][i]] = next[fail[now]][i];
suf[next[now][i]] = end[fail[next[now][i]]] ? fail[next[now][i]]
: suf[fail[next[now][i]]];
q.push(next[now][i]);
} else
next[now][i] = next[fail[now]][i];
}
}
}
void solve(char buf[]) {
int len = strlen(buf);
int now = 0;
for (int i = 0; i < len; i++) {
now = next[now][buf[i] - 'a'];
for (int t = now; t; t = suf[t])
if (end[t]) pos[end[t]].push_back(i);
}
}
} ac;
int main() {
scanf("%s", s);
scanf("%d", &n);
int key = 0;
if (n == 4) key = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &k[i]);
scanf("%s", t);
if (key) printf("%s\n", t);
l[i] = strlen(t);
ac.insert(t, i);
}
ac.build();
ac.solve(s);
for (int i = 1; i <= n; i++) {
int m = pos[i].size();
if (m < k[i])
puts("-1");
else {
int ans = MAXN;
for (int j = 0; j <= m - k[i]; j++)
ans = min(ans, pos[i][j + k[i] - 1] - pos[i][j]);
printf("%d\n", ans + l[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&...args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
} // namespace std
template <class Iterator>
class IteratorRange {
public:
IteratorRange(Iterator begin, Iterator end) : begin_(begin), end_(end) {}
Iterator begin() const { return begin_; }
Iterator end() const { return end_; }
private:
Iterator begin_, end_;
};
namespace traverses {
template <class Vertex, class Graph, class Visitor>
void BreadthFirstSearch(Vertex origin_vertex, const Graph &graph,
Visitor visitor) {
std::unordered_set<Vertex> visited{origin_vertex};
std::queue<Vertex> queue;
visitor.DiscoverVertex(origin_vertex);
queue.push(origin_vertex);
while (!queue.empty()) {
auto vertex = queue.front();
queue.pop();
visitor.ExamineVertex(vertex);
for (const auto &edge : OutgoingEdges(graph, vertex)) {
auto target = GetTarget(graph, edge);
visitor.ExamineEdge(edge);
if (visited.count(target)) {
continue;
}
visitor.DiscoverVertex(target);
visited.insert(target);
queue.push(target);
}
}
}
template <class Vertex, class Edge>
class BfsVisitor {
public:
virtual void DiscoverVertex(Vertex) {}
virtual void ExamineEdge(const Edge &) {}
virtual void ExamineVertex(Vertex) {}
virtual ~BfsVisitor() = default;
};
} // namespace traverses
struct AutomatonNode {
AutomatonNode() : suffix_link(nullptr), terminal_link(nullptr) {}
std::vector<size_t> terminated_string_ids;
std::map<char, AutomatonNode> trie_transitions;
std::map<char, AutomatonNode *> automaton_transitions_cache;
AutomatonNode *suffix_link;
AutomatonNode *terminal_link;
};
AutomatonNode *GetTrieTransition(AutomatonNode *node, char character) {
auto transition = node->trie_transitions.find(character);
if (transition != node->trie_transitions.end()) {
return &transition->second;
}
return nullptr;
}
AutomatonNode *GetAutomatonTransition(AutomatonNode *node,
const AutomatonNode *root,
char character) {
auto cache_transition = node->automaton_transitions_cache.find(character);
if (cache_transition != node->automaton_transitions_cache.end()) {
return cache_transition->second;
}
AutomatonNode *automaton_transition = GetTrieTransition(node, character);
if (automaton_transition) {
return node->automaton_transitions_cache[character] = automaton_transition;
}
if (node == root) {
automaton_transition = node;
} else {
automaton_transition =
GetAutomatonTransition(node->suffix_link, root, character);
}
return node->automaton_transitions_cache[character] = automaton_transition;
}
namespace internal {
class AutomatonGraph {
public:
struct Edge {
Edge(AutomatonNode *source, AutomatonNode *target, char character)
: source(source), target(target), character(character) {}
AutomatonNode *source;
AutomatonNode *target;
char character;
};
};
std::vector<typename AutomatonGraph::Edge> OutgoingEdges(
const AutomatonGraph &, AutomatonNode *vertex) {
std::vector<typename AutomatonGraph::Edge> edges;
for (auto &trie_transition : vertex->trie_transitions) {
edges.emplace_back(vertex, &trie_transition.second, trie_transition.first);
}
return edges;
}
AutomatonNode *GetTarget(const AutomatonGraph &,
const AutomatonGraph::Edge &edge) {
return edge.target;
}
class SuffixLinkCalculator
: public traverses::BfsVisitor<AutomatonNode *, AutomatonGraph::Edge> {
public:
explicit SuffixLinkCalculator(AutomatonNode *root) : root_(root) {}
void ExamineVertex(AutomatonNode *node) override {
if (!node->suffix_link) {
node->suffix_link = root_;
}
}
void ExamineEdge(const AutomatonGraph::Edge &edge) override {
AutomatonNode *node = edge.source;
AutomatonNode *target = edge.target;
char character = edge.character;
if (node == root_) {
target->suffix_link = root_;
} else {
target->suffix_link =
GetAutomatonTransition(node->suffix_link, root_, character);
}
}
private:
AutomatonNode *root_;
};
class TerminalLinkCalculator
: public traverses::BfsVisitor<AutomatonNode *, AutomatonGraph::Edge> {
public:
explicit TerminalLinkCalculator(AutomatonNode *root) : root_(root) {}
void DiscoverVertex(AutomatonNode *node) override {
node->terminal_link = nullptr;
if (node == root_) {
return;
}
if (node->suffix_link->terminated_string_ids.empty()) {
node->terminal_link = node->suffix_link->terminal_link;
return;
}
node->terminal_link = node->suffix_link;
}
private:
AutomatonNode *root_;
};
} // namespace internal
class NodeReference {
public:
NodeReference() : node_(nullptr), root_(nullptr) {}
NodeReference(AutomatonNode *node, AutomatonNode *root)
: node_(node), root_(root) {}
NodeReference Next(char character) const {
return {GetAutomatonTransition(node_, root_, character), root_};
}
template <class Callback>
void GenerateMatches(Callback on_match) const {
auto current = *this;
while (current) {
for (size_t string_id : current.TerminatedStringIds()) {
on_match(string_id);
}
current = current.TerminalLink();
}
}
bool IsTerminal() const { return !node_->terminated_string_ids.empty(); }
explicit operator bool() const { return node_ != nullptr; }
bool operator==(const NodeReference &other) const {
return node_ == other.node_ && root_ == other.root_;
}
private:
using TerminatedStringIterator = std::vector<size_t>::const_iterator;
using TerminatedStringIteratorRange = IteratorRange<TerminatedStringIterator>;
NodeReference TerminalLink() const { return {node_->terminal_link, root_}; }
TerminatedStringIteratorRange TerminatedStringIds() const {
return {node_->terminated_string_ids.begin(),
node_->terminated_string_ids.end()};
}
AutomatonNode *node_;
AutomatonNode *root_;
};
class AutomatonBuilder;
class Automaton {
public:
Automaton() = default;
Automaton(const Automaton &) = delete;
Automaton &operator=(const Automaton &) = delete;
NodeReference Root() { return {&root_, &root_}; }
private:
AutomatonNode root_;
friend class AutomatonBuilder;
};
class AutomatonBuilder {
public:
void Add(const std::string &string, size_t id) {
words_.push_back(string);
ids_.push_back(id);
}
std::unique_ptr<Automaton> Build() {
auto automaton = std::make_unique<Automaton>();
BuildTrie(words_, ids_, automaton.get());
BuildSuffixLinks(automaton.get());
BuildTerminalLinks(automaton.get());
return automaton;
}
private:
static void BuildTrie(const std::vector<std::string> &words,
const std::vector<size_t> &ids, Automaton *automaton) {
for (size_t i = 0; i < words.size(); ++i) {
AddString(&automaton->root_, ids[i], words[i]);
}
}
static void AddString(AutomatonNode *root, size_t string_id,
const std::string &string) {
AutomatonNode *current = root;
for (char symbol : string) {
current = ¤t->trie_transitions[symbol];
}
current->terminated_string_ids.push_back(string_id);
}
static void BuildSuffixLinks(Automaton *automaton) {
internal::SuffixLinkCalculator suffix_link_calculator(&automaton->root_);
traverses::BreadthFirstSearch(&automaton->root_, internal::AutomatonGraph(),
suffix_link_calculator);
}
static void BuildTerminalLinks(Automaton *automaton) {
internal::TerminalLinkCalculator terminal_link_calculator(
&automaton->root_);
traverses::BreadthFirstSearch(&automaton->root_, internal::AutomatonGraph(),
terminal_link_calculator);
}
std::vector<std::string> words_;
std::vector<size_t> ids_;
};
const int max_n = 100011, inf = 1000111222;
int n, k[max_n], ans[max_n];
string s, t[max_n];
vector<int> all[max_n];
AutomatonBuilder q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s >> n;
for (int i = 0; i < n; ++i) {
cin >> k[i] >> t[i];
q.Add(t[i], i);
}
const auto &automaton = q.Build();
NodeReference state = automaton->Root();
for (int i = 0; i < s.length(); ++i) {
state = state.Next(s[i]);
auto lambda = [i](int id) { all[id].push_back(i); };
state.GenerateMatches(lambda);
}
for (int i = 0; i < n; ++i) {
int len = inf;
for (int j = 0; j + k[i] <= all[i].size(); ++j) {
len = min(len, all[i][j + k[i] - 1] - all[i][j]);
}
if (len == inf) {
cout << "-1\n";
} else {
cout << len + t[i].length() << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9 + 7;
unsigned long long pre[maxn], h[maxn];
int k[maxn], len[maxn];
vector<pair<unsigned long long, int> > save[maxn];
vector<int> entry[maxn];
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int lens = s.size();
pre[0] = 1;
for (int i = 1; i < maxn; i++) pre[i] = pre[i - 1] * 163;
h[0] = s[0] - 'a' + 1;
for (int i = 1; i < lens; i++) h[i] = h[i - 1] * 163 + (s[i] - 'a' + 1);
int Q;
cin >> Q;
for (int i = 0; i < Q; i++) {
string m;
cin >> k[i] >> m;
len[i] = m.size();
unsigned long long temp = m[0] - 'a' + 1;
for (int j = 1; j < len[i]; j++) temp = temp * 163 + (m[j] - 'a' + 1);
save[len[i]].push_back(make_pair(temp, i));
}
for (int i = 1; i <= lens; i++) {
if (save[i].empty()) continue;
sort(save[i].begin(), save[i].end());
for (int j = 0; j + i - 1 < lens; j++) {
unsigned long long temp;
if (!j)
temp = h[i - 1];
else
temp = h[j + i - 1] - h[j - 1] * pre[i];
int pos =
lower_bound(save[i].begin(), save[i].end(), make_pair(temp, 0)) -
save[i].begin();
if (pos != save[i].size() && save[i][pos].first == temp)
entry[save[i][pos].second].push_back(j);
}
}
for (int i = 0; i < Q; i++) {
if (entry[i].size() < k[i]) {
cout << -1 << endl;
continue;
}
int ans = INF;
for (int j = 0; j + k[i] - 1 < entry[i].size(); j++)
ans = min(ans, entry[i][j + k[i] - 1] - entry[i][j] + len[i]);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v;
Node* ch[26];
Node *fail, *lst;
};
const int N = 100010;
int len, n;
int k[N], l[N], ans[N];
deque<int> tail[N];
char s[N], str[N];
Node* ac;
Node* create();
void build();
int main() {
scanf("%s%d", str + 1, &n);
len = strlen(str + 1);
ac = create();
for (int i = 1; i <= n; ++i) {
scanf("%d%s", &k[i], s + 1);
l[i] = strlen(s + 1);
Node* p = ac;
for (char* c = s + 1; *c; ++c) {
if (!p->ch[*c - 'a']) p->ch[*c - 'a'] = create();
p = p->ch[*c - 'a'];
}
p->v = i;
}
build();
memset(ans, -1, sizeof(ans));
Node* p = ac;
for (char* c = str + 1; *c; ++c) {
p = p->ch[*c - 'a'];
Node* q = p->v ? p : p->lst;
while (q) {
int id = q->v;
tail[id].push_back(c - str);
if (tail[id].size() > k[id]) tail[id].pop_front();
if (tail[id].size() == k[id]) {
if (ans[id] == -1 ||
ans[id] > (tail[id].back() - tail[id].front() + l[id]))
ans[id] = tail[id].back() - tail[id].front() + l[id];
}
q = q->lst;
}
}
for (int i = 1; i <= n; ++i) printf("%d\n", ans[i]);
return 0;
}
Node* create() {
static Node pool[N];
static Node* p = pool;
return p++;
}
void build() {
queue<Node*> q;
q.push(ac);
ac->fail = ac;
while (!q.empty()) {
Node* p = q.front();
q.pop();
if (p->fail->v)
p->lst = p->fail;
else
p->lst = p->fail->lst;
for (int i = 0; i < 26; ++i)
if (!p->ch[i]) {
if (p == ac)
p->ch[i] = p;
else
p->ch[i] = p->fail->ch[i];
} else {
if (p == ac)
p->ch[i]->fail = ac;
else
p->ch[i]->fail = p->fail->ch[i];
q.push(p->ch[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)2e5 + 5, base = 727, sq = 340,
mod = (int)(1 << 23) * 17 * 7 + 1;
int nxt[N][26], ind[N], sz = 1, h[N], pw[N], qk[N], hashed[N];
vector<int> appear[N];
string t[N];
string s;
int main() {
memset(ind, -1, sizeof ind);
cin >> s;
int n = (int)s.size();
pw[0] = 1;
for (int i = 0; i < n; ++i)
h[i + 1] = (h[i] * (long long)base + s[i]) % mod,
pw[i + 1] = (long long)pw[i] * base % mod;
int m;
cin >> m;
vector<int> all;
for (int j = 0; j < m; ++j) {
cin >> qk[j] >> t[j];
if ((int)t[j].size() >= sq) {
int id = (int)all.size();
for (auto c : t[j]) hashed[id] = ((long long)hashed[id] * base + c) % mod;
all.push_back(j);
} else {
int v = 0;
for (auto c : t[j]) {
if (!nxt[v][c - 'a']) {
nxt[v][c - 'a'] = sz++;
}
v = nxt[v][c - 'a'];
}
ind[v] = j;
}
}
for (int pos = 0; pos < n; ++pos) {
int v = 0;
for (int r = pos + 1; r <= min(n, sq + pos + 1); ++r) {
if (!nxt[v][s[r - 1] - 'a']) {
break;
}
v = nxt[v][s[r - 1] - 'a'];
if (ind[v] >= 0) {
appear[ind[v]].push_back(pos);
}
}
int id = 0;
for (int first : all) {
int r = pos + (int)t[first].size();
int hs = (h[r] - (long long)h[pos] * pw[r - pos] % mod + mod) % mod;
if (hs == hashed[id]) {
appear[first].push_back(pos);
}
++id;
}
}
for (int j = 0; j < m; ++j) {
if (appear[j].size() < qk[j]) {
cout << -1 << '\n';
} else {
int res = n;
for (int i = 0; i + qk[j] - 1 < (int)appear[j].size(); ++i) {
res = min(res,
(appear[j][i + qk[j] - 1] - appear[j][i] + (int)t[j].size()));
}
cout << res << '\n';
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.