text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[2111], t[2111], rs[2111];
int lcps[2111][2111], lcprs[2111][2111];
int frs[2111], frrs[2111];
int dp[2111], last[2111];
pair<int, int> g[2111];
int cnt[222];
void dfs(int k) {
if (k <= 0) return;
dfs(last[k]);
int l, r;
l = g[k].first;
r = g[k].second;
if (l < r)
if (r - l + 1 > k - last[k]) {
r = l + (k - last[k] - 1);
} else if (l - r + 1 > k - last[k]) {
r = l - (k - last[k] - 1);
}
printf("%d %d\n", l, r);
}
int main() {
gets(s + 1);
gets(t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
for (int i = 1; i <= n; i++) {
cnt[s[i]]++;
}
for (int i = 1; i <= m; i++) {
if (cnt[t[i]] == 0) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; i++) {
rs[i] = s[n - i + 1];
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (s[i] == t[j]) {
lcps[i][j] = lcps[i + 1][j + 1] + 1;
if (lcps[0][j] < lcps[i][j]) {
lcps[0][j] = lcps[i][j];
frs[j] = i;
}
}
if (rs[i] == t[j]) {
lcprs[i][j] = lcprs[i + 1][j + 1] + 1;
if (lcprs[0][j] < lcprs[i][j]) {
lcprs[0][j] = lcprs[i][j];
frrs[j] = i;
}
}
}
}
int l, r;
for (int i = 1; i <= m; i++) {
r = lcps[0][i];
if (l != 0)
for (l = 1; l <= r; l++)
if (dp[i + l - 1] == 0 || dp[i + l - 1] > dp[i - 1] + 1) {
dp[i + l - 1] = dp[i - 1] + 1;
last[i + l - 1] = i - 1;
g[i + l - 1] = make_pair(frs[i], frs[i] + l - 1);
}
r = lcprs[0][i];
if (l != 0)
for (l = 1; l <= r; l++)
if (dp[i + l - 1] == 0 || dp[i + l - 1] > dp[i - 1] + 1) {
dp[i + l - 1] = dp[i - 1] + 1;
last[i + l - 1] = i - 1;
g[i + l - 1] = make_pair(n + 1 - frrs[i], n + 1 - (frrs[i] + l - 1));
}
}
if (dp[m] == 0) {
puts("-1");
return 0;
}
cout << dp[m] << endl;
dfs(m);
}
|
#include <bits/stdc++.h>
using namespace std;
char S[2200], T[2200];
int SL, TL;
int dp[2200];
int tr[2200];
struct TrieNode {
TrieNode* children[26];
int a, b;
TrieNode(int a, int b) : a(a), b(b) { memset(children, 0, sizeof(children)); }
~TrieNode() {
for (int i = 0; i < 26; i++) {
if (children[i]) delete children[i];
}
}
TrieNode* insert(const char c, int na, int nb) {
int k = c - 'a';
if (children[k] == NULL) children[k] = new TrieNode(na, nb);
return children[k];
}
TrieNode* next(const char c) {
int k = c - 'a';
return children[k];
}
};
TrieNode* ans[2200];
int main() {
scanf("%s%s", S + 1, T + 1);
SL = strlen(S + 1);
TL = strlen(T + 1);
TrieNode* trie = new TrieNode(0, 0);
for (int i = 1; i <= SL; i++) {
TrieNode* node = trie;
for (int j = i; j <= SL; j++) {
node = node->insert(S[j], i, j);
}
TrieNode* node2 = trie;
for (int j = i; j > 0; j--) {
node2 = node2->insert(S[j], i, j);
}
}
for (int i = TL; i > 0; i--) {
dp[i] = 123456789;
TrieNode* node = trie;
for (int j = i; j <= TL; j++) {
if (node) {
node = node->next(T[j]);
int v = dp[j + 1] + (node ? 1 : 123456789);
if (v < dp[i]) {
dp[i] = v;
ans[i] = node;
tr[i] = j + 1;
}
}
}
}
if (dp[1] >= 123456789) {
printf("-1\n");
} else {
printf("%d\n", dp[1]);
int i = 1;
for (int j = 0; j < dp[1]; j++) {
printf("%d %d\n", ans[i]->a, ans[i]->b);
i = tr[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
string s, t;
while (cin >> s >> t) {
int hn = s.size();
s = s + "$" + string(s.rbegin(), s.rend());
int n = s.size(), m = t.size();
vector<vector<short> > lcp(n + 1, vector<short>(m + 1));
for (int i = n - 1; i >= 0; --i)
for (int j = m - 1; j >= 0; --j)
lcp[i][j] = s[i] == t[j] ? lcp[i + 1][j + 1] + 1 : 0;
vector<pair<int, int> > ans;
int pos = 0;
while (pos < m) {
pair<int, int> a(0, 0x3f3f3f3f);
for (int(i) = 0; (i) < (int)(n); ++(i))
amax(a, make_pair(((int)lcp[i][pos]), (i)));
if (a.first == 0) {
ans.clear();
break;
}
int i = a.second;
if (i < hn)
ans.emplace_back(i + 1, i + a.first);
else {
int k = hn - (i - (hn + 1) + a.first);
ans.emplace_back(k + a.first, k + 1);
}
pos += a.first;
}
if (ans.empty()) {
puts("-1");
} else {
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string reverse(string s) {
string t = s;
int slen = s.length();
for (int i = 0; i < slen; i++) {
t[slen - 1 - i] = s[i];
}
return t;
}
struct st {
int first, second, x, y;
};
int main() {
ios_base::sync_with_stdio(false);
string s, t, srev;
cin >> s >> t;
int slen = s.length(), tlen = t.length();
srev = reverse(s);
int lcp[tlen][slen], lcpr[tlen][slen];
for (int i = tlen - 1; i >= 0; --i) {
if (s[slen - 1] == t[i]) {
lcp[i][slen - 1] = 1;
} else {
lcp[i][slen - 1] = 0;
}
for (int j = slen - 2; j >= 0; --j) {
if (s[j] == t[i]) {
if (i + 1 < tlen) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
} else {
lcp[i][j] = 1;
}
} else {
lcp[i][j] = 0;
}
}
}
for (int i = tlen - 1; i >= 0; --i) {
if (srev[slen - 1] == t[i]) {
lcpr[i][slen - 1] = 1;
} else {
lcpr[i][slen - 1] = 0;
}
for (int j = slen - 2; j >= 0; --j) {
if (srev[j] == t[i]) {
if (i + 1 < tlen) {
lcpr[i][j] = lcpr[i + 1][j + 1] + 1;
} else {
lcpr[i][j] = 1;
}
} else {
lcpr[i][j] = 0;
}
}
}
st ans[tlen];
for (int i = 0; i < tlen; i++) {
ans[i].first = 0;
ans[i].second = 0;
ans[i].x = 0;
ans[i].y = 0;
for (int j = 0; j < slen; j++) {
if (lcp[i][j] >= lcp[i][ans[i].first]) {
ans[i].first = j;
ans[i].x = j + 1;
ans[i].y = j + lcp[i][j];
}
}
for (int j = 0; j < slen; j++) {
if (lcpr[i][j] >= lcp[i][ans[i].first] && ans[i].second == 0) {
ans[i].first = j;
ans[i].second = 1;
ans[i].x = slen - j;
ans[i].y = slen - j - lcpr[i][j] + 1;
} else {
if (lcpr[i][j] >= lcpr[i][ans[i].first] && ans[i].second == 1) {
ans[i].first = j;
ans[i].x = slen - j;
ans[i].y = slen - j - lcpr[i][j] + 1;
}
}
}
}
int total = 0;
vector<pair<int, int> > v;
for (int i = 0; i < tlen; i++) {
if (lcp[i][ans[i].first] > 0 && ans[i].second == 0) {
++total;
v.push_back(make_pair(ans[i].x, ans[i].y));
i += (lcp[i][ans[i].first] - 1);
} else {
if (lcpr[i][ans[i].first] > 0 && ans[i].second == 1) {
++total;
v.push_back(make_pair(ans[i].x, ans[i].y));
i += (lcpr[i][ans[i].first] - 1);
} else {
total = -1;
break;
}
}
}
cout << total << endl;
if (total > 0) {
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > res;
int z[5000][2];
void zf(string s, int id) {
int n = (int)s.length();
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i][id] = min(r - i + 1, z[i - l][id]);
while (i + z[i][id] < n && s[z[i][id]] == s[i + z[i][id]]) ++z[i][id];
if (i + z[i][id] - 1 > r) l = i, r = i + z[i][id] - 1;
}
}
int main() {
string s;
string t;
cin >> s >> t;
string revs = s;
reverse(revs.begin(), revs.end());
int pos = 0;
while (true) {
memset(z, 0, sizeof(z));
string s1, s2;
if (pos >= t.size()) break;
for (int i = pos; i < t.size(); i++) {
s1.push_back(t[i]);
}
s2 = s1 + '#' + revs;
s1 = s1 + '#' + s;
zf(s1, 0);
zf(s2, 1);
int a, b, mx = 0;
int len = s1.size();
for (int i = 0; i < s.size(); i++) {
if (z[len - 1 - i][0] > mx) {
mx = z[len - 1 - i][0];
a = s.size() - i;
b = a + mx - 1;
}
if (z[len - 1 - i][1] > mx) {
mx = z[len - 1 - i][1];
a = i + 1;
b = a - mx + 1;
}
}
if (mx == 0) {
printf("-1");
return 0;
}
res.push_back(pair<int, int>(a, b));
pos += mx;
}
printf("%d\n", (int)res.size());
for (int i = 0; i < res.size(); i++) {
printf("%d %d\n", res[i].first, res[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500020;
const long long MOD = (int)1e9 + 7;
const int INF = 1e9;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
vector<int> z_algo(const string &s) {
int n = s.size();
int L = 0, R = 0;
vector<int> z(n, 0);
for (int i = 1; i < n; i++) {
if (i <= R) z[i] = min(z[i - L], R - i + 1);
while (z[i] + i < n and s[z[i] + i] == s[z[i]]) z[i]++;
if (i + z[i] - 1 > R) {
L = i;
R = i + z[i] - 1;
}
}
return z;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string s, sinv, t;
int n;
cin >> s >> t;
n = t.size();
vector<pair<int, int> > res;
sinv = s;
reverse(sinv.begin(), sinv.end());
int idx = 0;
while (idx < n) {
string eita = t.substr(idx, n - idx);
string zstr = eita + "$" + s;
string zstrinv = eita + "$" + sinv;
vector<int> z = z_algo(zstr);
vector<int> zinv = z_algo(zstrinv);
int maior = 0, l = -1, r = -1;
for (int i = eita.size() + 1, j = 0; i < (int)z.size(); i++, j++) {
if (z[i] > maior) {
maior = z[i];
l = j;
r = j + z[i] - 1;
}
}
for (int i = eita.size() + 1, j = s.size() - 1; i < (int)zinv.size();
i++, j--) {
if (zinv[i] > maior) {
maior = zinv[i];
l = j;
r = j - (zinv[i] - 1);
}
}
if (maior == 0) {
cout << -1 << '\n';
return 0;
}
idx += maior;
res.push_back(make_pair(l, r));
}
cout << res.size() << '\n';
for (auto p : res) cout << p.first + 1 << " " << p.second + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void BuildKMP(const char *str, int *fail) {
fail[0] = fail[1] = 0;
for (int i = 1; str[i]; i++) {
int &f = fail[i + 1] = fail[i];
while (f && str[f] != str[i]) f = fail[f];
if (str[f] == str[i]) ++f;
}
}
int FAIL[2101];
pair<int, int> Match(const char *a, const char *b) {
BuildKMP(b, FAIL);
int u = 0;
pair<int, int> ans = make_pair(-1, -1);
int i = 0;
for (; a[i]; i++) {
while (u && b[u] != a[i]) u = FAIL[u];
if (b[u] == a[i]) ++u;
if (u >= abs(ans.second - ans.first) + 1) ans = make_pair(i - u + 1, i);
}
--i, u = 0;
for (; i >= 0; i--) {
while (u && b[u] != a[i]) u = FAIL[u];
if (b[u] == a[i]) ++u;
if (u >= abs(ans.second - ans.first) + 1) ans = make_pair(i + u - 1, i);
}
return ans;
}
int N, M;
char A[2101], B[2101];
vector<pair<int, int> > Solve() {
vector<pair<int, int> > ans;
for (int cur = 0; B[cur];) {
const auto &p = Match(A, B + cur);
if (p.first == -1) {
ans.clear();
return ans;
}
ans.push_back(p);
cur += abs(p.first - p.second) + 1;
}
return ans;
}
int main() {
while (scanf("%s%s", A, B) == 2) {
const vector<pair<int, int> > &ans = Solve();
if (ans.empty())
puts("-1");
else {
printf("%d\n", (int)ans.size());
for (const auto &p : ans) printf("%d %d\n", p.first + 1, p.second + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2220;
const int inf = 1e9 + 7;
int n, m, dp[N], thead[N], ttail[N], trace[N];
string s, t;
vector<pair<int, int> > ans;
struct Node {
Node* child[26];
int head, tail;
} * root;
Node* node(int head, int tail) {
Node* p;
p = new Node();
for (int i = 0; i < 26; ++i) p->child[i] = NULL;
p->head = head;
p->tail = tail;
return p;
}
int main() {
cin >> s >> t;
n = s.size();
m = t.size();
root = node(0, 0);
for (int i = 0; i < n; ++i) {
Node* p = root;
for (int j = i; j >= 0; --j) {
if (p->child[s[j] - 'a'] == NULL)
p->child[s[j] - 'a'] = node(j + 1, i + 1);
p = p->child[s[j] - 'a'];
}
}
reverse(s.begin(), s.end());
for (int i = 0; i < n; ++i) {
Node* p = root;
for (int j = i; j >= 0; --j) {
if (p->child[s[j] - 'a'] == NULL)
p->child[s[j] - 'a'] = node(n - j, n - i);
p = p->child[s[j] - 'a'];
}
}
for (int i = 1; i <= m; ++i) dp[i] = inf;
for (int i = 0; i < m; ++i) {
Node* p = root;
for (int j = i; j >= 0; --j)
if (p->child[t[j] - 'a'] != NULL) {
dp[i + 1] = min(dp[i + 1], dp[j] + 1);
p = p->child[t[j] - 'a'];
if (dp[i + 1] == dp[j] + 1) {
thead[i + 1] = p->head;
ttail[i + 1] = p->tail;
trace[i + 1] = j;
}
} else
break;
}
if (dp[m] == inf) dp[m] = -1;
cout << dp[m] << endl;
if (dp[m] == -1) return 0;
int v = m;
while (v != 0) {
ans.push_back(make_pair(thead[v], ttail[v]));
v = trace[v];
}
for (int i = ans.size() - 1; i >= 0; --i)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, ar, b, fi;
int i, j, ans, o1[3000], o2[3000];
int main() {
ios_base::sync_with_stdio(0);
cin >> a >> b;
ar = a;
reverse(ar.begin(), ar.end());
for (; i < b.size(); ++i) {
if (a.find(b[i]) == string::npos) {
cout << "-1\n";
return 0;
}
}
for (i = 0; i < b.size();) {
for (j = 1; i + j <= b.length(); ++j) {
fi = b.substr(i, j);
if (a.find(fi) == string::npos && ar.find(fi) == string::npos) {
if (a.find(b.substr(i, j - 1)) == string::npos) {
o1[ans] = a.length() - ar.find(b.substr(i, j - 1));
o2[ans] = a.length() - ar.find(b.substr(i, j - 1)) - j + 2;
} else {
o1[ans] = a.find(b.substr(i, j - 1)) + 1;
o2[ans] = a.find(b.substr(i, j - 1)) + j - 1;
}
i += j - 1;
++ans;
break;
} else if (i + j == b.length()) {
if (a.find(b.substr(i, j)) == string::npos) {
o1[ans] = a.length() - ar.find(b.substr(i, j));
o2[ans] = a.length() - ar.find(b.substr(i, j)) - j + 1;
} else {
o1[ans] = a.find(b.substr(i, j)) + 1;
o2[ans] = a.find(b.substr(i, j)) + j;
}
i += j;
++ans;
}
}
}
cout << ans << '\n';
for (i = 0; i < ans; ++i) cout << o1[i] << ' ' << o2[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string base, s;
cin >> base >> s;
int n = base.size(), m = s.size();
base = '*' + base;
s = '*' + s;
int f[m + 2][n + 2];
memset(f, 0, sizeof(f));
for (int i = m; i >= 1; i--)
for (int j = n; j >= 1; j--)
if (s[i] == base[j]) f[i][j] = f[i + 1][j + 1] + 1;
int g[m + 2][n + 2];
memset(g, 0, sizeof(g));
for (int i = m; i >= 1; i--)
for (int j = 1; j <= n; j++)
if (s[i] == base[j]) g[i][j] = g[i + 1][j - 1] + 1;
vector<pair<int, int>> ans;
for (int i = 1; i <= m;) {
int l1 = max_element(f[i] + 1, f[i] + n + 1) - f[i];
int l2 = max_element(g[i] + 1, g[i] + n + 1) - g[i];
if (!f[i][l1] && !g[i][l2]) {
cout << -1;
return 0;
}
if (f[i][l1] >= g[i][l2])
ans.push_back({l1, l1 + f[i][l1] - 1});
else
ans.push_back({l2, l2 - g[i][l2] + 1});
i += max(f[i][l1], g[i][l2]);
}
cout << ans.size() << "\n";
for (auto p : ans) cout << p.first << " " << p.second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, rs, t;
cin >> s >> t;
rs = s;
reverse(rs.begin(), rs.end());
s = rs + '#' + s;
int m = s.size(), n = t.size();
vector<vector<int> > lcp(n + 1, vector<int>(m + 1));
vector<int> ml(n);
for (int i = n - 1; i >= 0; --i)
for (int j = m - 1, mx = 0; j >= 0; --j) {
if (t[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
if ((lcp[i][j] >= mx && j > m / 2) || lcp[i][j] > mx)
mx = lcp[i][j], ml[i] = j;
}
vector<pair<int, int> > res;
int k = 0, d = m / 2;
while (k < n) {
if (lcp[k][ml[k]] == 0) {
cout << -1;
return 0;
}
if (ml[k] > d)
res.push_back(make_pair(ml[k] - d, ml[k] - d - 1 + lcp[k][ml[k]]));
else
res.push_back(make_pair(d - ml[k], d + 1 - (ml[k] + lcp[k][ml[k]])));
k += lcp[k][ml[k]];
}
cout << res.size() << endl;
for (auto c : res) cout << c.first << " " << c.second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 10;
char t[maxn], s[maxn], s1[maxn];
int f[maxn], x, y, u, x1, y2;
bool vis[30];
vector<int> ansx, ansy;
void getf() {
int m = strlen(t);
f[u] = f[u + 1] = u;
for (int i = u + 1; i < m; i++) {
int j = f[i];
while (j > u && t[i] != t[j]) j = f[j];
f[i + 1] = (t[i] == t[j] ? j + 1 : u);
}
}
int find() {
int M = 0;
int n = strlen(s), m = strlen(t);
int j = u;
for (int i = 0; i < n; i++) {
while (j > u && t[j] != s[i]) j = f[j];
if (s[i] == t[j]) j++;
if (M < j - u) {
M = j - u;
y = i;
x = i - j + 1 + u;
}
if (j == m) return M;
}
return M;
}
int find1() {
int M = 0;
int n = strlen(s1), m = strlen(t);
int j = u;
for (int i = 0; i < n; i++) {
while (j > u && t[j] != s1[i]) j = f[j];
if (s1[i] == t[j]) j++;
if (M < j - u) {
M = j - u;
y2 = i;
x1 = i - j + 1 + u;
}
if (j == m) return M;
}
return M;
}
bool ok() {
int n = strlen(s);
for (int i = 0; i < n; i++) vis[s[i] - 'a'] = 1;
int m = strlen(t);
for (int i = 0; i < m; i++)
if (!vis[t[i] - 'a']) return 0;
return 1;
}
int main() {
while (scanf("%s", s) != EOF) {
ansx.clear();
ansy.clear();
scanf("%s", t);
if (!ok()) {
printf("-1\n");
continue;
}
int n = strlen(t);
int len = strlen(s);
for (int i = 0; i < len; i++) s1[i] = s[len - 1 - i];
s1[len] = NULL;
int ans = 0;
u = 0;
while (u < n) {
getf();
x = 0;
y = 0;
x1 = 0;
y2 = 0;
int tp1 = find();
int tp2 = find1();
if (tp1 >= tp2) {
ansx.push_back(x + 1);
ansy.push_back(y + 1);
u += tp1;
} else {
ansx.push_back(len - x1);
ansy.push_back(len - y2);
u += tp2;
}
ans++;
}
printf("%d\n", ans);
for (int i = 0; i < ans; i++) printf("%d %d\n", ansx[i], ansy[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, sr, s2;
pair<int, int> good(int from, int to) {
string sh = s2.substr(from, to - from + 1);
int found = s1.find(sh), foundr = sr.find(sh);
if (found != -1) {
return make_pair(found, 0);
}
return make_pair(foundr, 1);
}
vector<pair<int, int> > out;
void output() {
for (int i = 0; i < out.size(); i++)
cout << out[i].first << " " << out[i].second << endl;
}
int main() {
cin >> s1 >> s2;
sr = s1;
reverse(sr.begin(), sr.end());
int total = 0, n = s2.length();
int low = 0, high = n, mid = (n - 1) / 2, it = 0;
while (total < n) {
int initial = low;
while (low < high) {
mid = (low + high) / 2;
if (good(total, mid).first != -1)
low = mid + 1;
else
high = mid;
}
if (low == initial) {
cout << -1 << endl;
return 0;
} else {
pair<int, int> p1 = good(initial, low - 1);
if (p1.second == 1) {
out.push_back(make_pair(s1.length() - p1.first,
s1.length() - p1.first - low + initial + 1));
} else if (p1.second == 0) {
out.push_back(make_pair(p1.first + 1, p1.first + low - initial));
}
}
total += (low - initial);
low = total;
high = n;
}
cout << out.size() << endl;
output();
return 0;
}
|
#include <bits/stdc++.h>
typedef long double ld;
const long long INF = LLONG_MAX;
const long long NINF = LLONG_MIN;
const long long MAX = 1e6 + 5;
const long long MOD = 1e9 + 7;
using namespace std;
inline long long gcd(long long a, long long b) {
long long t;
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
while (b != 0) {
t = a;
a = b;
b = t % b;
}
return a;
}
inline long long mpow(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b & 1) {
ans = ans * a;
}
a = a * a;
b >>= 1;
}
return ans;
}
void computeLPSArray(string, long long M, long long *lps);
long long KMP(string pat, string txt) {
long long M = pat.size();
long long N = txt.size();
long long *lps = (long long *)malloc(sizeof(long long) * M);
long long j = 0;
computeLPSArray(pat, M, lps);
long long i = 0;
while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
return i - j;
j = lps[j - 1];
} else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
free(lps);
return -1;
}
void computeLPSArray(string pat, long long M, long long *lps) {
long long len = 0;
long long i;
lps[0] = 0;
i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
int main() {
long long c, i, j, k, y, x;
string s, sx, ss, sxx, s1, s2;
vector<long long> v;
c = 0;
s = "";
sx = "";
cin >> s1 >> s2;
s2 += "*";
j = 0;
for (i = 0; i < s2.size(); i++) {
s = s + s2[i];
sx = s2[i] + sx;
if (KMP(s, s1) == -1 && KMP(sx, s1) == -1 && s.size() == 1) {
cout << "-1\n";
return 0;
} else if (KMP(s, s1) == -1 && KMP(sx, s1) == -1) {
ss = "";
for (k = 0; k < s.size() - 1; k++) {
ss += s[k];
}
sxx = "";
for (k = 1; k < sx.size(); k++) {
sxx += sx[k];
}
x = KMP(ss, s1);
y = KMP(sxx, s1);
if (x != -1) {
c++;
v.push_back(x);
v.push_back(x + ss.size() - 1);
} else if (y != -1) {
c++;
v.push_back(y + sxx.size() - 1);
v.push_back(y);
} else {
cout << "-1\n";
return 0;
}
s = s2[i];
sx = s2[i];
}
}
printf("%lld\n", c);
for (i = 0; i < c; i++) {
printf("%lld ", v[2 * i] + 1);
printf("%lld\n", v[2 * i + 1] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct trie {
struct trie *ch[26];
int l, r;
};
struct trie *get(void) {
struct trie *ret = new trie;
ret->l = -1;
ret->r = -1;
for (int i = 0; i < 26; i++) {
ret->ch[i] = NULL;
}
return ret;
}
string s, ss;
int n;
void add1(struct trie *root, int st) {
struct trie *tmp = root;
for (int i = st; i < (int)s.size(); i++) {
int ind = s[i] - 'a';
if (!tmp->ch[ind]) {
tmp->ch[ind] = get();
}
tmp->ch[ind]->l = st + 1;
tmp->ch[ind]->r = i + 1;
tmp = tmp->ch[ind];
}
}
void add2(struct trie *root, int st) {
struct trie *tmp = root;
for (int i = st; i < (int)ss.size(); i++) {
int ind = ss[i] - 'a';
if (!tmp->ch[ind]) {
tmp->ch[ind] = get();
}
tmp->ch[ind]->l = n - st;
tmp->ch[ind]->r = n - i;
tmp = tmp->ch[ind];
}
}
vector<pair<long long, long long> > ans;
int main() {
struct trie *root = get();
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
add1(root, i);
}
ss = s;
reverse(ss.begin(), ss.end());
for (int i = 0; i < n; i++) {
add2(root, i);
}
struct trie *tmp = root;
string t;
cin >> t;
t += '#';
for (int i = 0; i < (int)t.size(); i++) {
int ind = t[i] - 'a';
if (t[i] == '#') {
ans.push_back({tmp->l, tmp->r});
break;
}
if (!root->ch[ind]) {
cout << -1 << endl;
return 0;
}
if (!tmp->ch[ind]) {
i--;
ans.push_back({tmp->l, tmp->r});
tmp = root;
continue;
}
tmp = tmp->ch[ind];
}
cout << (int)ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
namespace SuffixArray {
template <class T>
void induce(int n, const T s[], bool ls[], int sa[], int l_basm[], int B) {
int buf[B + 10];
copy_n(l_basm, B + 1, buf);
for (int i = 0; i <= n; i++) {
if (sa[i] >= 1 && !ls[sa[i] - 1]) {
int bc = s[sa[i] - 1];
sa[buf[bc]++] = sa[i] - 1;
}
}
copy_n(l_basm, B + 1, buf);
for (int i = n; i > 0; i--) {
if (sa[i] >= 1 && ls[sa[i] - 1]) {
int bc = s[sa[i] - 1];
sa[--buf[bc + 1]] = sa[i] - 1;
}
}
}
template <class T>
void SA(int n, const T s[], int sa[], int B = 200) {
bool ls[n + 1];
int l_ba[B + 1], s_ba[B + 1];
fill_n(l_ba, B + 1, 0);
fill_n(s_ba, B + 1, 0);
ls[n] = true;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1 || s[i] > s[i + 1]) {
ls[i] = false;
} else if (s[i] < s[i + 1]) {
ls[i] = true;
} else {
ls[i] = ls[i + 1];
}
if (!ls[i]) {
l_ba[(int)s[i]]++;
} else {
s_ba[(int)s[i]]++;
}
}
vector<int> v;
int lms[n + 1];
fill_n(lms, n + 1, -1);
int c = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms[i] = c++;
v.push_back(i);
}
}
int l_basm[B + 1], s_basm[B + 1];
l_basm[0] = 1;
s_basm[0] = 1 + l_ba[0];
for (int i = 1; i <= B; i++) {
l_basm[i] = s_basm[i - 1] + s_ba[i - 1];
s_basm[i] = l_basm[i] + l_ba[i];
}
if (v.size()) {
vector<int> v2 = v;
int buf[B + 1];
copy_n(s_basm, B + 1, buf);
fill_n(sa, n + 1, -1);
sa[0] = n;
for (int i = 0; i < (int)v.size(); i++) {
int c = s[v[i]];
sa[buf[c]++] = v[i];
}
induce(n, s, ls, sa, l_basm, B);
int c = 0;
for (int i = 1; i <= n; i++) {
if (lms[sa[i]] == -1) continue;
v[c++] = sa[i];
}
int s2[v.size()];
int sa2[v.size() + 1];
c = 0;
s2[lms[v[0]]] = 0;
for (int i = 1; i < (int)v.size(); i++) {
int l = v[i - 1], r = v[i];
while (true) {
if (s[l] != s[r]) {
c++;
break;
}
l++;
r++;
if (lms[l] != -1 || lms[r] != -1) {
if (lms[l] == -1 || lms[r] == -1) {
c++;
}
break;
}
}
s2[lms[v[i]]] = c;
}
SA(v.size(), s2, sa2, c);
for (int i = 1; i <= (int)v.size(); i++) {
v[i - 1] = v2[sa2[i]];
}
}
int buf[B + 1];
copy_n(s_basm, B + 1, buf);
fill_n(sa, n + 1, -1);
sa[0] = n;
for (int i = 0; i < (int)v.size(); i++) {
int c = s[v[i]];
sa[buf[c]++] = v[i];
}
induce(n, s, ls, sa, l_basm, B);
}
template <class T>
void LCP(int n, const T s[], const int sa[], int lcp[]) {
int rsa[n + 1];
for (int i = 0; i <= n; i++) {
rsa[sa[i]] = i;
}
int h = 0;
for (int i = 0; i < n; i++) {
int j = sa[rsa[i] - 1];
if (h > 0) h--;
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h]) break;
}
lcp[rsa[i] - 1] = h;
}
}
} // namespace SuffixArray
const int MN = 2200;
int mt(string s, string t) {
int n = min((int)s.size(), (int)t.size());
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) return i;
}
return n;
}
int main() {
string s, sr;
cin >> s;
sr = s;
reverse(sr.begin(), sr.end());
int n = (int)s.size();
static int ssa[MN], srsa[MN];
SuffixArray::SA(n, s.c_str(), ssa);
SuffixArray::SA(n, sr.c_str(), srsa);
string t;
cin >> t;
int m = (int)t.size();
vector<P> res;
int p = 0;
while (p < m) {
int mi = 0;
P mp;
int nm;
P np;
int l = 0, r = n + 1;
while (r - l > 1) {
int md = (l + r) / 2;
if (s.substr(ssa[md]) < t.substr(p)) {
l = md;
} else {
r = md;
}
}
nm = mt(s.substr(ssa[l]), t.substr(p));
np = P(ssa[l] + 1, ssa[l] + nm);
if (mi < nm) {
mi = nm;
mp = np;
}
if (r < n + 1) {
nm = mt(s.substr(ssa[r]), t.substr(p));
np = P(ssa[r] + 1, ssa[r] + nm);
if (mi < nm) {
mi = nm;
mp = np;
}
}
l = 0, r = n + 1;
while (r - l > 1) {
int md = (l + r) / 2;
if (sr.substr(srsa[md]) < t.substr(p)) {
l = md;
} else {
r = md;
}
}
nm = mt(sr.substr(srsa[l]), t.substr(p));
np = P(srsa[l], srsa[l] + nm);
np = P(n - np.first, n + 1 - np.second);
if (mi < nm) {
mi = nm;
mp = np;
}
if (r < n + 1) {
nm = mt(sr.substr(srsa[r]), t.substr(p));
np = P(srsa[r], srsa[r] + nm);
np = P(n - np.first, n + 1 - np.second);
if (mi < nm) {
mi = nm;
mp = np;
}
}
if (mi == 0) {
cout << -1 << endl;
return 0;
}
p += mi;
res.push_back(mp);
}
cout << res.size() << endl;
for (P p : res) {
cout << p.first << " " << p.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, revs;
int m, n;
int lcp[2105][2105], revlcp[2105][2105];
void build_lcp() {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (t[i] == s[j]) lcp[i][j] = lcp[i - 1][j - 1] + 1;
}
for (int j = 1; j <= n; j++) {
if (t[i] == revs[j]) revlcp[i][j] = revlcp[i - 1][j - 1] + 1;
}
}
}
vector<pair<int, int> > ans;
int main() {
std::ios::sync_with_stdio(false);
cin >> s >> t;
revs = s;
reverse(revs.begin(), revs.end());
n = s.length();
m = t.length();
s = "*" + s;
t = "*" + t;
revs = "*" + revs;
build_lcp();
int i = m;
while (i > 0) {
int max1 = 0, pos1, max2 = 0, pos2;
for (int j = 1; j <= n; j++) {
if (max1 < lcp[i][j]) {
max1 = lcp[i][j];
pos1 = j;
}
}
for (int j = 1; j <= n; j++) {
if (max2 < revlcp[i][j]) {
max2 = revlcp[i][j];
pos2 = j;
}
}
if (max1 == 0 && max2 == 0) {
cout << "-1";
return 0;
}
if (max1 >= max2) {
ans.push_back(make_pair(pos1 - max1 + 1, pos1));
i = i - max1;
} else {
ans.push_back(make_pair(n - (pos2 - max2 + 1) + 1, n - pos2 + 1));
i = i - max2;
}
}
int sz = ans.size();
cout << sz << endl;
for (int j = sz - 1; j >= 0; j--)
cout << ans[j].first << " " << ans[j].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[2201], s2[2201];
bool mark1[200];
long long prefixhash[2201];
long long invbase[2201];
long long inv;
long long suffixhash[2201];
long long power(long long a, long long b, long long m = 1000000007) {
a %= m;
long long x = 1;
while (b) {
if ((1 & b)) x = x * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return x;
}
void hash2(int n) {
prefixhash[0] = 0;
invbase[0] = 1;
inv = power(29, 1000000007 - 2, 1000000007);
long long b = 29;
for (int i = 1; i <= n; i++) {
prefixhash[i] = prefixhash[i - 1];
long long x = s2[i - 1] * b;
b *= 29;
b %= 1000000007;
invbase[i] = (invbase[i - 1] * inv) % 1000000007;
prefixhash[i] = (prefixhash[i] + x) % 1000000007;
}
b = 29;
suffixhash[n + 1] = 0;
for (int i = n; i >= 1; i--) {
suffixhash[i] = suffixhash[i + 1];
long long x = s2[i - 1] * b;
b *= 29;
b %= 1000000007;
suffixhash[i] = (suffixhash[i] + x) % 1000000007;
}
}
long long rangef(long long i, long long j) {
long long ans = 1000000007 + prefixhash[j] - prefixhash[i - 1];
if (ans >= 1000000007) ans -= 1000000007;
return (ans * invbase[i - 1]) % 1000000007;
}
int tn;
long long rangeb(long long i, long long j) {
long long ans = 1000000007 + suffixhash[i] - suffixhash[j + 1];
if (ans >= 1000000007) ans -= 1000000007;
return (ans * invbase[tn - j]) % 1000000007;
}
long long prefixhash1[2201];
long long invbase1[2201];
long long inv1;
long long suffixhash1[2201];
void hash1(int n) {
prefixhash1[0] = 0;
invbase1[0] = 1;
inv1 = power(29, 1000000007 - 2, 1000000007);
long long b = 29;
for (int i = 1; i <= n; i++) {
prefixhash1[i] = prefixhash1[i - 1];
long long x = s1[i - 1] * b;
b *= 29;
b %= 1000000007;
invbase1[i] = (invbase1[i - 1] * inv1) % 1000000007;
prefixhash1[i] = (prefixhash1[i] + x) % 1000000007;
}
b = 29;
suffixhash1[n + 1] = 0;
for (int i = n; i >= 1; i--) {
suffixhash1[i] = suffixhash1[i + 1];
long long x = s1[i - 1] * b;
b *= 29;
b %= 1000000007;
suffixhash1[i] = (suffixhash1[i] + x) % 1000000007;
}
}
long long rangef1(long long i, long long j) {
long long ans = 1000000007 + prefixhash1[j] - prefixhash1[i - 1];
if (ans >= 1000000007) ans -= 1000000007;
return (ans * invbase1[i - 1]) % 1000000007;
}
int t1;
long long rangeb1(long long i, long long j) {
long long ans = 1000000007 + suffixhash1[i] - suffixhash1[j + 1];
if (ans >= 1000000007) ans -= 1000000007;
return (ans * invbase1[tn - j]) % 1000000007;
}
bool pos(long long got, long long x) {
for (int i = 0; i + x - 1 < t1; i++) {
if (rangef1(i + 1, i + x) == got) return true;
}
return false;
}
bool can(int s, int e) {
if (pos(rangef(s + 1, e + 1), e - s + 1)) return true;
if (pos(rangeb(s + 1, e + 1), e - s + 1)) return true;
return false;
}
vector<pair<int, int> > my;
bool pos1(long long got, long long x, bool flag) {
if (flag == 0) {
for (int i = 0; i + x - 1 < t1; i++) {
if (rangef1(i + 1, i + x) == got) {
my.push_back(make_pair(i + 1, i + x));
return true;
}
}
return false;
} else {
for (int i = 0; i + x - 1 < t1; i++) {
if (rangef1(i + 1, i + x) == got) {
my.push_back(make_pair(i + x, i + 1));
return true;
}
}
return false;
}
}
void mysearch(int s, int e) {
if (pos1(rangef(s + 1, e + 1), e - s + 1, 0)) return;
pos1(rangeb(s + 1, e + 1), e - s + 1, 1);
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
int l1 = strlen(s1), l2 = strlen(s2);
hash2(l2);
tn = l2;
t1 = l1;
hash1(l1);
for (int i = 0; i < 200; i++) mark1[i] = false;
for (int i = 0; i < l1; i++) {
mark1[s1[i]] = 1;
}
string fuck = "-1";
for (int i = 0; i < l2; i++) {
if (!mark1[s2[i]]) {
cout << fuck << endl;
return 0;
}
}
int found = 0, moves = 0, end;
for (int i = 1; i < l2; i++) {
if (can(found, i)) continue;
end = i - 1;
moves++;
mysearch(found, end);
found = i;
}
end = l2 - 1;
moves++;
mysearch(found, end);
printf("%d\n", moves);
for (int i = 0; i < my.size(); i++) {
cout << my[i].first << " " << my[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dfa[3010][26];
void build(string s) {
memset(dfa, 0, sizeof dfa);
int x = 0;
for (int i = 0; i < s.size(); i++) {
for (int c = 0; c < 26; c++) dfa[i][c] = dfa[x][c];
x = dfa[i][s[i] - 'a'];
dfa[i][s[i] - 'a'] = i + 1;
}
for (int c = 0; c < 26; c++) dfa[s.size()][c] = dfa[x][c];
}
pair<int, int> get(string s) {
pair<int, int> ret(0, 0);
int x = 0;
for (int i = 0; i < s.size(); i++) {
x = dfa[x][s[i] - 'a'];
if (x > ret.first) {
ret = {x, i - x + 1};
}
}
return ret;
}
int main() {
string a, b;
while (cin >> a >> b) {
string ra = a;
reverse(ra.begin(), ra.end());
int beg = 0;
vector<pair<int, int> > res;
while (beg < b.size()) {
build(b.substr(beg));
pair<int, int> t = get(a), tr = get(ra);
if (t.first == 0 && tr.first == 0) {
cout << -1 << endl;
res.clear();
break;
}
if (t.first >= tr.first)
res.push_back({t.second, t.second + t.first - 1}), beg += t.first;
else
res.push_back({(int)a.size() - tr.second - 1,
(int)a.size() - tr.second - tr.first}),
beg += tr.first;
}
if (res.size()) {
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i].first + 1 << ' ' << res[i].second + 1 << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void Read(T &x) {
int f = 1;
char t = getchar();
while (t < '0' || t > '9') {
if (t == '-') f = -1;
t = getchar();
}
x = 0;
while (t >= '0' && t <= '9') {
x = x * 10 + t - '0';
t = getchar();
}
x *= f;
}
const int maxn = 3005;
const int inf = 0x3f3f3f3f;
int n, m, len;
int pre[maxn], fail[maxn];
pair<int, int> from[maxn];
char pat[maxn], str1[maxn], str[maxn];
void input() {
scanf("%s", str1 + 1);
scanf("%s", str + 1);
n = strlen(str1 + 1);
m = strlen(str + 1);
memset(pre, inf, sizeof(pre));
}
void getfail() {
int i = 1, j = 0;
fail[1] = 0;
while (i <= len) {
if (j == 0 || pat[i] == pat[j]) {
fail[++i] = ++j;
} else {
j = fail[j];
}
}
}
void kmp(int rev, int st) {
for (register int i = 1, j = 1; i <= m; i++) {
while (j > 1 && str[i] != pat[j]) j = fail[j];
if (str[i] == pat[j]) j++;
if (j > 1) {
if (i - j + 2 < pre[i]) {
pre[i] = i - j + 2;
if (rev == 0)
from[i] = make_pair(st, st + j - 2);
else
from[i] = make_pair(n - st + 1, n - st - j + 3);
}
}
if (j > len) j = fail[j];
}
}
void solve() {
for (register int i = 1; i <= n; i++) {
len = 0;
for (register int j = i; j <= n; j++) pat[++len] = str1[j];
pat[len + 1] = 0;
getfail();
kmp(0, i);
}
reverse(str1 + 1, str1 + n + 1);
for (register int i = 1; i <= n; i++) {
len = 0;
for (register int j = i; j <= n; j++) pat[++len] = str1[j];
pat[len + 1] = 0;
getfail();
kmp(1, i);
}
int ans = 0, cnt = m;
static vector<pair<int, int> > output;
while (cnt >= 1) {
if (pre[cnt] == inf) {
printf("-1\n");
return;
}
ans++;
output.push_back(from[cnt]);
cnt = pre[cnt] - 1;
}
printf("%d\n", ans);
for (register int i = output.size() - 1; i >= 0; i--) {
printf("%d %d\n", output[i].first, output[i].second);
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w;
int self[2205], match[2205];
char S[2205], R[2205], A[2205];
int i, ans;
int a, b;
int C[2205], D[2205];
int main() {
scanf("%s", S);
scanf("%s", A);
m = strlen(A);
n = strlen(S);
for (int j = (0); j < (n); j++) R[j] = S[n - j - 1];
i = 0;
while (i < m) {
self[i] = i - 1;
for (int j = (i + 1); j < (m); j++) {
x = self[j - 1];
while (x != i - 1 && A[x + 1] != A[j]) x = self[x];
if (A[x + 1] != A[j])
self[j] = i - 1;
else
self[j] = x + 1;
}
if (S[0] == A[i])
match[0] = i;
else
match[0] = i - 1;
k = match[0];
a = 1;
b = 1;
for (int j = (1); j < (n); j++) {
x = match[j - 1];
while (S[j] != A[x + 1] && x != i - 1) x = self[x];
if (S[j] == A[x + 1])
match[j] = x + 1;
else
match[j] = i - 1;
if (match[j] > k) {
k = match[j];
b = j + 1;
a = b - (k - i);
}
}
if (R[0] == A[i])
match[0] = i;
else
match[0] = i - 1;
k = max(k, match[0]);
for (int j = (1); j < (n); j++) {
x = match[j - 1];
while (R[j] != A[x + 1] && x != i - 1) x = self[x];
if (R[j] == A[x + 1])
match[j] = x + 1;
else
match[j] = i - 1;
if (match[j] > k) {
k = match[j];
b = n - j;
a = b + (k - i);
}
}
if (k == i - 1) {
printf("-1\n");
return 0;
}
i = k + 1;
C[ans] = a;
D[ans++] = b;
}
printf("%d\n", ans);
for (int i = (0); i < (ans); i++) printf("%d %d\n", C[i], D[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[26], b[26], x, y, i, p, q, j, z, alp, tt, k;
vector<pair<int, int> > vec;
int main() {
string s, t, temp;
cin >> s >> t;
temp = s;
for (i = 0; i < s.length(); i++) a[s[i] - 97]++;
for (i = 0; i < t.length(); i++) b[t[i] - 97]++;
for (i = 0; i < 26; i++)
if (b[i] != 0 && a[i] == 0) {
cout << "-1";
return 0;
}
x = s.length();
y = t.length();
i = 0;
while (i < y) {
alp = i;
for (j = 0; j < x; j++) {
k = j, i = alp;
while (k < x && i < y && t[i] == s[k]) {
i++;
k++;
}
if (z < i) {
z = i;
p = j;
q = k - 1;
}
}
for (j = x - 1; j >= 0; j--) {
k = j, i = alp;
while (k >= 0 && i < y && t[i] == s[k]) {
i++;
k--;
}
if (z < i) {
z = i;
p = j;
q = k + 1;
}
}
vec.push_back(make_pair(p, q));
tt++;
i = z;
}
cout << vec.size() << endl;
for (i = 0; i < vec.size(); i++) {
cout << vec[i].first + 1 << " " << vec[i].second + 1 << endl;
}
}
|
#include <bits/stdc++.h>
const int MAXN = 2e7 + 7;
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) {
res = (res * x) % 1000000007;
}
x = (x * x) % 1000000007;
y = y >> 1;
}
return res;
}
std::vector<int> divi[100004];
void divisor(int n) {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
divi[j].push_back(i);
}
}
}
vector<pair<int, int>> v[200005];
int ans[200004];
int vis[200004];
set<int> deg[200005];
vector<int> cnt[200005];
void dfs(int s, int p) {
int val = 1;
for (auto i : v[s]) {
if (i.first != p) {
while (deg[s].find(val) != deg[s].end()) val++;
deg[s].insert(val);
deg[i.first].insert(val);
ans[i.second] = val;
}
}
for (auto i : v[s]) {
if (i.first != p) {
dfs(i.first, s);
}
}
return;
}
pair<int, pair<int, int>> dp[2500];
int L[2500][2500], R[2500][2500];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 2500; i++) {
dp[i] = {INT_MAX, {-1, -1}};
}
string s, t;
cin >> s >> t;
string rev = "";
int n = s.length();
for (int i = s.size() - 1; i >= 0; i--) {
rev.push_back(s[i]);
}
for (int i = 0; i < t.length(); i++) {
for (int j = 0; j < s.length(); j++) {
if (t[i] == s[j]) {
L[i][j] = 1 + ((i > 0 && j > 0) ? L[i - 1][j - 1] : 0);
}
if (t[i] == rev[j]) {
R[i][j] = 1 + ((i > 0 && j > 0) ? R[i - 1][j - 1] : 0);
}
}
}
for (int i = 0; i < t.length(); i++) {
for (int j = 0; j < s.length(); j++) {
if (i == L[i][j] - 1) {
dp[i].first = 1;
dp[i].second = {j - L[i][j] + 1, j};
continue;
} else if (dp[i - L[i][j]].first != INT_MAX &&
dp[i - L[i][j]].first + 1 < dp[i].first) {
dp[i].first = dp[i - L[i][j]].first + 1;
dp[i].second = {j - L[i][j] + 1, j};
}
if (i == R[i][j] - 1) {
dp[i].first = 1;
dp[i].second = {n - j - 1 + R[i][j] - 1, n - j - 1};
} else if (dp[i - R[i][j]].first != INT_MAX &&
dp[i - R[i][j]].first + 1 < dp[i].first) {
dp[i].first = dp[i - R[i][j]].first + 1;
dp[i].second = {n - j - 1 + R[i][j] - 1, n - j - 1};
}
}
}
if (dp[t.length() - 1].first == INT_MAX) {
cout << -1 << endl;
return 0;
}
vector<pair<int, int>> ans;
int i = t.length() - 1;
while (i >= 0) {
ans.push_back(dp[i].second);
i = i - abs(dp[i].second.first - dp[i].second.second) - 1;
}
cout << ans.size() << endl;
while (ans.size()) {
cout << ans.back().first + 1 << " " << ans.back().second + 1 << endl;
ans.pop_back();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(12);
solve();
return 0;
}
template <typename T>
void prv(vector<T> v) {
for (int __ii = 0; __ii < ((int)v.size()); __ii++) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void prm(vector<vector<T>> v) {
for (int __ii = 0; __ii < ((int)v.size()); __ii++) {
for (int __jj = 0; __jj < v[__ii].size(); __jj++) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void pr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void pr(const Head& head, const Tail&... tail) {
cout << head << ' ';
pr(tail...);
}
template <typename... T>
void err(const T&... cod) {
pr(cod...);
exit(0);
}
string s, t;
vector<pair<int, int>> ansv;
int jump(int idx) {
int mx_jump = -1;
int from, to;
for (int i = 0; i < ((int)s.size()); i++) {
if (s[i] == t[idx]) {
int j = i;
while (j < ((int)s.size()) && s[j] == t[idx + j - i]) j++;
if (j - i > mx_jump) {
from = i;
to = j - 1;
mx_jump = j - i;
}
}
}
for (int i = 0; i < ((int)s.size()); i++) {
if (s[i] == t[idx]) {
int j = i;
while (j >= 0 && s[j] == t[idx + i - j]) j--;
if (i - j > mx_jump) {
from = i;
to = j + 1;
mx_jump = i - j;
}
}
}
if (mx_jump == -1) err(-1);
ansv.emplace_back(from + 1, to + 1);
return mx_jump;
}
void solve() {
sc(s, t);
int i = 0, ans = 0;
while (i < ((int)t.size())) {
i += jump(i);
ans++;
}
pr(ans);
for (auto p : ansv) pr(p.first, p.second);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 2102;
int dpf[N][N], dpr[N][N];
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
if (s[i - 1] == t[j - 1]) dpf[i][j] = dpf[i + 1][j + 1] + 1;
reverse(s.begin(), s.end());
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
if (s[i - 1] == t[j - 1]) dpr[i][j] = dpr[i + 1][j + 1] + 1;
bool flag = true;
vector<pair<int, int>> v;
for (int i = 1; i <= m; ++i) {
int len1 = 0, len2 = 0, p1 = 0, p2 = 0;
for (int j = 1; j <= n; ++j) {
if (dpf[j][i] > len1) {
len1 = dpf[j][i];
p1 = j;
}
}
for (int j = 1; j <= n; ++j) {
if (dpr[j][i] > len2) {
len2 = dpr[j][i];
p2 = j;
}
}
if (len1 || len2) {
if (len1 >= len2) {
int l = p1, r = p1 + len1 - 1;
i += len1 - 1;
v.push_back(make_pair(l, r));
} else {
int l = n - p2 + 1, r = n - (p2 + len2) + 2;
i += len2 - 1;
v.push_back(make_pair(l, r));
}
} else {
flag = false;
break;
}
}
if (flag == false)
cout << "-1\n";
else {
cout << v.size() << "\n";
for (auto i : v) cout << i.first << " " << i.second << "\n";
}
}
|
#include <bits/stdc++.h>
const int N = 2150;
using namespace std;
string st1, st2;
int lcp1[N][N], lcp2[N][N];
int ans[N];
int dp[N];
vector<pair<int, int> > answ;
int par[N];
pair<int, int> memo[N];
int rev(int x) { return st1.size() - x - 1; }
int main() {
ios_base::sync_with_stdio(0);
cin >> st1;
cin >> st2;
for (int i = st2.size() - 1; i >= 0; i--) {
for (int j = st1.size() - 1; j >= 0; --j) {
lcp1[i][j] = lcp1[i + 1][j + 1] + 1;
if (st2[i] != st1[j]) lcp1[i][j] = 0;
}
}
reverse(st1.begin(), st1.end());
for (int i = st2.size() - 1; i >= 0; --i) {
for (int j = st1.size() - 1; j >= 0; --j) {
lcp2[i][j] = lcp2[i + 1][j + 1] + 1;
if (st2[i] != st1[j]) {
lcp2[i][j] = 0;
}
}
}
for (int i = 0; i < st2.size(); i++) {
for (int j = 0; j < st1.size(); j++) {
if (lcp1[i][j] > ans[i]) {
ans[i] = lcp1[i][j];
memo[i] = make_pair(j, j + lcp1[i][j] - 1);
}
}
}
for (int i = 0; i < st2.size(); i++) {
for (int j = 0; j < st1.size(); j++) {
if (lcp2[i][j] > ans[i]) {
ans[i] = lcp2[i][j];
memo[i] = make_pair(rev(j), rev(j + lcp2[i][j] - 1));
}
}
}
for (int i = 0; i <= st2.size(); i++) {
dp[i] = 1e9;
}
dp[0] = 0;
for (int i = 0; i < st2.size(); i++) {
int to = i + ans[i];
if (dp[to] > dp[i] + 1) {
dp[to] = dp[i] + 1;
par[to] = i;
}
}
if (dp[st2.size()] > 1e8) {
cout << -1 << endl;
return 0;
}
int cur = st2.size();
while (cur) {
int ps = par[cur];
answ.push_back(memo[ps]);
cur = ps;
}
reverse(answ.begin(), answ.end());
cout << answ.size() << endl;
for (int i = 0; i < answ.size(); i++) {
cout << answ[i].first + 1 << " " << answ[i].second + 1 << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[2200], b[2200], s[2200];
int l[2200], r[2200];
int main() {
int i, j, n, m;
cin >> a >> s;
n = strlen(a);
m = strlen(s);
for (i = 0; i < n; i++) b[n - i - 1] = a[i];
int now = 0, tot = -1, f;
while (now < m) {
tot++;
for (i = 0; i < n; i++) {
if (a[i] == s[now]) {
j = i;
while ((j < n) && (now + j - i < m) && (a[j] == s[now + j - i])) j++;
if ((a[j] != s[now + j - i]) || (j >= n)) j--;
if (j - i + 1 > r[tot] - l[tot]) {
l[tot] = i + 1;
r[tot] = j + 2;
f = 0;
}
}
}
for (i = 0; i < n; i++) {
if (b[i] == s[now]) {
j = i;
while ((j < n) && (now + j - i < m) && (b[j] == s[now + j - i])) j++;
if ((b[j] != s[now + j - i]) || (j >= n)) j--;
if (j - i + 1 > r[tot] - l[tot]) {
l[tot] = i + 1;
r[tot] = j + 2;
f = 1;
}
}
}
if (!l[tot]) {
printf("-1\n");
return 0;
}
r[tot]--;
now += r[tot] - l[tot] + 1;
if (f) {
l[tot] = n + 1 - l[tot];
r[tot] = n + 1 - r[tot];
}
}
printf("%d\n", tot + 1);
for (i = 0; i < tot + 1; i++) {
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S, T;
cin >> S >> T;
string R = S;
reverse(R.begin(), R.end());
ostringstream out;
int c = 0;
for (int j = 0; j < T.size();) {
int m = 0, m_i;
for (long long i = (0); i < (S.size()); i++) {
int x = 0;
for (; i + x < S.size() && j + x < T.size() && S[i + x] == T[j + x]; x++)
;
if (m < x) {
m = x;
m_i = i;
}
}
for (long long i = (0); i < (R.size()); i++) {
int x = 0;
for (; i + x < R.size() && j + x < T.size() && R[i + x] == T[j + x]; x++)
;
if (m < x) {
m = x;
m_i = ~i;
}
}
if (m == 0) {
cout << -1 << "\n";
return 0;
}
j += m;
if (m_i >= 0)
out << m_i + 1 << " " << m_i + m << "\n";
else
out << R.size() - ~m_i << " " << R.size() - ~m_i - m + 1 << "\n";
c++;
}
cout << c << "\n" << out.str();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
Node* f[26];
Node() {
l = r = 0;
memset(f, 0, sizeof(f));
}
};
Node* add_word(Node* node, int letter, int l, int r) {
if (node->f[letter] == NULL) node->f[letter] = new Node();
node->f[letter]->l = l;
node->f[letter]->r = r;
return node->f[letter];
}
Node* root = new Node();
vector<pair<int, int> > sol;
void search(Node* node, int& pos, string& word, pair<int, int>& vaca) {
if (pos == word.size()) return;
int letter = word[pos] - 'a';
if (node->f[letter] != NULL) {
pos++;
vaca = make_pair(node->f[letter]->l, node->f[letter]->r);
search(node->f[letter], pos, word, vaca);
} else
return;
}
int main() {
cin.sync_with_stdio(false);
string s, d;
cin >> d >> s;
for (int i = 0; i < d.size(); i++) {
Node* past = root;
for (int j = i; j < d.size(); j++) past = add_word(past, d[j] - 'a', i, j);
}
for (int i = d.size() - 1; i >= 0; i--) {
Node* past = root;
for (int j = i; j >= 0; j--) past = add_word(past, d[j] - 'a', i, j);
}
for (int i = 0; i < s.size();) {
pair<int, int> vaca = make_pair(-1, -1);
search(root, i, s, vaca);
if (vaca.first == -1 && vaca.second == -1) {
cout << -1;
return 0;
}
sol.push_back(make_pair(vaca.first + 1, vaca.second + 1));
}
cout << sol.size() << '\n';
for (auto it : sol) cout << it.first << ' ' << it.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t, p, a = "";
vector<pair<int, int> > res;
int main() {
ios_base::sync_with_stdio(false);
cin >> s >> t;
p = s;
reverse(p.begin(), p.end());
int x, y, pos, n = s.size();
for (int i = 0; i < t.size(); i++) {
a += t[i];
pos = s.find(a);
if (pos == -1) {
pos = p.find(a);
} else {
x = pos + 1, y = x + a.size() - 1;
continue;
}
if (pos == -1) {
if (a.size() == 1) return cout << -1, 0;
res.push_back({x, y});
i--;
a.clear();
} else {
x = pos + 1, y = x + a.size() - 1;
x = n + 1 - x, y = n + 1 - y;
}
}
res.push_back({x, y});
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int MOD = 1000000007;
string s, t;
int main() {
ios_base::sync_with_stdio(0);
cin >> s >> t;
string bs = s;
reverse(bs.begin(), bs.end());
int l = 0;
int r = 0;
string h = "";
vector<pair<int, int> > ans;
for (int i = 0; i < t.size(); ++i) {
h += t[i];
if (s.find(h) == string::npos && bs.find(h) == string::npos) {
if (h.size() == 1) {
cout << -1 << endl;
return 0;
}
ans.push_back(make_pair(l + 1, r + 1));
h = t[i];
l = s.find(h);
r = l;
if (l == string::npos) {
cout << -1 << endl;
return 0;
}
} else {
if (s.find(h) != string::npos) {
l = s.find(h);
r = l + h.size() - 1;
} else {
l = s.size() - bs.find(h) - 1;
r = l - h.size() + 1;
}
}
}
ans.push_back(make_pair(l + 1, r + 1));
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > mem[2101];
int kmp(const string &needle, const string &haystack) {
int m = needle.size();
vector<int> border(m + 1);
border[0] = -1;
for (int i = 0; i < m; ++i) {
border[i + 1] = border[i];
while (border[i + 1] > -1 && needle[border[i + 1]] != needle[i]) {
border[i + 1] = border[border[i + 1]];
}
border[i + 1]++;
}
int n = haystack.size();
int seen = 0;
for (int i = 0; i < n; ++i) {
while (seen > -1 && needle[seen] != haystack[i]) {
seen = border[seen];
}
if (++seen == m) {
return i - m + 1;
seen = border[m];
}
}
return -1;
}
int main() {
string s, t;
cin >> s >> t;
bool vis[t.size()];
vector<pair<int, int> > ret;
string str1 = "", str2 = "";
int i = 0;
pair<int, int> p = make_pair(-1, -1);
while (i < t.size()) {
str1 += t[i];
str2 = t[i] + str2;
int a = kmp(str1, s), b = kmp(str2, s);
if (a == -1 && b == -1) {
if (p.first == -1) {
cout << -1 << endl;
return 0;
}
ret.push_back(p);
p.first = -1;
str1 = str2 = "";
continue;
}
if (a != -1) {
p = make_pair(a, a + str1.size() - 1);
} else {
p = make_pair(b + str2.size() - 1, b);
}
i++;
}
if (p.first == -1) {
cout << -1 << endl;
return 0;
} else
ret.push_back(p);
cout << ret.size() << endl;
for (int i = 0; i < ret.size(); i++)
cout << ret[i].first + 1 << " " << ret[i].second + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void scanint(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
long long fine(string s, string t, int len) {
string j = t.substr(0, len);
string rs = s;
reverse(rs.begin(), rs.end());
if (s.find(j) != std::string ::npos) {
int k = s.find(j);
return k;
} else if (rs.find(j) != std::string::npos) {
int k = rs.find(j);
return k;
}
return -1;
}
int main() {
std::ios::sync_with_stdio(false);
int t;
{
string s, t;
cin >> s >> t;
string rs = s;
int n = s.length();
reverse(rs.begin(), rs.end());
vector<pair<int, int> > ans;
while (!t.empty()) {
int lo = 1, hi = (int)t.length();
int len;
int ans2 = -1;
while (lo <= hi) {
len = (lo) + (hi - lo) / 2;
int k = fine(s, t, len);
if (k == -1)
hi = len - 1;
else {
lo = len + 1;
ans2 = len;
}
}
if (ans2 == -1) {
cout << ans2 << "\n";
return 0;
}
string j = t.substr(0, ans2);
if (s.find(j) != std::string ::npos) {
int k = s.find(j);
ans.push_back(make_pair(k + 1, k + ans2));
t.erase(0, ans2);
} else if (rs.find(j) != std::string::npos) {
int k = rs.find(j);
ans.push_back(make_pair(n - k, n - k - ans2 + 1));
t.erase(0, ans2);
}
}
cout << ans.size() << "\n";
for (auto i : ans) cout << i.first << " " << i.second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
s = "$" + s + "$";
t += "#";
vector<int> endPos1(s.size()), endPos2(s.size());
vector<pair<int, int> > ans;
for (int i = 0; i < m;) {
int found = 0;
pair<int, int> cur = {-1, -1};
for (int j = 1; j <= n; j++) {
endPos1[j] = (s[j] == t[i]);
endPos2[j] = (s[j] == t[i]);
found |= endPos1[j];
}
for (int len = 1; found; i++, len++) {
found = 0;
for (int j = 1; j <= n; j++) {
if (endPos2[j]) {
cur = {j + len - 1, j};
}
endPos2[j] = (endPos2[j + 1] && s[j] == t[i + 1]);
found |= endPos2[j];
}
for (int j = n; j >= 1; j--) {
if (endPos1[j]) {
cur = {j - len + 1, j};
}
endPos1[j] = (endPos1[j - 1] && s[j] == t[i + 1]);
found |= endPos1[j];
}
}
if (cur.first == -1) {
cout << "-1" << endl;
return 0;
}
ans.push_back(cur);
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
const int INF = 1e9;
const long long INF_LL = 4e18;
const double pi = acos(-1.0);
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
char s[2][2102], t[2102];
int n, m;
vector<pair<int, int>> ans;
int main() {
scanf("%s%s", s[0], t);
n = (int)strlen(s[0]);
m = (int)strlen(t);
for (int i = 0; i < n; i++) s[1][i] = s[0][n - 1 - i];
int p = 0;
while (p < m) {
int p1 = -1, len1 = 0, p2 = -1, len2 = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m - p && i + j - 1 < n; j++) {
if (s[0][i + j - 1] == t[p + j - 1]) {
if (j > len1) {
len1 = j;
p1 = i;
}
} else
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m - p && i + j - 1 < n; j++) {
if (s[1][i + j - 1] == t[p + j - 1]) {
if (j > len2) {
len2 = j;
p2 = i;
}
} else
break;
}
}
if (len1 > 0 && len1 >= len2) {
assert(p1 >= 0);
ans.push_back(make_pair((p1), (p1 + len1 - 1)));
p += len1;
} else if (len2 > 0 && len2 > len1) {
assert(p2 >= 0);
ans.push_back(make_pair((n - 1 - p2), (n - 1 - (p2 + len2 - 1))));
p += len2;
} else
break;
}
if (p == m) {
printf("%d\n", int((ans).size()));
for (auto i : ans) printf("%d %d\n", i.first + 1, i.second + 1);
} else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2211;
int lcp[N][N];
int dp[N];
int from[N][2];
void solve(string &s, string &t, int type) {
memset(lcp, 0, sizeof(lcp));
for (int i = s.size() - 1; i >= 0; i--)
for (int j = t.size() - 1; j >= 0; j--)
if (s[i] == t[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
if (lcp[i][j] > dp[j]) {
dp[j] = lcp[i][j];
from[j][0] = i + 1;
from[j][1] = i + dp[j];
if (type == 1) {
int sl = s.size();
from[j][0] = sl - from[j][0] + 1;
from[j][1] = sl - from[j][1] + 1;
}
}
}
}
int main() {
ios ::sync_with_stdio(false);
string s, t;
cin >> s >> t;
solve(s, t, 0);
reverse(s.begin(), s.end());
solve(s, t, 1);
int now = 0;
vector<pair<int, int> > ans;
while (now != t.size()) {
if (dp[now] == 0) {
cout << -1 << '\n';
return 0;
}
ans.push_back(make_pair(from[now][0], from[now][1]));
now += dp[now];
}
cout << ans.size() << '\n';
for (auto &p : ans) cout << p.first << ' ' << p.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const char en = '\n';
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t, u;
cin >> t >> s;
u = t;
reverse(u.begin(), u.end());
int pos = 0;
vector<pair<long long, long long> > X;
while (pos < s.length()) {
int z = -1, e = -1;
for (int x = 0; x < t.length(); x++) {
int p = x;
while (p + pos - x < s.length() && p < t.length() &&
t[p] == s[p + pos - x])
p++;
if (abs(p - x) > abs(z - e)) {
z = x;
e = p;
}
}
int zz = -1, ee = -1;
for (int x = 0; x < t.length(); x++) {
int p = x;
while (p + pos - x < s.length() && p < t.length() &&
u[p] == s[p + pos - x])
p++;
if (abs(p - x) > abs(zz - ee)) {
zz = x;
ee = p;
}
}
int zzz = 0, eee = -1;
if (e - z > eee - zzz + 1) {
zzz = z + 1;
eee = e;
}
if (ee - zz > eee - zzz + 1) {
zzz = t.length() - zz;
eee = t.length() - ee + 1;
}
if (eee == -1) break;
pos += abs(zzz - eee) + 1;
X.push_back(make_pair(zzz, eee));
}
if (pos == s.length()) {
cout << X.size() << en;
for (int i = 0; i < X.size(); i++) {
cout << X[i].first << " " << X[i].second << en;
}
} else
cout << "-1" << en;
}
|
#include <bits/stdc++.h>
using namespace std;
map<char, int> a;
vector<pair<int, int> > ans;
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.length(); i++) a[s[i]]++;
for (int i = 0; i < t.length(); i++) {
if (a[t[i]] == 0) {
cout << "-1";
return 0;
}
}
int k = 0;
while (k < t.length()) {
int mlen = 0;
int pos = 0;
bool f = 0;
for (int i = 0; i < s.length(); i++) {
int len = 0;
for (int j = 0; k + j < t.length() && i + j < s.length(); j++) {
if (t[k + j] == s[i + j])
len++;
else
break;
}
if (mlen < len) {
mlen = len;
pos = i;
}
}
for (int i = 0; i < s.length(); i++) {
int len = 0;
for (int j = 0; k + j < t.length() && i - j >= 0; j++) {
if (t[k + j] == s[i - j])
len++;
else
break;
}
if (mlen < len) {
mlen = len;
pos = i;
f = 1;
}
}
if (!f)
ans.push_back(make_pair(pos, pos + mlen - 1));
else
ans.push_back(make_pair(pos, pos - mlen + 1));
k += mlen;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
vector<pair<int, int> > v;
void pre(string &p, int *b) {
int i = 0, j = -1;
b[0] = -1;
while (i < p.size()) {
while (j >= 0 && p[i] != p[j]) j = b[j];
i++, j++;
b[i] = j;
}
}
pair<int, int> kmp(string &t, string &p) {
int b[p.size() + 1];
pre(p, b);
int i = 0, j = 0;
while (i < t.size()) {
while (j >= 0 && t[i] != p[j]) j = b[j];
i++, j++;
if (j == p.size()) {
return pair<int, int>(i - p.size() + 1, i);
}
}
return pair<int, int>(-1, -1);
}
pair<bool, pair<int, int> > match(string &t, string &s) {
pair<int, int> cand = kmp(s, t);
if (cand.first == -1) {
reverse(s.begin(), s.end());
cand = kmp(s, t);
reverse(s.begin(), s.end());
if (cand.first != -1) {
int f = cand.first;
cand.first = s.size() - cand.second + 1;
cand.second = s.size() - f + 1;
swap(cand.first, cand.second);
return make_pair(true, cand);
} else
return make_pair(false, cand);
} else
return make_pair(true, cand);
return make_pair(false, cand);
}
int main(int argc, char const *argv[]) {
cin >> s >> t;
int start = 0;
bool can = true;
while (can && start != t.size()) {
int lo = start, hi = t.size() - 1;
int len = -1;
pair<int, int> best;
while (lo <= hi) {
int mid = (lo + hi) / 2;
string to_match = t.substr(start, mid - start + 1);
pair<bool, pair<int, int> > r = match(to_match, s);
if (r.first) {
best = r.second;
len = mid - start + 1;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
if (len == -1)
can = false;
else {
v.push_back(best);
start += len;
}
}
if (can) {
printf("%d\n", (int)v.size());
for (int i = 0; i < v.size(); i++) {
printf("%d %d\n", v[i].first, v[i].second);
}
} else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *first, *next;
int at;
char ch;
Node(int _at, char _ch, Node* last) {
first = NULL;
next = last;
at = _at;
ch = _ch;
}
Node* getChild(char c) {
Node* cur = first;
while (cur) {
if (cur->ch == c) return cur;
cur = cur->next;
}
return NULL;
}
};
struct Trie {
Node* root;
Trie() { root = new Node(0, 0, NULL); }
void insert(char* s, int len, int at) {
Node* cur = root;
Node* nxt;
for (int i = 0; i < len; ++i) {
nxt = cur->getChild(s[i]);
if (nxt == NULL) {
nxt = new Node(at, s[i], cur->first);
cur->first = nxt;
}
cur = nxt;
cur->at = at;
}
}
};
Trie a, b;
char s[2101], t[2101];
int len, dp[2100], lenA;
pair<int, int> best[2100];
int calc(int i) {
if (i == len) return 0;
int& ret = dp[i];
if (ret != -1) return ret;
ret = 1e9;
Node* cur = a.root;
for (int j = i; j < len; ++j) {
cur = cur->getChild(t[j]);
if (cur == NULL) break;
int z = 1 + calc(j + 1);
if (z < ret) {
ret = z;
best[i] = make_pair(cur->at, cur->at + j - i);
}
}
cur = b.root;
for (int j = i; j < len; ++j) {
cur = cur->getChild(t[j]);
if (cur == NULL) break;
int z = 1 + calc(j + 1);
if (z < ret) {
ret = z;
int x = cur->at;
int y = cur->at + j - i;
x = lenA - x - 1;
y = lenA - y - 1;
best[i] = make_pair(x, y);
}
}
return ret;
}
int main() {
scanf("%s%s", s, t);
lenA = len = strlen(s);
for (int i = 0; i < len; ++i) a.insert(s + i, len - i, i);
reverse(s, s + len);
for (int i = 0; i < len; ++i) b.insert(s + i, len - i, i);
reverse(s, s + len);
memset(dp, -1, sizeof(dp));
len = strlen(t);
if (calc(0) > 1e8) {
puts("-1");
return 0;
}
int cur = 0;
printf("%d\n", calc(0));
while (cur != len) {
printf("%d %d\n", best[cur].first + 1, best[cur].second + 1);
cur += abs(best[cur].first - best[cur].second) + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct trie_t {
struct node {
int tag;
node* children[26];
node() : tag(-1) {
for (int i = 0; i < 26; i++) children[i] = nullptr;
}
};
node* root;
node* curr;
trie_t() {
root = new node();
curr = root;
}
void push(const string& str, int tag) {
if (!str.empty()) push(root, str, 0, tag);
}
void push(node* p, const string& str, int i, int tag) {
if (!p->children[str[i] - 'a']) p->children[str[i] - 'a'] = new node();
p->children[str[i] - 'a']->tag = tag;
if (i + 1 != str.size()) push(p->children[str[i] - 'a'], str, i + 1, tag);
}
void reset() { curr = root; }
bool canMove(char ch) { return curr->children[ch - 'a'] != nullptr; }
void move(char ch) { curr = curr->children[ch - 'a']; }
};
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
string s, t;
cin >> s >> t;
trie_t trie1 = trie_t();
trie_t trie2 = trie_t();
string sInv = string(s.rbegin(), s.rend());
for (int i = 0; i < s.length(); i++) {
trie1.push(s.substr(i, s.length()), i + 1);
trie2.push(sInv.substr(i, s.length()), s.length() - i);
}
int MAX = t.size() + 1;
int* dp = new int[t.size() + 1];
int* dPrev = new int[t.size() + 1];
int* dStart = new int[t.size() + 1];
int* dEnd = new int[t.size() + 1];
dp[0] = 0;
for (int len = 1; len <= t.size(); len++) {
int best = MAX;
trie1.reset();
for (int l = len - 1; l >= 0; --l) {
if (trie1.canMove(t[l])) {
trie1.move(t[l]);
if (dp[l] + 1 < best) {
best = dp[l] + 1;
dPrev[len] = l;
dStart[len] = trie1.curr->tag;
dEnd[len] = trie1.curr->tag + (len - l - 1);
}
} else
break;
}
trie2.reset();
for (int l = len - 1; l >= 0; --l) {
if (trie2.canMove(t[l])) {
trie2.move(t[l]);
if (dp[l] + 1 < best) {
best = dp[l] + 1;
dPrev[len] = l;
dStart[len] = trie2.curr->tag;
dEnd[len] = trie2.curr->tag - (len - l - 1);
}
} else
break;
}
swap(dStart[len], dEnd[len]);
dp[len] = best;
}
if (dp[t.length()] == MAX) {
cout << -1 << endl;
} else {
vector<pair<int, int> > stk = vector<pair<int, int> >();
int k = t.length();
while (k > 0) {
stk.push_back(pair<int, int>(dStart[k], dEnd[k]));
k = dPrev[k];
}
cout << stk.size() << endl;
while (!stk.empty()) {
cout << stk.back().first << " " << stk.back().second << endl;
stk.pop_back();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3030;
int lcpts[maxN][maxN];
int lcprev[maxN][maxN];
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
int m = t.size();
s = "&" + s + "@";
t = "$" + t + "^";
for (int i = m; i >= 1; i--) {
for (int j = n; j >= 1; j--) {
if (t[i] == s[j]) lcpts[i][j] = lcpts[i + 1][j + 1] + 1;
}
for (int j = 1; j <= n; j++) {
if (t[i] == s[j]) lcprev[i][j] = lcprev[i + 1][j - 1] + 1;
}
}
vector<pair<int, int> > ans;
for (int i = 1; i <= m;) {
int i1 = max_element(lcpts[i] + 1, lcpts[i] + n + 1) - lcpts[i];
int i2 = max_element(lcprev[i] + 1, lcprev[i] + n + 1) - lcprev[i];
int len = max(lcpts[i][i1], lcprev[i][i2]);
if (len == 0) {
cout << -1 << endl;
return 0;
}
if (len == lcpts[i][i1]) {
ans.push_back({i1, i1 + len - 1});
} else {
ans.push_back({i2, i2 - len + 1});
}
i += len;
}
cout << ans.size() << endl;
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2105;
const int Q = 1e9 + 7;
char str[N], s[N];
int sl, tl, nxt[N], way[2][N];
void getnext(char s[], int p, int l) {
int j = 0, k = -1;
nxt[0] = -1;
while (p + j < l) {
while (k > -1 && s[p + j] != s[p + k]) k = nxt[k];
++j;
++k;
nxt[j] = (s[p + j] == s[p + k]) ? nxt[k] : k;
}
}
int kmp(char s[], int pos, int p, int l) {
int i = 0, j = 0;
getnext(s, p, l);
while (pos + i < sl) {
while (j > -1 && str[pos + i] != s[p + j]) j = nxt[j];
++i;
if (++j == l) return i;
}
return -1;
}
pair<int, int> check(int l, int r) {
char s1[N], s2[N];
int pt1 = 0, pt2 = 0;
for (int i = l; i <= r; i++) s1[pt1++] = s[i];
for (int i = r; i >= l; i--) s2[pt2++] = s[i];
return make_pair(kmp(s1, 0, 0, pt1), kmp(s2, 0, 0, pt2));
}
int main() {
scanf("%s%s", str, s);
sl = strlen(str);
tl = strlen(s);
int ans = 0;
int cur = 0;
bool ok = 1;
while (cur < tl) {
int l = 1, r = tl;
while (l + 1 < r) {
int mid = (l + r) / 2;
pair<int, int> c = check(cur, cur + mid - 1);
if (c.first != -1 || c.second != -1)
l = mid;
else
r = mid;
}
pair<int, int> c = check(cur, cur + r - 1);
if (c.first != -1 || c.second != -1) {
if (c.first != -1) {
way[0][ans] = c.first - r + 1;
way[1][ans] = c.first;
} else {
way[0][ans] = c.second;
way[1][ans] = c.second - r + 1;
}
ans++;
cur += r;
} else {
pair<int, int> c = check(cur, cur + l - 1);
if (c.first != -1 || c.second != -1) {
if (c.first != -1) {
way[0][ans] = c.first - l + 1;
way[1][ans] = c.first;
} else {
way[0][ans] = c.second;
way[1][ans] = c.second - l + 1;
}
ans++;
cur += l;
} else {
ok = 0;
break;
}
}
}
if (!ok)
puts("-1");
else {
cout << ans << endl;
for (int i = 0; i < ans; i++) cout << way[0][i] << " " << way[1][i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp1[2110][2110], dp2[2110][2110];
int dp[2110];
int main() {
string s, t;
cin >> s >> t;
int slen = s.length(), tlen = t.length();
string srev = s;
reverse(srev.begin(), srev.end());
for (int i = slen - 1; i >= 0; i--) {
for (int j = tlen - 1; j >= 0; j--) {
if (s[i] == t[j])
dp1[i][j] = dp1[i + 1][j + 1] + 1;
else
dp1[i][j] = 0;
}
}
for (int i = slen - 1; i >= 0; i--) {
for (int j = tlen - 1; j >= 0; j--) {
if (srev[i] == t[j])
dp2[i][j] = dp2[i + 1][j + 1] + 1;
else
dp2[i][j] = 0;
}
}
for (int i = 0; i < 2110; i++) dp[i] = 1e9;
dp[tlen] = 0;
for (int i = tlen - 1; i >= 0; i--) {
for (int j = 0; j < slen; j++) {
dp[i] = min(dp[i], dp[min(tlen, i + dp1[j][i])] + 1);
}
for (int j = 0; j < slen; j++) {
dp[i] = min(dp[i], dp[min(tlen, i + dp2[j][i])] + 1);
}
}
if (dp[0] == 1e9)
cout << -1 << endl;
else {
cout << dp[0] << endl;
int iptr = 0;
while (iptr < tlen) {
for (int i = 0; i < slen; i++) {
if (dp[iptr] == dp[min(tlen, iptr + dp1[i][iptr])] + 1) {
cout << i + 1 << " " << i + dp1[i][iptr] << endl;
iptr += dp1[i][iptr];
break;
}
}
for (int i = 0; i < slen; i++) {
if (dp[iptr] == dp[min(tlen, iptr + dp2[i][iptr])] + 1) {
cout << slen - 1 - i + 1 << " "
<< slen - 1 - (i + dp2[i][iptr] - 1) + 1 << endl;
iptr += dp2[i][iptr];
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
int k = 0, i = 0, j = 0;
string pat, txt, patr;
in >> pat;
in >> txt;
int t = pat.size();
patr = pat;
reverse(patr.begin(), patr.end());
pat = pat + "$" + patr;
vector<vector<int>> dp(txt.size(), vector<int>(pat.size() + 1, 0));
int val = 0;
for (size_t i = 0; i < txt.size(); i++) {
for (size_t j = 0; j < pat.size(); j++) {
val = (i == 0 || j == 0) ? 0 : dp[i - 1][j - 1];
dp[i][j] = (txt[i] == pat[j]) ? val + 1 : 0;
}
dp[i][pat.size()] = 0;
if (i > 0 && *max_element(dp[i].begin(), dp[i].end()) <=
*max_element(dp[i - 1].begin(), dp[i - 1].end())) {
for (size_t j = 1; j < pat.size(); j++)
dp[i][j] = (txt[i] == pat[j]) ? 1 : 0;
}
}
dp.push_back(vector<int>(pat.size() + 1, 0));
vector<pair<int, int>> res;
int mss = 0;
int pos = 0;
for (size_t i = 0; i < dp.size() - 1; i++) {
bool maxnow = 0;
for (size_t j = 0; j < dp[0].size() - 1; ++j) {
if (maxnow && dp[i][j] >= mss && dp[i + 1][j + 1] > mss) {
maxnow = 0;
pos = j;
}
if (dp[i][j] > mss) {
maxnow = (dp[i + 1][j + 1] == 0);
++mss;
pos = j;
}
}
if (mss == 0) {
out << -1;
return;
}
if (maxnow) {
if (pos < t)
res.push_back(make_pair(pos - mss + 2, pos + 1));
else
res.push_back(make_pair(2 * t - pos + mss, 2 * t - pos + 1));
mss = 0;
}
}
if (res.empty()) {
out << -1;
return;
} else
out << res.size() << "\n";
for (size_t i = 0; i < res.size(); ++i) {
if (res[i].first != -1)
out << res[i].first << " " << res[i].second << "\n";
}
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2105;
const int inf = 1e9;
char s[N], my[N];
int n, m, half;
int lcp[N][N], dp[N][2], f[N][2];
vector<pair<int, int> > sol;
void calcLCP() {
for (int i = m; i > 0; i--) {
for (int j = n; j > 0; j--) {
if (s[j] == my[i]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (lcp[i][j] > f[i][0]) {
f[i][0] = lcp[i][j];
f[i][1] = j;
}
}
}
reverse(s + 1, s + n + 1);
memset(lcp, 0, sizeof lcp);
for (int i = m; i > 0; i--) {
for (int j = n; j > 0; j--) {
if (s[j] == my[i]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (lcp[i][j] > abs(f[i][0])) {
f[i][0] = -lcp[i][j];
f[i][1] = j;
}
}
}
}
int main() {
scanf("%s%s", s + 1, my + 1);
n = strlen(s + 1);
m = strlen(my + 1);
calcLCP();
for (int i = 1; i <= m; i++) dp[i][0] = inf;
for (int i = 1; i <= m; i++) {
for (int j = i - 1; j >= 0; j--) {
if (abs(f[j + 1][0]) >= i - j) {
if (dp[j][0] + 1 < dp[i][0]) {
dp[i][0] = dp[j][0] + 1;
dp[i][1] = j + 1;
}
}
}
}
if (dp[m][0] == inf)
printf("-1");
else {
printf("%d\n", dp[m][0]);
int p = m;
while (p > 0) {
int xt = dp[p][1];
if (f[xt][0] > 0)
sol.push_back(
make_pair(f[xt][1], f[xt][1] + min(f[xt][0] - 1, p - xt)));
else {
int l = f[xt][1];
int r = f[xt][1] + min(-f[xt][0] - 1, p - xt);
sol.push_back(make_pair(n - l + 1, n - r + 1));
}
p = xt - 1;
}
for (int i = sol.size() - 1; i >= 0; i--)
printf("%d %d\n", sol[i].first, sol[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
bool arr[26] = {0};
for (int i = 0; i < s.size(); i++) arr[s[i] - 'a'] = 1;
for (int j = 0; j < t.size(); j++) {
if (!arr[t[j] - 'a']) {
cout << -1 << endl;
return 0;
}
}
int c = 0;
int j = 0;
vector<pair<int, int> > vec;
while (j != t.size()) {
int maxx = 0, start = 0, direction = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == t[j]) {
int x = i, y = j, count = 0;
while (x < s.size() && y < t.size() && s[x] == t[y]) {
count++;
x++;
y++;
}
if (count > maxx) {
start = i;
maxx = count;
}
}
}
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == t[j]) {
int x = i, y = j, count = 0;
while (x >= 0 && y < t.size() && s[x] == t[y]) {
count++;
x--;
y++;
}
if (count > maxx) {
start = i;
maxx = count;
direction = 1;
}
}
}
int endd;
if (!direction)
endd = start + maxx - 1;
else
endd = start - maxx + 1;
vec.push_back(make_pair(start, endd));
c++;
j += maxx;
}
cout << c << endl;
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].first + 1 << ' ' << vec[i].second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2, t, a;
vector<pair<int, int> > ans;
int main() {
cin >> s1 >> s2;
t = s1;
int n = s1.size();
reverse(t.begin(), t.end());
int x, y;
for (int i = 0; i < s2.size(); i++) {
a += s2[i];
int f = s1.find(a);
if (f < 0)
f = t.find(a);
else {
x = f + 1, y = x + a.size() - 1;
continue;
}
if (f < 0) {
if (a.size() == 1) {
cout << -1 << endl;
return 0;
} else {
ans.push_back(make_pair(x, y));
i--, a.clear();
}
} else {
x = f + 1, y = x + a.size() - 1, x = n + 1 - x, y = n + 1 - y;
}
}
ans.push_back(make_pair(x, y));
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2110];
char t[2110];
vector<int> v[26];
int main() {
while (cin >> s >> t) {
for (int i = 0; s[i]; i++) {
v[s[i] - 'a'].push_back(i);
}
vector<pair<int, int> > ans;
for (int i = 0; t[i];) {
int beg = 0, end = 0;
int maxl = 0;
for (int j = 0; j < v[t[i] - 'a'].size(); j++) {
int b = v[t[i] - 'a'][j];
int l = 0;
while (s[b + l] && s[b + l] == t[i + l]) {
l++;
}
if (l > maxl) {
beg = b + 1;
end = b + l;
maxl = l;
}
l = 0;
while (b - l >= 0 && s[b - l] == t[i + l]) {
l++;
}
if (l > maxl) {
beg = b + 1;
end = b - l + 2;
maxl = l;
}
}
if (maxl == 0) {
cout << -1 << endl;
return 0;
}
ans.push_back(make_pair(beg, end));
i += maxl;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[2200];
char b[2200];
int ans[2200][2];
int main() {
cin >> a;
cin >> b;
int lena = strlen(a);
int lenb = strlen(b);
int process = 0;
int total = 0;
while (process < lenb and total != -1) {
int temp = 0;
int tempans = 0;
for (int i = 0; i < lena; i++) {
if (process + temp < lenb and a[i] == b[process + temp]) {
temp++;
if (tempans < temp)
tempans = temp, ans[total][0] = i + 1 - temp + 1,
ans[total][1] = i + 1;
} else {
if (ans[total][0] != 2 + i - temp and ans[total][1] != i + 1)
i -= temp - 1;
temp = 0;
if (process + temp < lenb and a[i] == b[process + temp]) {
temp++;
if (tempans < temp)
tempans = temp, ans[total][0] = i + 1 - temp + 1,
ans[total][1] = i + 1;
}
}
}
temp = 0;
for (int i = lena - 1; i >= 0; i--) {
if (process + temp < lenb and a[i] == b[process + temp]) {
temp++;
if (tempans < temp)
tempans = temp, ans[total][0] = i - 1 + temp + 1,
ans[total][1] = i + 1;
} else {
if (ans[total][0] != i - 1 + temp + 1 or ans[total][1] != i + 1)
i += temp - 1;
temp = 0;
if (process + temp < lenb and a[i] == b[process + temp]) {
temp++;
if (tempans < temp)
tempans = temp, ans[total][0] = i - 1 + temp + 1,
ans[total][1] = i + 1;
}
}
}
process += tempans;
total++;
if (tempans == 0) total = -1;
}
if (total == -1)
cout << -1 << endl;
else {
cout << total << endl;
for (int i = 0; i < total; i++)
cout << ans[i][0] << " " << ans[i][1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[2][2110][2110];
int main() {
string s, t;
cin >> s >> t;
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = t.size() - 1; j >= 0; j--) {
if (s[i] == t[j]) dp[0][i][j] = dp[0][i + 1][j + 1] + 1;
if (s[s.size() - 1 - i] == t[j]) dp[1][i][j] = dp[1][i + 1][j + 1] + 1;
}
}
vector<pair<int, int>> ans;
int cur = 0;
while (cur < t.size()) {
int tmp = 0;
pair<int, int> add;
for (int i = 0; i < s.size(); i++) {
if (dp[0][i][cur] > tmp) {
tmp = dp[0][i][cur];
add = make_pair(i + 1, i + dp[0][i][cur]);
}
if (dp[1][i][cur] > tmp) {
tmp = dp[1][i][cur];
add = make_pair(s.size() - i, s.size() - i - (dp[1][i][cur] - 1));
}
}
if (tmp == 0) {
cout << -1 << endl;
return 0;
}
cur += tmp;
ans.push_back(add);
}
cout << ans.size() << endl;
for (auto i : ans) cout << i.first << " " << i.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const long long INFll = 1ll * INF * INF;
const long double ldINF = 1e+018;
const long double EPS = 0.000000001;
int d[2500][2500];
int f[2500][2500];
int main() {
ios_base::sync_with_stdio(0);
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--)
if (s[i] == t[j]) d[i][j] = d[i + 1][j + 1] + 1;
reverse(s.begin(), s.end());
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--)
if (s[i] == t[j]) f[i][j] = f[i + 1][j + 1] + 1;
int x = 0;
vector<pair<int, int> > ans;
while (x < m) {
int mx = 0, num = 0, k = 0;
for (int i = 0; i < n; i++)
if (mx < d[i][x]) mx = d[i][x], num = i;
for (int i = 0; i < n; i++)
if (mx < f[i][x]) mx = f[i][x], num = i, k = 1;
if (mx == 0) {
cout << -1 << endl;
return 0;
}
if (k == 0)
ans.push_back(make_pair(num + 1, num + mx));
else
ans.push_back(make_pair(n - num, n - num - mx + 1));
x += mx;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2103], t[2103];
pair<int, int> xy[2103];
int ln_s, ln_t, sz, sz1, x, yy, x_tmp, ans;
int main() {
scanf("%s\n", s);
scanf("%s\n", t);
ln_s = strlen(s);
ln_t = strlen(t);
t[ln_t] = '%';
for (int i = (0); i < (ln_t); ++i) {
int tmp_i = i, ii = i;
sz1 = sz = 0;
for (int j = 0, jj = 0; jj < ln_s; ++jj) {
j = jj;
sz = 0;
i = tmp_i;
if (s[j] != t[i]) {
++j;
continue;
}
x_tmp = j;
while (s[j] == t[i]) ++sz, ++i, ++j;
if (sz > sz1) {
sz1 = sz;
x = x_tmp;
yy = j - 1;
}
}
for (int j = ln_s - 1, jj = j; jj >= 0; --jj) {
j = jj;
sz = 0;
ii = tmp_i;
if (s[j] != t[ii]) {
--j;
continue;
}
x_tmp = j;
while (j >= 0 && s[j] == t[ii]) ++sz, ++ii, --j;
if (sz > sz1) {
sz1 = sz;
x = x_tmp;
yy = j + 1;
}
}
if (sz1 == 0) {
cout << -1;
return 0;
}
i = tmp_i + sz1 - 1;
xy[ans].first = x;
xy[ans].second = yy;
++ans;
}
cout << ans;
printf("\n");
for (int i = (0); i < (ans); ++i)
printf("%d %d ", xy[i].first + 1, xy[i].second + 1), printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, z[6007];
char c[3007];
string s, t, s1, q, p;
vector<pair<int, int> > ans;
void solve() {
int i, j, l, r, lll;
gets(c);
s = c;
s1 = "";
for (i = s.size() - 1; i >= 0; i -= 1) {
s1 += s[i];
}
gets(c);
t = c;
lll = 0;
while (lll < t.size()) {
int ind1 = -1, ind2;
p = "";
for (i = lll; i < t.size(); i++) {
p += t[i];
}
for (i = 0; i < 6007; i++) {
z[i] = 0;
}
q = p;
q += '#';
q += s;
z[0] = 0;
l = 0;
r = 0;
for (i = 1; i < q.size(); i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
z[i] = max(0, z[i]);
while (i + z[i] < q.size() && q[i + z[i]] == q[z[i]]) {
z[i]++;
}
if (i > p.size() && (ind1 == -1 || z[i] > abs(ind1 - ind2)) &&
z[i] != 0) {
ind1 = i - p.size() - 1;
ind2 = i + z[i] - 1 - p.size() - 1;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
q = p;
q += '#';
q += s1;
z[0] = 0;
l = 0;
r = 0;
for (i = 0; i < 6007; i++) {
z[i] = 0;
}
for (i = 1; i < q.size(); i++) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
z[i] = max(0, z[i]);
while (i + z[i] < q.size() && q[i + z[i]] == q[z[i]]) {
z[i]++;
}
if (i > p.size() && (ind1 == -1 || z[i] > abs(ind1 - ind2)) &&
z[i] != 0) {
ind1 = i - p.size();
ind2 = i + z[i] - 1 - p.size();
ind1 = s.size() - ind1;
ind2 = s.size() - ind2;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
ans.push_back(make_pair(ind1, ind2));
if (ind1 == -1) {
printf("-1");
return;
}
lll += abs(ind1 - ind2) + 1;
}
i = 1;
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
int main() {
#pragma comment(linker, "/STACK:268435456")
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2105;
int neXt[MAXN];
void getNext(string s) {
int n = s.length();
neXt[0] = -1;
int k = -1, j = 0;
while (j < n) {
if (k == -1 || s[j] == s[k]) {
j++;
k++;
if (s[j] != s[k])
neXt[j] = k;
else
neXt[j] = neXt[k];
} else {
k = neXt[k];
}
}
}
int kmp(string s, string p) {
int i = 0, j = 0;
int m = s.length(), n = p.length();
while (i < m && j < n) {
if (j == -1 || s[i] == p[j])
i++, j++;
else
j = neXt[j];
}
if (j == n) return i - j;
return -1;
}
bool solve(string x, string y, vector<pair<int, int>>& ans) {
string z(x);
reverse(z.begin(), z.end());
int m = x.length();
int n = y.length();
int start = 0;
while (start < n) {
int l = 1, r = n - start, res = 0, pos = -1;
bool flg = true;
while (l <= r) {
int mid = (l + r) >> 1;
string tmp = y.substr(start, mid);
getNext(tmp);
int p = kmp(x, tmp);
if (p != -1) {
res = mid;
pos = p;
flg = true;
l = mid + 1;
} else if ((p = kmp(z, tmp)) != -1) {
res = mid;
pos = p;
flg = false;
l = mid + 1;
} else
r = mid - 1;
}
if (!res) return false;
if (flg)
ans.push_back(pair<int, int>(pos + 1, pos + res));
else
ans.push_back(pair<int, int>(m - pos, m - pos - res + 1));
start += res;
}
return true;
}
int main() {
string x, y;
cin >> x >> y;
vector<pair<int, int>> res;
if (solve(x, y, res)) {
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int poz;
bool directie;
} q;
vector<p> m[2101];
string s, ob;
int din[2110];
int main() {
cin >> s >> ob;
int l = s.size();
for (int i = 0; i < s.size(); i++) {
if (s[i] == ob[0]) {
q.poz = i;
q.directie = true;
m[0].push_back(q);
q.directie = false;
m[0].push_back(q);
}
}
din[0] = 1;
if (m[0].size() == 0) {
cout << "-1";
return 0;
}
for (int i = 1; i < ob.size(); i++) {
for (auto j : m[i - 1]) {
if (j.directie == 1 && j.poz + 1 < l && s[j.poz + 1] == ob[i]) {
q.poz = j.poz + 1;
q.directie = 1;
m[i].push_back(q);
}
if (j.directie == 0 && j.poz - 1 >= 0 && s[j.poz - 1] == ob[i]) {
q.poz = j.poz - 1;
q.directie = 0;
m[i].push_back(q);
}
}
din[i] = din[i - 1];
if (m[i].size() == 0) {
for (int z = 0; z < s.size(); z++) {
if (s[z] == ob[i]) {
q.poz = z;
q.directie = true;
m[i].push_back(q);
q.directie = false;
m[i].push_back(q);
}
}
din[i]++;
if (m[i].size() == 0) {
cout << "-1";
return 0;
}
}
}
cout << din[ob.size() - 1] << '\n';
int r[5000], c = 0;
int directie, poz;
for (int i = ob.size() - 1; i >= 0; i--) {
poz = m[i][0].poz;
if (m[i][0].directie)
directie = -1;
else
directie = 1;
r[c++] = poz;
while (i >= 0 && poz + directie >= 0 && poz + directie < l &&
s[poz + directie] == ob[i - 1]) {
poz += directie;
i--;
}
r[c++] = poz;
}
for (int i = c - 1; i >= 0; i -= 2)
cout << r[i] + 1 << ' ' << r[i - 1] + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans, n;
vector<pair<int, int> > vec;
string s, t;
int lcp1[5005][5005];
int lcp2[5005][5005];
void LCP(string &s, string &t, int lcp[5005][5005]) {
for (int i = (int)s.size() - 1; i >= 0; i--) {
for (int j = (int)t.size() - 1; j >= 0; j--) {
if (s[i] == t[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
} else {
lcp[i][j] = 0;
}
}
}
}
void solve() {
LCP(s, t, lcp1);
reverse(s.begin(), s.end());
LCP(s, t, lcp2);
for (int ti = 0; ti < t.size();) {
int mx1 = 0, mx1_si = -1;
int mx2 = 0, mx2_si = -1;
for (int si = 0; si < s.size(); si++) {
if (mx1 < lcp1[si][ti]) {
mx1 = lcp1[si][ti];
mx1_si = si;
}
if (mx2 < lcp2[si][ti]) {
mx2 = lcp2[si][ti];
mx2_si = si;
}
}
if (mx1 == 0 && mx2 == 0) {
ans = -1;
break;
} else if (mx1 >= mx2) {
ans++;
vec.push_back(pair<int, int>(mx1_si + 1, mx1_si + mx1 - 1 + 1));
ti += mx1;
} else {
ans++;
vec.push_back(pair<int, int>(n - mx2_si, n - (mx2_si + mx2 - 1)));
ti += mx2;
}
}
cout << ans << endl;
for (int i = 0; i < (ans); i++) {
cout << vec[i].first << " " << vec[i].second << endl;
}
}
int main() {
cin >> s;
cin >> t;
n = (int)s.size();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int in[maxn], in1[maxn];
int dp[maxn];
int dp1[maxn];
int dp2[maxn];
int s[maxn];
int vis[maxn];
int dp3[maxn];
vector<int> g[maxn];
int a[maxn];
int k;
int flag;
void dfs(int u, int pa) {
int p = g[u].size();
dp1[u] = 1;
vis[u] = 1;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
dfs(g[u][i], u);
dp1[u] = max(dp1[u], dp1[g[u][i]] + 1);
}
}
}
int pre[maxn], ou[maxn];
int nex[maxn];
void dfs1(int u, int pa) {
s[u] = 0;
if (in1[u] != in[u]) {
s[u] = 1;
}
int p = (int)g[u].size();
int ss = 0;
int s1 = 0;
int tot = 0;
int y = 0, q = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
dfs1(g[u][i], u);
if (flag) return;
if (s[g[u][i]] == 0) {
ss += dp[g[u][i]];
} else {
s1 = max(s1, dp[g[u][i]]);
s[u] = 1;
y++;
q = g[u][i];
}
}
}
dp[u] = ss + s1 + 1;
dp3[u] = ss;
if (dp[u] >= k) {
flag = 1;
}
if (y == 1 && in[u] == in1[u])
nex[u] = q;
else
nex[u] = 0;
dp2[u] = dp[u];
tot = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
if (tot == 0)
pre[tot] = dp[g[u][i]];
else
pre[tot] = max(pre[tot - 1], dp[g[u][i]]);
tot++;
}
}
int w = tot;
ou[w] = 0;
for (int i = p - 1; i >= 0; i--) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
w--;
ou[w] = max(ou[w + 1], dp[g[u][i]]);
}
}
int f = 0;
for (int i = 0; i < p; i++) {
if (g[u][i] != pa) {
if (s[g[u][i]] == 0) continue;
if (f == 0) {
dp2[u] = max(dp2[u], dp[g[u][i]] + ou[1] + ss + 1);
} else {
dp2[u] = max(dp2[u], dp[g[u][i]] + max(pre[f - 1], ou[f + 1]) + ss + 1);
}
dp2[u] = max(dp2[u], dp[g[u][i]] + ss + 1);
f++;
}
}
if (dp2[u] >= k) {
flag = 1;
return;
}
if (pa == -1) {
int p = u;
int s = 0;
while (nex[p]) {
s += dp3[p] + 1;
p = nex[p];
if (s + dp2[p] >= k) {
flag = 1;
return;
}
}
}
}
struct pi {
int a;
int b;
} pp[maxn];
int main() {
int i, n;
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &pp[i].a, &pp[i].b);
in[pp[i].a]++;
in[pp[i].b]++;
}
int le = 1, ri = 1000000, mid;
while (le <= ri) {
mid = (le + ri) / 2;
for (i = 1; i <= n; i++) {
g[i].clear();
vis[i] = 0;
in1[i] = 0;
}
for (i = 0; i < n - 1; i++) {
if (a[pp[i].a] < mid || a[pp[i].b] < mid) continue;
g[pp[i].a].push_back(pp[i].b);
g[pp[i].b].push_back(pp[i].a);
in1[pp[i].a]++;
in1[pp[i].b]++;
}
flag = 0;
for (i = 1; i <= n; i++) {
if (a[i] < mid) continue;
if (!vis[i]) {
dfs(i, -1);
dfs1(i, -1);
if (flag) {
break;
}
}
}
if (flag)
le = mid + 1;
else
ri = mid - 1;
}
printf("%d\n", ri);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct Edge {
int to;
int nxt;
} edge[MAXN << 1];
int n, k, id;
int first[MAXN];
int a[MAXN];
int fa[MAXN];
int f[MAXN];
int g[MAXN];
int sz[MAXN];
void addE(int u, int v) {
edge[++id] = (Edge){v, first[u]};
first[u] = id;
}
void dfsinfo(int u) {
sz[u] = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u]) {
fa[edge[i].to] = u;
dfsinfo(edge[i].to);
sz[u] += sz[edge[i].to];
}
}
void dfsf(int u, int lim) {
int MX = 0, sum = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
dfsf(edge[i].to, lim);
if (sz[edge[i].to] == f[edge[i].to])
sum += f[edge[i].to];
else
MX = max(MX, f[edge[i].to]);
}
f[u] = MX + sum;
}
void dfsg(int u, int lim) {
int MX1 = 0, MX2 = 0, sum = 1;
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
if (sz[edge[i].to] == f[edge[i].to])
sum += f[edge[i].to];
else if (f[edge[i].to] >= MX1) {
MX2 = MX1;
MX1 = f[edge[i].to];
} else if (f[edge[i].to] > MX2)
MX2 = f[edge[i].to];
}
if (n - sz[u] == g[u])
sum += g[u];
else if (g[u] >= MX1) {
MX2 = MX1;
MX1 = g[u];
} else if (g[u] > MX2)
MX2 = g[u];
for (int i = first[u]; i; i = edge[i].nxt)
if (edge[i].to != fa[u] && a[edge[i].to] >= lim) {
if (sz[edge[i].to] == f[edge[i].to])
g[edge[i].to] = sum - f[edge[i].to] + MX1;
else if (f[edge[i].to] == MX1)
g[edge[i].to] = sum + MX2;
else
g[edge[i].to] = sum + MX1;
dfsg(edge[i].to, lim);
}
}
int getans(int lim) {
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
if (a[1] >= lim) {
dfsf(1, lim);
dfsg(1, lim);
}
for (int i = 1; i <= n; i++)
if (a[i] < lim)
for (int j = first[i]; j; j = edge[j].nxt)
if (edge[j].to != fa[i] && a[edge[j].to] >= lim) {
dfsf(edge[j].to, lim);
dfsg(edge[j].to, lim);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < lim) continue;
int MX = 0, sum = 1;
for (int j = first[i]; j; j = edge[j].nxt)
if (a[edge[j].to] >= lim) {
int SZ = 0, FG = 0;
if (edge[j].to == fa[i]) {
SZ = n - sz[i];
FG = g[i];
} else {
SZ = sz[edge[j].to];
FG = f[edge[j].to];
}
if (FG == SZ)
sum += FG;
else
MX = max(MX, FG);
}
res = max(res, MX + sum);
}
return res;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int u, v, i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
addE(u, v);
addE(v, u);
}
dfsinfo(1);
int low = 1, high = 1000000;
while (low < high) {
int mid = low + high + 1 >> 1;
if (getans(mid) >= k)
low = mid;
else
high = mid - 1;
}
printf("%d\n", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tavan(int a, int b, int mod = ((int)1e9 + 7)) {
int res = 1;
while (b) {
res *= b % 2 ? a : 1;
res %= mod;
a *= a;
a %= mod;
b /= 2;
}
return res;
}
int n, k, a[((int)201 * 1000)], dp_down[((int)201 * 1000)],
dp_up[((int)201 * 1000)], dp[((int)201 * 1000)], ans;
vector<int> e[((int)201 * 1000)];
bool block[((int)201 * 1000)], mark[((int)201 * 1000)],
block_down[((int)201 * 1000)], block_up[((int)201 * 1000)];
void dfs_down(int x, int par = 0) {
block_down[x] = block[x];
dp_down[x] = 1;
int maxi = 0;
for (auto v : e[x])
if (v != par && !mark[v]) {
dfs_down(v, x);
block_down[x] |= block_down[v];
if (!block_down[v])
dp_down[x] += dp_down[v];
else
maxi = max(maxi, dp_down[v]);
}
dp_down[x] += maxi;
}
void dfs_up(int x, int par = 0) {
mark[x] = 1;
int sum = 0, block_num = block_up[x], id = 0;
int id1 = 0, id2 = 0, maxi = 0;
if (!block_up[x])
sum += dp_up[x];
else
maxi = dp_up[x];
for (auto v : e[x])
if (v != par && !mark[v]) {
if (block_down[v]) {
block_num++, id = v;
if (dp_down[v] > dp_down[id1])
id2 = id1, id1 = v;
else if (dp_down[v] > dp_down[id2])
id2 = v;
} else
sum += dp_down[v];
}
for (auto v : e[x])
if (v != par && !mark[v]) {
block_up[v] = (block_num >= 2 || (block_num == 1 && id != v));
if (block_down[v]) {
if (v != id1)
dp_up[v] = sum + max(maxi, dp_down[id1]);
else
dp_up[v] = sum + max(maxi, dp_down[id2]);
} else
dp_up[v] = sum - dp_down[v] + max(maxi, dp_down[id1]);
dp_up[v]++;
dfs_up(v, x);
}
ans = max(ans, sum + max(maxi, dp_down[id1]) + 1);
}
bool check(int x) {
for (int i = 1; i <= n; i++)
dp_down[i] = dp_up[i] = block_down[i] = block_up[i] = block[i] = mark[i] =
0;
for (int i = 1; i <= n; i++) {
if (a[i] < x) mark[i] = 1;
for (auto v : e[i])
if (a[v] < x) block[i] = 1;
}
for (int i = 1; i <= n; i++)
if (!mark[i]) {
ans = 0;
dfs_down(i);
dfs_up(i);
if (ans >= k) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
e[v].push_back(u);
e[u].push_back(v);
}
int l = 0, r = (int)1e7;
while (l < r - 1) {
int mid = l + r >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, sz[N], a[N], c, ret, dp[N];
pair<int, int> m[N][2];
vector<int> adj[N];
void dfs(int x, int p) {
int f = 0, u, i, d;
dp[x] = 0;
if (!sz[x]) f = 1, ++sz[x];
d = a[x] >= c ? 1 : 0;
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
dfs(u, x);
if (f) sz[x] += sz[u];
if (dp[u] == sz[u])
dp[x] += dp[u];
else {
if (m[x][0].first <= dp[u])
m[x][1] = m[x][0], m[x][0] = make_pair(dp[u], u);
else if (m[x][1].first < dp[u])
m[x][1] = make_pair(dp[u], u);
}
}
}
dp[x] += d + m[x][0].first;
if (d == 0) dp[x] = 0;
}
int ar[3];
void dfs2(int x, int p, int d) {
int v = 0, u, i, t = d, nd;
if (a[x] >= c) {
if (d == n - sz[x]) v = d, t = 0;
ar[0] = m[x][0].first, ar[1] = m[x][1].first, ar[2] = t;
sort(ar, ar + 3);
ret = max(ret, dp[x] + ar[2] + v - m[x][0].first);
}
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (u != p) {
nd = dp[x] - m[x][0].first + max(m[x][0].first, t) + v;
if (u == m[x][0].second)
nd = dp[x] - m[x][0].first + max(m[x][1].first, t) + v;
else if (sz[u] == dp[u])
nd -= sz[u];
if (a[x] < c) nd = 0;
dfs2(u, x, nd);
}
}
}
int main() {
int i, x, y, q, l, r, k, mid;
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 0; i < n - 1; ++i)
scanf("%d%d", &x, &y), adj[x].push_back(y), adj[y].push_back(x);
dfs(1, 0);
l = 1, r = 1e6;
while (l < r) {
mid = (l + r + 1) / 2;
c = mid;
memset(m, 0, sizeof(m));
ret = 0;
dfs(1, 0);
dfs2(1, 0, 0);
if (ret >= k)
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
std::vector<std::vector<int>> ch(200001);
std::vector<int> par(200001);
std::vector<std::vector<int>> nb(200001);
std::vector<std::vector<int>> lvl(200001);
std::vector<int> v_lvl(200001, 0);
std::vector<int> cost(200001, 0);
int l = 2;
long long d, n, m, k;
bool test(int mark) {
map<std::pair<int, int>, int> areal;
map<std::pair<int, int>, int> breal;
std::vector<int> a(n + 1, 0);
std::vector<int> asum(n + 1, 0);
std::vector<std::vector<int>> an(n + 1);
std::vector<std::vector<int>> bn(n + 1);
std::vector<int> b(n + 1, 0);
std::vector<int> bestb(n + 1, 0);
std::vector<int> best2b(n + 1, 0);
for (int i = l; i > 0; i--) {
for (auto v : lvl[i]) {
a[v] = 0;
b[v] = 0;
if (cost[v] < mark) {
continue;
}
bool f = true;
bestb[v] = 1;
for (auto u : ch[v]) {
if (a[u] > 0) {
b[v] += a[u];
an[v].push_back(a[u]);
} else {
bn[v].push_back(b[u]);
f = false;
if (b[u] + 1 >= bestb[v]) {
best2b[v] = bestb[v];
bestb[v] = b[u] + 1;
} else if (b[u] + 1 > best2b[v])
best2b[v] = b[u] + 1;
}
}
asum[v] = b[v];
b[v] += bestb[v];
if (f) a[v] = b[v];
}
}
for (int i = 2; i <= l; i++) {
for (auto v : lvl[i]) {
int u = par[v];
int wasa = a[v];
int wasb = b[v];
if (cost[v] < mark) {
continue;
}
if (cost[u] < mark) continue;
if (a[v] > 0) {
a[v] = a[u];
b[v] = b[u];
an[v].push_back(a[u] - a[v]);
} else if (bn[u].size() == 1) {
an[v].push_back(b[u] - b[v]);
b[v] = b[u];
asum[v] += asum[u] + 1;
} else {
sort((bn[u]).begin(), (bn[u]).end());
reverse((bn[u]).begin(), (bn[u]).end());
if (bn[u][0] > b[v]) {
bn[v].push_back(b[u]);
} else {
bn[v].push_back(b[u] - bn[u][0] + bn[u][1]);
}
int maxb = 0;
for (auto mm : bn[v]) maxb = max(maxb, mm);
b[v] = asum[v] + maxb + 1;
}
}
}
if (a[1] >= k) return true;
int maxb = 0;
for (int i = 1; i <= n; i++) maxb = max(maxb, b[i]);
return (maxb >= k);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> cost[i];
m = 1;
lvl[1].push_back(1);
v_lvl[1] = 1;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
nb[u].push_back(v);
nb[v].push_back(u);
}
while (m < n) {
for (int k = 0; k < lvl[l - 1].size(); k++) {
int v = lvl[l - 1][k];
for (int h = 0; h < nb[v].size(); h++) {
if (v_lvl[nb[v][h]] == 0) {
v_lvl[nb[v][h]] = l;
lvl[l].push_back(nb[v][h]);
m++;
ch[v].push_back(nb[v][h]);
par[nb[v][h]] = v;
}
}
}
l++;
}
l--;
std::vector<long long> lsize(l + 1);
for (int i = 1; i <= l; i++) lsize[i] = lvl[i].size();
int lm = 1;
int rm = 1000001;
while ((rm - lm) > 1) {
int mm = (lm + rm) / 2;
if (test(mm)) {
lm = mm;
} else {
rm = mm;
}
}
cout << lm;
}
|
#include <bits/stdc++.h>
const int N = 205000;
using namespace std;
int n, k, ar[N];
vector<int> g[N];
int BOUND;
int subsize[N], cbad[N], used[N];
void trace(int v) {
used[v] = 1;
subsize[v] = 1;
if (ar[v] < BOUND) cbad[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (used[to]) continue;
trace(to);
subsize[v] += subsize[to];
cbad[v] += cbad[to];
}
}
int best;
int solve(int v) {
used[v] = 1;
vector<int> good, bad;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (used[to]) continue;
int here = solve(to);
if (cbad[to] == 0)
good.push_back(here);
else
bad.push_back(here);
}
if (ar[v] < BOUND) return 0;
sort(good.begin(), good.end());
sort(bad.begin(), bad.end());
reverse(good.begin(), good.end());
reverse(bad.begin(), bad.end());
int res = 1;
for (int i = 0; i < good.size(); i++) res += good[i];
int memo = res;
for (int i = 0; i < 2 && i < bad.size(); i++) res += bad[i];
int bad_out = cbad[1] - cbad[v];
if (bad_out == 0) res += n - subsize[v];
best = max(best, res);
res = memo;
for (int i = 0; i < 1 && i < bad.size(); i++) res += bad[i];
return res;
}
bool check(int thold) {
BOUND = thold;
for (int i = 1; i <= n; i++) {
subsize[i] = cbad[i] = used[i] = 0;
}
trace(1);
best = 0;
for (int i = 1; i <= n; i++) used[i] = 0;
solve(1);
if (best >= k) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int l, r;
l = 0;
r = 1e9;
while (l < r) {
int mid = l + r + 1;
mid /= 2;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 5;
int n, a[N], x, y, l, r, mid, f[N], ans, k;
bool o[N];
vector<int> G[N];
void dfs(int x, int fa) {
int y, maxi = 0;
o[x] = f[x] = 1;
for (int i = 0; i < G[x].size(); i++)
if ((y = G[x][i]) != fa) {
dfs(y, x);
if (!o[y]) {
o[x] = 0;
maxi = max(maxi, f[y]);
} else
f[x] += f[y];
}
f[x] += maxi;
if (a[x] < mid) o[x] = f[x] = 0;
}
void dfs2(int x, int fa, int sum, bool o2) {
if (fa && a[fa] < mid) sum = o2 = 0;
int y, u = 0, v = 0, tot;
for (int i = 0; i < G[x].size(); i++)
if ((y = G[x][i]) != fa && !o[y]) {
if (f[y] > f[u])
v = u, u = y;
else if (f[y] > f[v])
v = y;
}
if (a[x] < mid)
o2 = 0;
else {
tot = f[x] - f[u];
if (o2)
tot += sum;
else
tot += max(sum, f[u]);
ans = max(ans, tot);
}
for (int i = 0; i < G[x].size(); i++)
if ((y = G[x][i]) != fa) {
tot = f[x] - f[y] - f[u];
if (o2) tot += sum;
if (y == u) {
tot += f[u];
if (!o2)
tot += max(f[v], sum);
else
tot += f[v];
dfs2(y, x, tot, o2 & (v == 0));
} else if (y == v) {
if (!o2)
tot += max(f[u], sum);
else
tot += f[u];
dfs2(y, x, tot, 0);
} else {
if (!o2)
tot += max(f[u], sum);
else
tot += f[u];
dfs2(y, x, tot, o2 & (u == 0));
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), r = max(r, a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
r++;
while (l < r) {
mid = (l + r) / 2;
dfs(1, 0);
ans = 0;
dfs2(1, 0, 0, 1);
if (ans < k)
r = mid;
else
l = mid + 1;
}
cout << l - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, a[1000010], k;
vector<int> G[1000010];
int fa[1000010], siz[1000010], anss[1000010];
bool can_use[1000010], used[1000010];
void find_root(int x) {
for (int i = 0; i < G[x].size(); i++) {
if (fa[G[x][i]] == 0) {
fa[G[x][i]] = x;
find_root(G[x][i]);
}
}
return;
}
void find_size(int x) {
int ret = 0;
for (int i = 0; i < G[x].size(); i++) {
if (G[x][i] != fa[x]) {
find_size(G[x][i]);
ret += siz[G[x][i]];
}
}
siz[x] = ret + 1;
return;
}
int ans = 0;
void get_anss_of_root(int x) {
anss[x] = 1;
int max1 = 0;
int max2 = 0;
for (int i = 0; i < G[x].size(); i++) {
if (G[x][i] != fa[x]) {
get_anss_of_root(G[x][i]);
if (anss[G[x][i]] == siz[G[x][i]])
anss[x] += anss[G[x][i]];
else {
if (anss[G[x][i]] > max1) swap(anss[G[x][i]], max1);
if (anss[G[x][i]] > max2) swap(anss[G[x][i]], max2);
}
}
}
if (!can_use[x]) {
anss[x] = 0;
return;
}
anss[x] += max1;
ans = max(anss[x] + max2, ans);
return;
}
int rt = 1;
int judge(int x) {
ans = 0;
for (int i = 1; i <= n; i++) can_use[i] = (a[i] >= x), anss[i] = -1;
get_anss_of_root(rt);
return ans >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
int minn = 1000001;
for (int i = 1; i <= n; i++)
if (a[i] < minn) minn = a[i], rt = i;
fa[rt] = -1;
find_root(rt);
find_size(rt);
int L = 1, R = 1000000, mid = 500000;
while (L <= R) {
mid = (L + R) >> 1;
if (judge(mid))
L = mid + 1;
else
R = mid - 1;
}
printf("%d\n", L - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mid, rt, res, a[200010], f[200010], sz[200010];
vector<int> e[200010];
void dfs(int u, int fa) {
f[u] = sz[u] = 1;
int m1 = 0, m2 = 0;
for (auto v : e[u]) {
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
if (f[v] == sz[v])
f[u] += f[v];
else {
if (f[v] > m1) swap(f[v], m1);
if (f[v] > m2) swap(f[v], m2);
}
}
f[u] = a[u] < mid ? 0 : f[u] + m1;
res = max(res, f[u] + m2);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
rt = min_element(a + 1, a + 1 + n) - a;
int l = 0, r = 1000010, ans;
while (l <= r) {
mid = (l + r) >> 1;
res = 0;
dfs(rt, 0);
if (res >= m)
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt[200010 << 1], to[200010 << 1], head[200010], cnt;
void add(int u, int v) {
nxt[++cnt] = head[u];
to[cnt] = v;
head[u] = cnt;
}
int f[200010], siz[200010], fa[200010], val[200010];
void pre(int u, int p) {
siz[u] = 1;
fa[u] = p;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == p) continue;
pre(v, u);
siz[u] += siz[v];
}
}
int dn[200010], maxn;
void dfs(int u, int x) {
dn[u] = 1;
int res = 0, r2 = 0;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa[u]) continue;
dfs(v, x);
if (dn[v] == siz[v])
dn[u] += siz[v];
else if (res < dn[v])
r2 = res, res = dn[v];
else
r2 = max(r2, dn[v]);
}
dn[u] += res;
if (val[u] < x) dn[u] = 0;
maxn = max(maxn, dn[u] + r2);
}
int main() {
int n, m = 0, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]), m = max(m, val[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v), add(v, u);
}
int rt = min_element(val + 1, val + n + 1) - val;
pre(rt, 0);
int l = 1, r = m, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
maxn = 0;
dfs(rt, mid);
if (maxn >= k)
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010];
struct Lfs {
int to, nxt;
} t[200010 * 2];
int head[200010], cnt;
void add(int x, int y) {
t[cnt].to = y;
t[cnt].nxt = head[x];
head[x] = cnt++;
}
int sz[200010];
void dfs(int x, int fa) {
sz[x] = 1;
for (int i = head[x]; ~i; i = t[i].nxt) {
int v = t[i].to;
if (v == fa) continue;
dfs(v, x);
sz[x] += sz[v];
}
}
bool tag[200010];
int js, ans, n, k;
int f[200010];
int sum[200010];
void dfs2(int x, int fa) {
if (ans >= k) return;
int max1 = 0, max2 = 0, all = 0;
for (int i = head[x]; ~i; i = t[i].nxt) {
int v = t[i].to;
if (v == fa) continue;
dfs2(v, x);
sum[x] += sum[v];
if (f[v] == sz[v]) {
all += sz[v];
} else if (max1 < f[v]) {
max2 = max1, max1 = f[v];
} else if (max2 < f[v]) {
max2 = f[v];
}
}
if (!tag[x]) {
f[x] = 0;
} else {
f[x] = all + max1 + 1;
++sum[x];
}
if (n - sz[x] == js - sum[x]) {
all += n - sz[x];
}
if (tag[x]) {
ans = max(ans, all + max1 + max2 + 1);
}
}
void check(int v) {
memset(sum, 0, sizeof(sum));
memset(tag, false, sizeof(tag));
ans = js = 0;
for (int i = 1; i <= n; ++i) {
tag[i] = a[i] >= v;
js += tag[i];
}
dfs2(1, -1);
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, -1);
int l = 0, r = 0x3f3f3f3f;
while (l <= r) {
int mid = (((l) + (r)) / 2);
check(mid);
if (ans >= k) {
l = mid + 1;
} else
r = mid - 1;
}
printf("%d\n", r);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, k, head[maxn], tot, siz[maxn], w[maxn], a[maxn], f[maxn], ans;
bool flag, b[maxn];
struct node {
int nxt, to;
} edge[maxn << 1];
int max(int a, int b) {
if (a >= b) return a;
return b;
}
int min(int a, int b) {
if (a <= b) return a;
return b;
}
int read() {
int x = 0;
char c = getchar();
while (c < 48 || c > 57) c = getchar();
while (c >= 48 && c <= 57) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x;
}
void dfs1(int u, int fa) {
int i, v;
siz[u] = 1;
for (i = head[u]; i; i = edge[i].nxt) {
v = edge[i].to;
if (v == fa) continue;
dfs1(v, u);
siz[u] += siz[v];
w[u] += w[v];
}
}
void dfs2(int u, int fa, int m) {
int i, v, max1 = 0, max2 = 0, cnt = 0;
for (i = head[u]; i; i = edge[i].nxt) {
v = edge[i].to;
if (v == fa) continue;
if (b[u] && siz[u] - siz[v] == w[u] - w[v]) b[v] = 1;
dfs2(v, u, m);
if (a[v] < m) continue;
if (siz[v] == w[v])
cnt += siz[v];
else {
if (f[v] >= max1)
max2 = max1, max1 = f[v];
else if (f[v] > max2)
max2 = f[v];
}
}
if (a[u] < m) return;
f[u] = cnt + max1 + 1;
if (f[u] + max2 + b[u] * (n - siz[u]) >= k) flag = 1;
}
void add(int u, int v) {
edge[++tot] = (node){head[u], v};
head[u] = tot;
}
bool chck(int x) {
memset(f, 0, sizeof(f));
memset(b, 0, sizeof(b));
memset(siz, 0, sizeof(siz));
memset(w, 0, sizeof(w));
int i;
for (i = 1; i <= n; i++) w[i] = (a[i] >= x);
dfs1(1, 0);
flag = 0;
b[1] = w[1];
dfs2(1, 0, x);
return flag;
}
int main() {
int i, u, v, l = 10000000, r = 0, mid;
n = read(), k = read();
for (i = 1; i <= n; i++) a[i] = read(), l = min(l, a[i]), r = max(r, a[i]);
for (i = 1; i <= n - 1; i++) {
u = read(), v = read();
add(u, v);
add(v, u);
}
while (l <= r) {
mid = (l + r) >> 1;
if (chck(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 212345;
vector<int> adj[MAXN];
int a[MAXN];
int n, k;
int st[MAXN];
int ed[MAXN];
int P[MAXN];
int order[MAXN];
int o_idx = 1;
void dfs(int node, int par) {
P[node] = par;
st[node] = o_idx;
order[o_idx++] = node;
for (int i = 0; i < (int)adj[node].size(); i++) {
int v = adj[node][i];
if (v != par) {
dfs(v, node);
}
}
ed[node] = o_idx - 1;
}
int memo[MAXN];
int hasZero[MAXN];
bool check(int mn) {
memset(memo, 0, sizeof memo);
memset(hasZero, 0, sizeof hasZero);
bool ok = 0;
for (int node_id = n; node_id > 0; node_id--) {
int node = order[node_id];
if (a[node] < mn) {
memo[node] = 0;
hasZero[node] = 1;
} else {
memo[node] = 1;
vector<int> zeros;
for (int i = 0; i < (int)adj[node].size(); i++) {
int v = adj[node][i];
if (v != P[node]) {
if (hasZero[v]) {
zeros.push_back(memo[v]);
sort(zeros.rbegin(), zeros.rend());
if (zeros.size() == 3) zeros.pop_back();
} else {
memo[node] += memo[v];
}
}
}
if (zeros.size()) {
memo[node] += zeros[0];
hasZero[node] = 1;
if (zeros.size() == 2) {
if (memo[node] + zeros[1] >= k) ok = 1;
}
}
if (memo[node] >= k) ok = 1;
}
}
return ok;
}
int solve() {
int l = 1, r = 1000000;
while (l <= r) {
int md = (l + r) >> 1;
if (check(md)) {
l = md + 1;
} else {
r = md - 1;
}
}
return l - 1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int ans = 0;
srand(time(0));
for (int it = 0; it < 10; it++) {
int r = rand() % n + 1;
o_idx = 1;
dfs(r, 0);
ans = max(ans, solve());
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int A[200036], o[200036];
vector<int> G[200036];
int dp[200036], mx[200036], sd[200036], siz[200036], sz[200036];
void dfs(int u, int f) {
siz[u] = o[u], sz[u] = 1;
dp[u] = o[u];
mx[u] = sd[u] = 0;
vector<int> tr;
for (int v : G[u])
if (v != f) {
dfs(v, u);
siz[u] += siz[v], sz[u] += sz[v];
if (o[u]) {
if (siz[v] == sz[v])
dp[u] += dp[v];
else {
if (dp[v] > mx[u])
sd[u] = mx[u], mx[u] = dp[v];
else if (dp[v] > sd[u])
sd[u] = dp[v];
}
}
}
dp[u] = dp[u] + mx[u];
}
void pfs(int u, int f) {
if (u != 1 && o[u]) {
if (siz[u] == sz[u])
dp[u] = (o[f] ? dp[f] : dp[u]);
else if (siz[1] - siz[u] == sz[1] - sz[u])
dp[u] += siz[1] - siz[u];
else {
int df = 0;
if (dp[u] == mx[f])
df = dp[f] - dp[u] + sd[f];
else
df = dp[f];
if (df > mx[u]) dp[u] = dp[u] - mx[u] + df;
if (df > mx[u])
sd[u] = mx[u], mx[u] = df;
else if (df > sd[u])
sd[u] = df;
}
}
for (int v : G[u])
if (v != f) pfs(v, u);
}
int chk(int x) {
for (int i = (1), iend = (n); i <= iend; ++i) o[i] = A[i] >= x;
dfs(1, 1);
pfs(1, 1);
return *max_element(dp + 1, dp + 1 + n);
}
void solve() {
cin >> n >> k;
for (int i = (1), iend = (n); i <= iend; ++i) scanf("%d", A + i);
for (int i = (2), iend = (n); i <= iend; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
int l = 0, r = 1e6;
while (r >= l) {
int mid = l + r >> 1;
if (chk(mid) >= k)
l = mid + 1;
else
r = mid - 1;
}
cout << r << endl;
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
vector<string> _split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return v;
}
void _print(vector<string>::iterator) {}
template <typename T, typename... Args>
void _print(vector<string>::iterator it, T a, Args... args) {
string name = it->substr((*it)[0] == ' ', it->length());
if (isalpha(name[0]))
cerr << name << " = " << a << " ";
else
cerr << name << " ";
_print(++it, args...);
}
const int N = (int)3e5;
int n, k;
vector<int> graph[N];
int a[N];
int lim;
int good_cnt[N];
int tree_size[N];
int dp[N];
int ans;
void calc_is_good(int v, int p) {
tree_size[v] = 1;
good_cnt[v] = (a[v] >= lim);
for (int to : graph[v]) {
if (to != p) {
calc_is_good(to, v);
tree_size[v] += tree_size[to];
good_cnt[v] += good_cnt[to];
}
}
}
void calc_dp(int v, int p) {
for (int to : graph[v])
if (to != p) calc_dp(to, v);
if (a[v] < lim) {
dp[v] = 0;
return;
}
if (good_cnt[v] == tree_size[v]) {
dp[v] = tree_size[v];
return;
}
dp[v] = 1;
int mx = 0;
for (int to : graph[v]) {
if (to == p) continue;
if (good_cnt[to] == tree_size[to])
dp[v] += tree_size[to];
else
mx = max(mx, dp[to]);
}
dp[v] += mx;
}
void calc_ans(int v, int p, int up_good_cnt, int up_dp) {
if (a[v] < lim) {
for (int to : graph[v]) {
if (to == p) continue;
calc_ans(to, v, 0, 0);
}
return;
}
multiset<int> dp_s;
dp_s.insert(0);
dp_s.insert(0);
int up_tree_size = n - tree_size[v];
int v_good_cnt = 1;
int cur_ans = 1;
v_good_cnt += up_good_cnt;
if (up_tree_size == up_good_cnt)
cur_ans += up_tree_size;
else
dp_s.insert(up_dp);
for (int to : graph[v]) {
if (to == p) continue;
v_good_cnt += good_cnt[to];
if (good_cnt[to] == tree_size[to])
cur_ans += tree_size[to];
else
dp_s.insert(dp[to]);
}
int base_ans = cur_ans;
auto it = dp_s.end();
for (int i = 0; i < 2; i++) {
it--;
cur_ans += (*it);
}
ans = max(ans, cur_ans);
for (int to : graph[v]) {
if (to == p) continue;
int new_up_good_cnt = v_good_cnt - good_cnt[to];
int to_dp = base_ans;
if (good_cnt[to] == tree_size[to])
to_dp -= good_cnt[to];
else
dp_s.erase(dp_s.find(dp[to]));
to_dp += *dp_s.rbegin();
calc_ans(to, v, new_up_good_cnt, to_dp);
if (good_cnt[to] != tree_size[to]) dp_s.insert(dp[to]);
}
}
bool solve(int _lim) {
lim = _lim;
calc_is_good(0, -1);
calc_dp(0, -1);
ans = 0;
calc_ans(0, -1, 0, 0);
return ans >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int v1, v2;
scanf("%d%d", &v1, &v2);
v1--;
v2--;
graph[v1].push_back(v2);
graph[v2].push_back(v1);
}
int l = 0;
int r = (int)1e6 + 10;
while (r - l > 1) {
int m = (l + r) / 2;
if (solve(m))
l = m;
else
r = m;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;
const int maxn = 200005;
int maxd[maxn], maxd2[maxn], sum[maxn], ans[maxn], badfull[maxn];
vector<int> gr[maxn];
int a[maxn];
int mina;
bool poss;
int n, k;
void calcdown(int cur, int pr) {
maxd[cur] = 0;
maxd2[cur] = 0;
sum[cur] = a[cur] >= mina;
badfull[cur] = 0;
ans[cur] = a[cur] >= mina;
for (auto x : gr[cur])
if (x != pr) {
calcdown(x, cur);
if (badfull[x] == 0)
sum[cur] += ans[x];
else {
badfull[cur]++;
if (ans[x] > maxd[cur]) {
maxd2[cur] = maxd[cur];
maxd[cur] = ans[x];
} else if (ans[x] > maxd2[cur]) {
maxd2[cur] = ans[x];
}
}
}
if (badfull[cur] == 0)
ans[cur] = sum[cur];
else
ans[cur] = sum[cur] + maxd[cur];
if (a[cur] < mina) {
badfull[cur] = 1;
ans[cur] = 0;
}
}
void go(int cur, int pr, bool canfullup, int ansup) {
if (poss) return;
if (canfullup)
sum[cur] += ansup;
else {
badfull[cur]++;
if (ansup > maxd[cur]) {
maxd2[cur] = maxd[cur];
maxd[cur] = ansup;
} else if (ansup > maxd2[cur]) {
maxd2[cur] = ansup;
}
}
if (a[cur] >= mina) {
int answer = 0;
if (badfull[cur] == 0)
answer = sum[cur];
else
answer = sum[cur] + maxd[cur];
if (answer >= k) {
poss = true;
return;
}
}
for (auto x : gr[cur])
if (x != pr) {
if (a[cur] < mina)
go(x, cur, false, 0);
else {
if (badfull[x] == 0) {
if (badfull[cur] == 0)
go(x, cur, true, sum[cur] - sum[x]);
else
go(x, cur, false, sum[cur] - sum[x] + maxd[cur]);
} else {
if (badfull[cur] == 1)
go(x, cur, true, sum[cur]);
else {
if (maxd[cur] == ans[x])
go(x, cur, false, sum[cur] + maxd2[cur]);
else
go(x, cur, false, sum[cur] + maxd[cur]);
}
}
}
}
}
bool can(int b) {
mina = b;
poss = false;
calcdown(0, -1);
go(0, -1, true, 0);
return poss;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
gr[a].push_back(b);
gr[b].push_back(a);
}
int l = 1;
int r = 1000001;
while (r - l > 1) {
int m = (l + r) / 2;
if (can(m))
l = m;
else
r = m;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[210000];
vector<int> wt[210000];
vector<int> dp[210000];
vector<pair<int, int> > adj[210000];
int n, k;
pair<int, int> totwt[210000][2];
int full[210000];
pair<int, int> notfull[210000][2];
int state[210000];
int rec(int v, int p, int goal);
void upd(int follow_idx, int v, int goal) {
int newv = adj[v][follow_idx].first;
int newp = adj[v][follow_idx].second;
rec(newv, newp, goal);
if (wt[newv][newp] >= goal) {
full[v] += dp[newv][newp];
} else {
if (notfull[v][1].second < dp[newv][newp])
notfull[v][1] = {dp[newv][newp], follow_idx};
if (notfull[v][0] < notfull[v][1]) swap(notfull[v][0], notfull[v][1]);
}
if (totwt[v][1].first > wt[newv][newp])
totwt[v][1] = {wt[newv][newp], follow_idx};
if (totwt[v][0] > totwt[v][1]) swap(totwt[v][0], totwt[v][1]);
}
int rec(int v, int p, int goal) {
int &ret = dp[v][p];
if (ret != -1) return ret;
if (val[v] < goal) return ret = 0;
if (state[v] == -1) {
for (int i = 1; i < (int)adj[v].size(); i++)
if (i != p) {
upd(i, v, goal);
}
state[v] = p;
} else if (state[v] && state[v] != p) {
upd(state[v], v, goal);
state[v] = 0;
}
wt[v][p] = (totwt[v][0].second != p ? totwt[v][0].first : totwt[v][1].first);
wt[v][p] = min(wt[v][p], val[v]);
ret = 1 + full[v] + notfull[v][0].first;
if (state[v] != p) {
if (notfull[v][0].second == p)
ret += (notfull[v][1].first - notfull[v][0].first);
if (wt[adj[v][p].first][adj[v][p].second] >= goal)
ret -= dp[adj[v][p].first][adj[v][p].second];
}
return ret;
}
bool check(int goal) {
for (int i = 1; i <= n; i++) {
state[i] = -1;
full[i] = 0;
notfull[i][0] = notfull[i][1] = {0, -1};
totwt[i][0] = totwt[i][1] = {1000000000, -1};
for (int j = 0; j < (int)adj[i].size(); j++) {
dp[i][j] = -1;
}
}
for (int i = 1; i <= n; i++) {
if (rec(i, 0, goal) >= k) return true;
}
return false;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= n; i++) adj[i].push_back({-1, -1});
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
int uT = adj[u].size();
int vT = adj[v].size();
adj[u].push_back({v, vT});
adj[v].push_back({u, uT});
}
for (int i = 0; i <= n; i++) {
wt[i].resize(adj[i].size(), -1);
dp[i].resize(adj[i].size(), -1);
}
int st = 0, ed = 1000000;
while (st < ed) {
int md = (st + ed + 1) / 2;
if (check(md))
st = md;
else
ed = md - 1;
}
printf("%d\n", st);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool readInteger(T& x) {
char c, r = 0, n = 0;
x = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r))
return (0);
else if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
x = x * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) x = -x;
return (1);
}
template <typename T, T MOD>
struct ModInt {
T value;
ModInt() : value(0) {}
ModInt(T x) {
x %= MOD;
if (x < 0) x += MOD;
value = x;
}
private:
T __________________(T ___, T ____) {
if (!____) return ___;
return __________________(____, ___ % ____);
}
T _____________(T _, T __, T ____, T ___) {
T _____, ______, _______ = ____ - _;
assert(!(_______ % __________________(__, ___)));
for (_____ = ______ = 0; _____ - ______ != _______;) {
_____ = (_______ + ______ + __ - 1) / __ * __;
______ = (_____ - _______ + ___ - 1) / ___ * ___;
}
return _____ + _;
}
public:
ModInt& operator+=(ModInt x) {
value += x.value;
if (value >= MOD) value -= MOD;
return *this;
}
ModInt& operator-=(ModInt x) {
value -= x.value;
if (value < 0) value += MOD;
return *this;
}
ModInt& operator*=(ModInt x) {
value *= x.value;
value %= MOD;
return *this;
}
ModInt& operator/=(ModInt x) {
x.invert();
return *this *= x;
}
ModInt operator+(ModInt x) const {
ModInt o = *this;
o += x;
return o;
}
ModInt operator-(ModInt x) const {
ModInt o = *this;
o -= x;
return o;
}
ModInt operator*(ModInt x) const {
ModInt o = *this;
o *= x;
return o;
}
ModInt operator/(ModInt x) const {
ModInt o = *this;
o /= x;
return o;
}
bool operator==(ModInt x) const { return value == x.value; }
bool operator!=(ModInt x) const { return !(*this == x); }
ModInt operator-() const { return ModInt(0) - *this; }
ModInt operator^(long long x) const {
ModInt ret = 1;
ModInt mul = *this;
while (x) {
if (x & 1) ret *= mul;
mul *= mul;
x >>= 1;
}
return ret;
}
ModInt& operator^=(long long x) { return *this = *this ^ x; }
private:
void invert() { *this ^= MOD - 2; }
public:
void answer() { std::cout << value << std::endl; }
};
const int MX = 2.1e5;
int N, K;
int ai[MX];
vector<int> E[MX];
vector<int> child[MX];
bool light[MX];
long long dp[MX][5];
const int NINF = -1e9;
void solve(int x) {
for (auto& o : (child[x])) solve(o);
long long useNow = NINF;
{
long long& ans = dp[x][4];
ans = NINF;
if (light[x]) {
{
long long sum = 1;
long long bestDelta = 0;
for (auto& o : (child[x])) {
sum += dp[o][3];
bestDelta = max(bestDelta, dp[o][4] - dp[o][3]);
}
sum += bestDelta;
ans = max(ans, sum);
}
{
long long sum = 1;
long long bestA = 0;
long long bestB = 0;
for (auto& o : (child[x])) {
long long v1 = max(0LL, dp[o][3]);
long long v2 = dp[o][2];
sum += v1;
long long delta = v2 - v1;
if (delta > bestA) {
bestB = bestA;
bestA = delta;
} else
bestB = max(bestB, delta);
}
useNow = sum + bestA + bestB;
ans = max(ans, useNow);
}
}
}
{
long long& ans = dp[x][3];
ans = NINF;
if (light[x]) {
long long sum = 1;
for (auto& o : (child[x])) sum += dp[o][3];
ans = max(ans, sum);
}
}
{
long long& ans = dp[x][2];
ans = NINF;
if (light[x]) {
long long sum = 1;
long long bestDelta = 0;
for (auto& o : (child[x])) {
long long v1 = max(0LL, dp[o][3]);
long long v2 = dp[o][2];
sum += v1;
bestDelta = max(bestDelta, v2 - v1);
}
sum += bestDelta;
ans = max(ans, sum);
}
}
{
long long& ans = dp[x][1];
ans = useNow;
for (auto& o : (child[x])) ans = max(ans, dp[o][1]);
}
}
int ROOT = 0;
bool ok(int threshold) {
for (int i = (0); i < int(N); i++) light[i] = ai[i] >= threshold;
if (light[ROOT]) return true;
solve(ROOT);
return dp[ROOT][1] >= K;
}
void init(int x, int par) {
for (auto& o : (E[x]))
if (o != par) {
child[x].push_back(o);
init(o, x);
}
}
int main() {
readInteger(N);
readInteger(K);
for (int i = (0); i < int(N); i++) readInteger(ai[i]);
for (int k = (0); k < int(N - 1); k++) {
int u, v;
readInteger(u);
readInteger(v);
--u, --v;
E[u].push_back(v);
E[v].push_back(u);
}
for (int i = (0); i < int(N); i++)
if (ai[i] < ai[ROOT]) ROOT = i;
init(ROOT, -1);
vector<int> vals(N);
for (int i = (0); i < int(N); i++) vals[i] = ai[i];
sort(vals.begin(), vals.end());
reverse(vals.begin(), vals.end());
int lo = K - 1;
int hi = N - 1;
while (lo != hi) {
int mid = (lo + hi) / 2;
if (ok(vals[mid]))
hi = mid;
else
lo = mid + 1;
}
printf("%d\n", vals[lo]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000001;
const long long int LLINF = 1000000000000000001LL;
void dfs(int v, int par, vector<vector<int> > &G, vector<bool> &good,
vector<int> &ansDown, vector<int> &sub, vector<int> &goodInSub,
vector<int> &p) {
p[v] = par;
int sumGoodSubs = 0;
for (int u : G[v])
if (u != par) {
dfs(u, v, G, good, ansDown, sub, goodInSub, p);
goodInSub[v] += goodInSub[u];
sub[v] += sub[u];
if (goodInSub[u] == sub[u]) {
sumGoodSubs += sub[u];
}
}
if (good[v]) {
for (int u : G[v])
if (u != par) {
int restGoodSubs = sumGoodSubs - (goodInSub[u] == sub[u]) * sub[u];
ansDown[v] = max(ansDown[v], ansDown[u] + 1 + restGoodSubs);
}
}
}
int solve(vector<vector<int> > &G, vector<bool> &good) {
int n = (int)(G).size();
vector<int> ansDown(n), sub(n, 1), par(n), goodInSub(n);
for (int i = (0); i <= (n - 1); ++i) ansDown[i] = goodInSub[i] = good[i];
dfs(0, -1, G, good, ansDown, sub, goodInSub, par);
int allGood = 0;
for (int i = (0); i <= (n - 1); ++i) allGood += good[i];
vector<int> up(n);
for (int i = (0); i <= (n - 1); ++i) {
int upGood = allGood - goodInSub[i];
if (upGood == n - sub[i]) {
up[i] = upGood;
} else {
up[i] = 0;
}
}
int ans = 0;
for (int i = (0); i <= (n - 1); ++i) ans = max(ans, ansDown[i] + up[i]);
for (int v = (0); v <= (n - 1); ++v)
if (good[v]) {
int sumGoodSubs = 0;
for (int u : G[v])
if (u != par[v] && (goodInSub[u] == sub[u])) {
sumGoodSubs += sub[u];
}
int bestSoFar = 0;
for (int u : G[v])
if (u != par[v]) {
int change = ansDown[u] - (goodInSub[u] == sub[u]) * sub[u];
ans = max(ans, up[v] + 1 + bestSoFar + change);
bestSoFar = max(bestSoFar, sumGoodSubs + change);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<int> T(n);
for (int i = (0); i <= (n - 1); ++i) cin >> T[i];
vector<vector<int> > G(n);
for (int i = (1); i <= (n - 1); ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
const int MAXA = 1000002;
int L = 0, R = MAXA;
while (R - L > 1) {
int mid = (L + R) / 2;
vector<bool> good(n);
for (int i = (0); i <= (n - 1); ++i) good[i] = (T[i] >= mid);
if (solve(G, good) >= k)
L = mid;
else
R = mid;
}
cout << L;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 18);
vector<int> v[MX];
int n, K;
int bad[MX], V[MX], par[MX];
int fakss[MX], good[MX], mx[MX];
void Pdfs(int x, int p) {
good[x] = 1;
int maxy = 0;
for (auto nxt : v[x]) {
if (nxt == p) continue;
Pdfs(nxt, x);
par[nxt] = x;
fakss[x] |= fakss[nxt];
if (fakss[nxt])
maxy = max(maxy, good[nxt]);
else
good[x] += good[nxt];
}
good[x] += maxy;
mx[x] = maxy;
if (bad[x]) good[x] = mx[x] = 0;
}
bool nk7 = 0;
void dfs(int x, int flag, int cnt) {
int G = good[x] - mx[x];
if (flag == 0) {
G += cnt;
G += mx[x];
} else
G += max(mx[x], cnt);
if (G >= K) nk7 = 1;
int nflag = flag, cc = 0, ncnt, Good = 0, pp[2] = {0, 0};
for (auto nxt : v[x]) {
if (nxt == par[x]) continue;
cc += fakss[nxt];
if (!fakss[nxt])
Good += good[nxt];
else {
pp[1] = max(pp[1], good[nxt]);
if (pp[1] > pp[0]) swap(pp[1], pp[0]);
}
}
for (auto nxt : v[x]) {
if (nxt == par[x]) continue;
cc -= fakss[nxt];
if (!fakss[nxt]) Good -= good[nxt];
nflag = flag ? flag : cc;
ncnt = Good;
int op = pp[0];
if (fakss[nxt] && good[nxt] == pp[0]) op = pp[1];
if (!flag) {
ncnt += cnt;
ncnt += op;
} else
ncnt += max(op, cnt);
if (bad[x]) {
nflag = 1;
ncnt = 0;
} else
ncnt++;
dfs(nxt, nflag, ncnt);
cc += fakss[nxt];
if (!fakss[nxt]) Good += good[nxt];
}
}
bool check(int X) {
for (int j = 1; j <= n; j++) {
if (V[j] >= X)
bad[j] = fakss[j] = 0;
else
bad[j] = fakss[j] = 1;
}
nk7 = 0;
Pdfs(1, -1);
dfs(1, 0, 0);
return nk7;
}
int main() {
scanf("%d %d", &n, &K);
for (int j = 1; j <= n; j++) scanf("%d", &V[j]);
for (int j = 1; j < n; j++) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
int st = 1, en = *max_element(V + 1, V + 1 + n), mid, ans;
while (st <= en) {
mid = (st + en) / 2;
if (check(mid)) {
ans = mid;
st = mid + 1;
} else
en = mid - 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[500001];
scanf("%s", ch);
return ch;
}
const long long MAX_N = 2e5 + 10;
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
vector<long long> g[MAX_N];
bool del[MAX_N], forb[MAX_N], mark[MAX_N];
long long a[MAX_N], dp[MAX_N], ln, vl[MAX_N], deg[MAX_N];
queue<long long> Bomb;
long long n, k;
inline void BombProcess() {
for (long long i = 1; i <= n; i++)
if (deg[i] == 1 && !forb[i]) Bomb.push(i);
while (Bomb.size()) {
long long first = Bomb.front();
Bomb.pop();
deg[first]--;
del[first] = true;
long long FIND = -1;
for (auto u : g[first]) {
if (!del[u] && !forb[u]) {
FIND = u;
break;
}
}
if (FIND != -1) {
vl[FIND] += vl[first];
deg[FIND]--;
if (deg[FIND] == 1) Bomb.push(FIND);
}
ln = max(ln, vl[first]);
vl[first] = 0;
}
}
inline void dfs(long long v, long long pr = -1) {
mark[v] = true;
long long f = 0, s = 0;
dp[v] = vl[v];
for (auto u : g[v]) {
if (pr == u || forb[u]) continue;
dfs(u, v);
if (dp[u] > f) {
s = f;
f = dp[u];
} else
s = max(s, dp[u]);
}
ln = max(ln, dp[v] + f + s);
dp[v] += f;
}
inline bool can(long long low) {
ln = 0;
for (long long i = 1; i <= n; i++) {
mark[i] = 0;
deg[i] = g[i].size();
dp[i] = 0;
del[i] = 0;
mark[i] = 0;
vl[i] = 1;
forb[i] = (a[i] < low);
}
BombProcess();
for (long long i = 1; i <= n; i++) {
if (!mark[i] && !forb[i]) dfs(i, -1);
}
return ln >= k;
}
int32_t main() {
n = in(), k = in();
for (long long i = 0; i < n; i++) a[i + 1] = in();
for (long long i = 0; i < n - 1; i++) {
long long v = in(), u = in();
g[v].push_back(u);
g[u].push_back(v);
}
long long l = 0, r = (1 << 20), best = 0, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (can(mid)) {
best = mid;
l = mid + 1;
continue;
}
r = mid - 1;
}
cout << best << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 202000;
int down[maxn], up[maxn];
int a[maxn], size[maxn];
bool ban[maxn];
vector<int> side[maxn];
multiset<int> q;
void dfs1(int u, int fa) {
size[u] = 1;
int buc = 0, mx = 0;
for (int i = (0), iend = (side[u].size() - 1); i <= iend; i++) {
int v = side[u][i];
if (v == fa) continue;
dfs1(v, u);
size[u] += size[v];
if (down[v] == size[v])
buc += size[v];
else {
mx = max(mx, down[v]);
q.insert(down[v]);
}
}
if (!ban[u]) down[u] = 1 + buc + mx;
}
int n, k;
void dfs2(int u, int fa) {
q.clear();
int buc = 0;
if (!ban[u]) up[u] = max(up[u], 1);
for (int i = (0), iend = (side[u].size() - 1); i <= iend; i++) {
int v = side[u][i];
if (v == fa) continue;
if (down[v] == size[v])
buc += size[v];
else {
q.insert(down[v]);
}
}
if (up[u] == n - size[u] + 1)
buc += up[u] - 1;
else {
q.insert(up[u] - 1);
}
for (int i = (0), iend = (side[u].size() - 1); i <= iend; i++) {
int v = side[u][i];
if (v == fa) continue;
if (down[v] == size[v])
buc -= size[v];
else {
q.erase(q.find(down[v]));
}
if (!ban[u] && !ban[v]) {
up[v] = buc + ((q.empty()) ? 0 : (*q.rbegin())) + 2;
}
if (down[v] == size[v])
buc += size[v];
else {
q.insert(down[v]);
}
}
for (int i = (0), iend = (side[u].size() - 1); i <= iend; i++) {
int v = side[u][i];
if (v == fa) continue;
dfs2(v, u);
}
}
bool check(int lim) {
memset(down, 0, sizeof(down));
memset(up, 0, sizeof(up));
memset(ban, 0, sizeof(ban));
for (int i = (1), iend = (n); i <= iend; i++)
if (a[i] < lim) ban[i] = 1;
dfs1(1, 0);
dfs2(1, 0);
for (int i = (1), iend = (n); i <= iend; i++) {
int ans = 0;
if (size[i] == down[i])
ans = down[i] + up[i] - 1;
else if (up[i] == n - size[i] + 1)
ans = up[i] + down[i] - 1;
else
ans = max(up[i], down[i]);
if (ans >= k) return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = (1), iend = (n); i <= iend; i++) cin >> a[i];
for (int i = (1), iend = (n - 1); i <= iend; i++) {
int u, v;
cin >> u >> v;
side[u].push_back(v);
side[v].push_back(u);
}
int l = 0, r = 1000001;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long INF = 1e9 + 19;
int a[N];
vector<int> e[N];
bool use[N];
int f[N];
int cnt[N];
int n, k;
bool can;
void read() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
e[v].push_back(u);
e[u].push_back(v);
}
}
void dfs1(int v, int val) {
use[v] = 1;
cnt[v] = 1;
int full = 0;
int mx = 0;
for (auto u : e[v]) {
if (!use[u]) {
dfs1(u, val);
cnt[v] += cnt[u];
if (cnt[u] == f[u])
full += f[u];
else
mx = max(f[u], mx);
}
}
if (a[v] < val)
f[v] = 0;
else
f[v] = full + 1 + mx;
}
void dfs2(int v, int val, int sz) {
use[v] = 1;
int full = 0;
pair<int, int> mx1 = make_pair(0, -1);
pair<int, int> mx2 = make_pair(0, -1);
for (auto u : e[v])
if (!use[u]) {
if (cnt[u] == f[u])
full += f[u];
else {
auto tmp = make_pair(f[u], u);
if (mx2 < tmp) {
mx2 = tmp;
if (mx1 < mx2) swap(mx1, mx2);
}
}
}
assert(sz <= n - cnt[v]);
if (sz == n - cnt[v])
full += sz;
else {
auto tmp = make_pair(sz, -1);
if (mx2 < tmp) {
mx2 = tmp;
if (mx1 < mx2) swap(mx1, mx2);
}
}
int sum = full + mx1.first + 1;
if (a[v] >= val) {
can |= sum >= k;
}
for (auto u : e[v])
if (!use[u]) {
int h = 0;
if (a[v] >= val) {
if (cnt[u] == f[u]) {
h = sum - f[u];
assert(h >= 1);
} else {
if (u == mx1.second)
h = sum - mx1.first + mx2.first;
else
h = sum;
}
}
dfs2(u, val, h);
}
}
bool check(int val) {
memset(use, 0, sizeof(use));
dfs1(0, val);
memset(use, 0, sizeof(use));
can = 0;
dfs2(0, val, 0);
return can;
}
void solve() {
int mx = 0;
for (int i = 0; i < n; i++) mx = max(mx, a[i]);
int l = 0;
int r = mx + 1;
while (r - l > 1) {
if (check((l + r) / 2))
l = (l + r) / 2;
else
r = (l + r) / 2;
}
printf("%d\n", l);
}
void stress() {}
int main() {
if (1) {
int k = 1;
for (int tt = 0; tt < k; tt++) {
read();
solve();
}
} else {
stress();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k, a[N];
vector<int> g[N];
int dp[N], tp[N];
int Mid;
int use[N];
bool vis[N];
void dfs(int u, int p) {
vis[u] = true;
tp[u] = 0;
dp[u] = 0;
if (a[u] < Mid) {
tp[u] = 1;
return;
}
int Max = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
if (tp[v] == 1) {
tp[u] = 1;
Max = max(Max, dp[v]);
} else
dp[u] += dp[v];
}
dp[u] += Max + 1;
}
int tot;
void dfs2(int u, int p, int tpp, int dpp) {
if (a[u] < Mid) return;
int v1 = 0, v2 = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (tp[v]) {
if (dp[v] >= dp[v1]) {
v2 = v1;
v1 = v;
} else if (dp[v] >= dp[v2])
v2 = v;
}
}
if (tp[v1]) {
if (tpp)
tot = max(tot, max(dpp, dp[v1]) + dp[u] - dp[v1]);
else
tot = max(tot, dpp + dp[u]);
} else
tot = max(tot, dpp + dp[u]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
if (tp[v1] == 0)
dfs2(v, u, tpp, dpp + dp[u] - dp[v]);
else {
if (v == v1) {
if (tp[v2] == 0)
dfs2(v, u, tpp, dpp + dp[u] - dp[v1]);
else {
if (tpp)
dfs2(v, u, tpp, max(dpp, dp[v2]) + dp[u] - dp[v1]);
else
dfs2(v, u, 1, dpp + dp[u] - dp[v1] + dp[v2]);
}
} else {
if (tp[v]) {
if (tpp)
dfs2(v, u, tpp, max(dpp, dp[v1]) + dp[u] - dp[v1]);
else
dfs2(v, u, 1, dpp + dp[u]);
} else {
if (tpp)
dfs2(v, u, tpp, max(dpp, dp[v1]) + dp[u] - dp[v1] - dp[v]);
else
dfs2(v, u, 1, dpp + dp[u] - dp[v]);
}
}
}
}
}
int cal(int mid) {
Mid = mid;
int ans = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (a[i] < Mid) continue;
if (vis[i]) continue;
dfs(i, i);
tot = 0;
dfs2(i, i, 0, 0);
ans = max(tot, ans);
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int u, v;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int l = 1, r = 1000001;
while (l < r) {
int mid = (l + r) >> 1;
if (cal(mid) >= k)
l = mid + 1;
else
r = mid;
}
printf("%d\n", l - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int Inf = 1e9 + 7;
vector<int> g[N];
int sz[N];
int mark[N];
int can = 0;
int dfs(int u, int p) {
sz[u] = 1;
int mx1 = 0, mx2 = 0;
int sum = 1;
for (auto v : g[u]) {
if (v != p) {
int x = dfs(v, u);
sz[u] += sz[v];
if (x == sz[v]) {
sum += x;
} else {
if (x > mx1) swap(x, mx1);
if (x > mx2) swap(x, mx2);
}
}
}
if (!mark[u]) return 0;
can = max(can, sum + mx1 + mx2);
return sum + mx1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i + 1 < n; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 0, r = 1e9 + 1;
while (r - l > 1) {
int m = (l + r) >> 1;
for (int i = 0; i < n; ++i) {
mark[i] = (a[i] >= m);
}
for (int i = 0; i < n; ++i) {
sz[i] = 0;
}
can = 0;
bool fl = false;
for (int i = 0; i < n; ++i) {
if (!mark[i]) {
dfs(i, -1);
fl = true;
break;
}
}
if (!fl) dfs(0, -1);
if (can >= k)
l = m;
else
r = m;
}
cout << l << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, k;
const int maxN = 3 * (int)1e5 + 100;
int par[maxN];
vector<int> g[maxN];
int a[maxN];
void dfs(int v, int p) {
for (int to : g[v]) {
if (to == p) continue;
par[to] = v;
dfs(to, v);
}
}
int b[maxN];
int dp[maxN];
bool is_good[maxN];
void go(int v, int p) {
is_good[v] = true;
dp[v] = 0;
int mx = 0;
for (int to : g[v]) {
if (to == p) continue;
go(to, v);
is_good[v] &= is_good[to];
if (is_good[to])
dp[v] += dp[to];
else {
mx = max(mx, dp[to]);
}
}
if (b[v] == 0) {
dp[v] = 0;
is_good[v] = false;
return;
}
dp[v] += (1 + mx);
}
int f[maxN];
bool all_f[maxN];
pair<pair<int, int>, bool> unite(pair<pair<int, int>, bool> a,
pair<pair<int, int>, bool> b) {
pair<pair<int, int>, bool> t;
t.second = b.second & a.second;
t.first = make_pair(a.first.first + b.first.first,
max(a.first.second, b.first.second));
return t;
}
void calc_up(int v, int p) {
vector<int> sons;
for (int to : g[v]) {
if (to == p) continue;
sons.push_back(to);
}
if (b[v] == 0) {
for (int to : sons) {
f[to] = 0;
all_f[to] = false;
}
} else {
vector<pair<pair<int, int>, bool> > pref(sons.size() + 1),
suf(sons.size() + 1);
pref[0] = make_pair(make_pair(0, 0), true);
for (int i = 1; i <= sons.size(); i++) {
pair<pair<int, int>, bool> t;
if (is_good[sons[i - 1]])
t.first.first = dp[sons[i - 1]];
else
t.first.second = dp[sons[i - 1]];
t.second = is_good[sons[i - 1]];
pref[i] = unite(pref[i - 1], t);
}
suf[sons.size()] = make_pair(make_pair(0, 0), true);
for (int i = (int)sons.size() - 1; i >= 0; i--) {
pair<pair<int, int>, bool> t;
if (is_good[sons[i]])
t.first.first = dp[sons[i]];
else
t.first.second = dp[sons[i]];
t.second = is_good[sons[i]];
suf[i] = unite(suf[i + 1], t);
}
for (int i = 0; i < sons.size(); i++) {
pair<pair<int, int>, bool> t;
t.second = all_f[v];
if (t.second)
t.first.first = f[v];
else
t.first.second = f[v];
auto nt = unite(t, unite(pref[i], suf[i + 1]));
nt.first.first += 1;
f[sons[i]] = nt.first.first + nt.first.second;
all_f[sons[i]] = nt.second;
}
}
for (int to : sons) {
calc_up(to, v);
}
}
bool ok(int x) {
for (int i = 1; i <= n; i++) {
b[i] = (a[i] >= x);
f[i] = all_f[i] = dp[i] = is_good[i] = 0;
}
f[1] = 0;
all_f[1] = true;
go(1, -1);
calc_up(1, -1);
for (int i = 1; i <= n; i++) {
if (b[i] == 0) continue;
int s;
if (all_f[i] || is_good[i])
s = f[i] + dp[i];
else
s = max(f[i], dp[i]);
if (s >= k) return true;
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, -1);
int l = 0;
int r = 1000 * 10000 + 10;
while (r - l > 1) {
int mid = (l + r) / 2;
if (ok(mid))
l = mid;
else
r = mid;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[200005];
int A[200005], dp[200005], ans[200005];
bool ok[200005], all[200005];
void dfs(int v = 0, int p = -1) {
int mx = 0, sum = 1;
all[v] = true;
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i];
if (to != p) {
dfs(to, v);
all[v] &= all[to];
if (all[to])
sum += dp[to];
else
mx = max(mx, dp[to]);
}
}
dp[v] = sum + mx;
if (!ok[v]) {
all[v] = false;
dp[v] = 0;
}
}
void make(int v = 0, int p = -1, int d = 0, bool up = true) {
int A = 0, B = 0;
int sum = 1, cnt = 0;
if (up)
sum += d;
else {
A = d;
cnt++;
}
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i];
if (to != p) {
int gt = dp[to];
if (all[to])
sum += dp[to];
else {
cnt++;
if (A < gt) swap(A, gt);
if (B < gt) swap(B, gt);
}
}
}
ans[v] = sum + A;
if (!ok[v]) ans[v] = 0;
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i];
if (to != p) {
int nxt = sum, nm = cnt;
if (all[to])
nxt += A - dp[to];
else {
nm--;
if (A == dp[to])
nxt += B;
else
nxt += A;
}
if (!ok[v]) {
nxt = 0;
nm = 1;
}
make(to, v, nxt, nm == 0);
}
}
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
vec[a].push_back(b);
vec[b].push_back(a);
}
int l = -1, r = 1000005;
while (l + 1 < r) {
int m = (l + r) / 2;
for (int i = 0; i < n; i++) ok[i] = (A[i] >= m);
dfs();
make();
int mx = 0;
for (int i = 0; i < n; i++) mx = max(mx, ans[i]);
if (mx >= k)
l = m;
else
r = m;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int a[200005], kol[200005], sz[200005], opa[200005], n, k;
void dfs(int v, int pr, int mark) {
sz[v] = 1;
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u != pr) {
dfs(u, v, mark);
sz[v] += sz[u];
}
}
if (a[v] < mark) {
kol[v] = 0;
return;
}
kol[v] = 1;
int mx = 0;
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u == pr) continue;
if (kol[u] == sz[u])
kol[v] += kol[u];
else
mx = max(mx, kol[u]);
}
kol[v] += mx;
return;
}
void dfsik(int v, int pr, int cur, int mark) {
opa[v] = 0;
if (a[v] >= mark) {
opa[v] = 1;
int mx = 0;
if (cur == n - sz[v])
opa[v] += cur;
else
mx = cur;
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u == pr) continue;
if (kol[u] == sz[u])
opa[v] += kol[u];
else
mx = max(mx, kol[u]);
}
opa[v] += mx;
}
int mx1 = 0, mx2 = 0;
if (cur != n - sz[v]) {
if (cur >= mx1) {
mx2 = mx1;
mx1 = cur;
} else if (cur >= mx2)
mx2 = cur;
}
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u == pr) continue;
if (kol[u] != sz[u]) {
if (kol[u] >= mx1) {
mx2 = mx1;
mx1 = kol[u];
} else if (kol[u] >= mx2)
mx2 = kol[u];
}
}
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u == pr) continue;
if (a[v] < mark)
dfsik(u, v, 0, mark);
else if (kol[u] == sz[u])
dfsik(u, v, opa[v] - kol[u], mark);
else {
if (kol[u] == mx1)
dfsik(u, v, opa[v] - mx1 + mx2, mark);
else
dfsik(u, v, opa[v], mark);
}
}
return;
}
bool ok(int mark) {
dfs(1, -1, mark);
dfsik(1, -1, 0, mark);
for (int i = 1; i <= n; i++)
if (opa[i] >= k) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int l = 1, r = 1000001;
while (l + 1 < r) {
int m = (l + r) / 2;
if (ok(m))
l = m;
else
r = m;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) f = c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return f ? -x : x;
}
namespace run {
const int N = 4e5 + 9;
int head[N], nex[N], to[N], cnt, deg[N];
inline void add(int u, int v) {
nex[++cnt] = head[u];
head[u] = cnt, to[cnt] = v;
}
int a[N], n, K, vis[N], B[N], ok[N], ans, com[N], val[N], siz[N], f[N];
inline void dfs1(int u, int _f) {
vis[u] = siz[u] = val[u] = 1;
int son = 0, _son = 0, peg = 0;
for (int i = head[u]; i; i = nex[i])
if (ok[to[i]] && to[i] ^ _f) {
dfs1(to[i], u), siz[u] += siz[to[i]], son++;
if (com[to[i]])
ok[to[i]] = 0, val[u] += siz[to[i]];
else
_son = to[i], peg++;
}
if (_f) son++;
if (son == deg[u] && val[u] == siz[u]) com[u] = 1;
if (son == deg[u] && peg == 1) f[u] = _son;
}
int mx[N], _mx[N];
inline void up(int u, int _f) {
mx[u] = _mx[u] = 0, vis[u] = 1;
for (int i = head[u]; i; i = nex[i])
if (ok[to[i]] && to[i] ^ _f) {
up(to[i], u);
if (mx[to[i]] + val[to[i]] > _mx[u]) {
_mx[u] = mx[to[i]] + val[to[i]];
if (_mx[u] > mx[u]) swap(mx[u], _mx[u]);
}
}
ans = max(ans, mx[u] + _mx[u] + val[u]);
}
inline void down(int u, int _f, int ret) {
ans = max(ans, ret + mx[u] + val[u]);
for (int i = head[u]; i; i = nex[i])
if (ok[to[i]] && to[i] ^ _f)
down(to[i], u,
mx[u] == mx[to[i]] + val[to[i]] ? max(_mx[u], ret) + val[u]
: max(ret, mx[u]) + val[u]);
}
inline bool check(int mid) {
for (int i = 1; i <= n; i++)
f[i] = val[i] = com[i] = vis[i] = 0, ok[i] = (a[i] >= mid);
ans = 0;
for (int i = 1; i <= n; i++)
if (ok[i] && !vis[i]) {
dfs1(i, 0);
int tmp = i;
while (f[tmp]) ok[tmp] = 0, val[f[tmp]] += val[tmp], tmp = f[tmp];
}
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= n; i++)
if (ok[i] && !vis[i]) up(i, 0), down(i, 0, 0);
return ans >= K;
}
int main() {
n = read<int>(), K = read<int>();
for (int i = 1; i <= n; i++) B[i] = a[i] = read<int>();
for (int i = 1; i < n; i++) {
int u = read<int>(), v = read<int>();
add(u, v), add(v, u), deg[u]++, deg[v]++;
}
sort(B + 1, B + n + 1);
int m = unique(B + 1, B + n + 1) - B - 1;
int l = 1, r = m, ret;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(B[mid]))
ret = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", B[ret]);
return 0;
}
} // namespace run
int main() { return run::main(); }
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct Input {
int n, k;
vector<int> a;
vector<pair<int, int> > ed;
bool read() {
if (!(cin >> n >> k)) {
return false;
}
a.resize(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i + 1 < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
ed.push_back(make_pair(u, v));
}
return true;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans;
void write() { cout << ans << "\n"; }
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
const int N = 2e5;
struct Solution : Data {
vector<pair<int, int> > g[N];
list<pair<int, int> > q[N];
pair<pair<int, int>, pair<int, int> > acc[N];
pair<int, int> d[3 * N];
int bound;
bool includedInAcc(int u, int w) {
return w != -1 &&
find_if((q[u]).begin(), (q[u]).end(), [&w](pair<int, int> const& x) {
return x.first == w;
}) == q[u].end();
}
void update(pair<pair<int, int>, pair<int, int> >& a,
pair<int, int> const& b) {
if (b.first == 0) {
a.first.second += b.second;
} else {
++a.first.first;
if (a.second.first < b.second) {
a.second.second = a.second.first;
a.second.first = b.second;
} else if (a.second.second < b.second) {
a.second.second = b.second;
}
}
}
pair<int, int> extract(pair<pair<int, int>, pair<int, int> > const& a,
pair<int, int> const& b) {
pair<int, int> r;
if (a.first.first - b.first == 0) {
r.first = 0;
r.second = a.first.second - (b.first ? 0 : b.second);
} else {
r.first = 1;
if (b.first == 0) {
r.second = a.first.second - b.second + a.second.first;
} else {
r.second =
a.first.second +
((a.second.first == b.second) ? a.second.second : a.second.first);
}
}
return r;
}
pair<int, int>& get(int u, int w, int e) {
return d[(w == -1) ? (2 * (n - 1) + u) : e];
}
pair<int, int> go(int u, int w = -1, int e = -1) {
if (a[u] < bound) {
return pair<int, int>(1, 0);
}
pair<pair<int, int>, pair<int, int> >& ra = acc[u];
for (auto it = q[u].begin(); it != q[u].end();) {
int v = it->first, f = it->second;
if (w == v) {
++it;
continue;
}
update(ra, go(v, u, f));
it = q[u].erase(it);
}
pair<int, int>& r = get(u, w, e);
r = extract(ra, (includedInAcc(u, w) ? get(w, u, e ^ 1) : make_pair(0, 0)));
++r.second;
return r;
}
bool ok(int x) {
bound = x;
for (int i = 0; i < n; ++i) {
acc[i] = make_pair(make_pair(0, 0), make_pair(0, 0));
q[i].clear();
q[i].insert(q[i].begin(), (g[i]).begin(), (g[i]).end());
}
for (int i = 0; i < n; ++i) {
if (go(i).second >= k) {
return true;
}
}
return false;
}
void solve() {
for (int i = 0; i < ((int)(ed).size()); ++i) {
int u = ed[i].first, v = ed[i].second;
g[u].push_back(make_pair(v, 2 * i));
g[v].push_back(make_pair(u, 2 * i + 1));
}
vector<int> b = a;
sort((b).begin(), (b).end());
int left = 0, right = ((int)(b).size());
while (left + 1 < right) {
int middle = (left + right) / 2;
if (ok(b[middle])) {
left = middle;
} else {
right = middle;
}
}
ans = b[left];
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
int a[300000];
int b[300000];
vector<int> edge[300000];
int ngood;
int child[300000];
int good[300000];
int d[300000];
int ans;
void back(int now, int parent) {
child[now] = 1;
good[now] = b[now];
for (auto e : edge[now])
if (e != parent) {
back(e, now);
child[now] += child[e], good[now] += good[e];
}
}
vector<pair<int, int> > v;
void back2(int now, int parent) {
for (auto e : edge[now])
if (e != parent) {
back2(e, now);
}
if (b[now] == 0) {
d[now] = 0;
return;
}
d[now] = 1;
int xgood = 0;
for (auto e : edge[now])
if (e != parent) {
if (child[e] == good[e]) xgood += child[e];
}
for (auto e : edge[now])
if (e != parent) {
d[now] =
max(d[now], 1 + d[e] + xgood - (child[e] == good[e] ? child[e] : 0));
}
ans = max(ans, d[now]);
int u = 1 + (n - child[now] == ngood - good[now] ? n - child[now] : 0);
v.clear();
for (auto e : edge[now])
if (e != parent) {
v.emplace_back(d[e], e);
}
sort((v).begin(), (v).end(), greater<pair<int, int> >());
for (int i = 0; i < 4 && i < v.size(); i++) {
for (int j = i + 1; j < 4 && j < v.size(); j++) {
ans = max(
ans, u + v[i].first + v[j].first + xgood -
(child[v[i].second] == good[v[i].second] ? child[v[i].second]
: 0) -
(child[v[j].second] == good[v[j].second] ? child[v[j].second]
: 0));
}
}
}
int param(int x) {
int i, j, k;
for (i = 0; i < n; i++) b[i] = a[i] >= x;
ngood = count(b, b + n, 1);
back(1, -1);
ans = 0;
back2(1, -1);
return ans >= m;
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y), x--, y--;
edge[x].push_back(y), edge[y].push_back(x);
}
int low = 0, high = 1000001, mid;
while (low <= high) {
mid = (low + high) / 2;
if (param(mid))
low = mid + 1;
else
high = mid - 1;
}
cout << high;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int val[200007];
vector<int> v[200007];
int coef[200007];
int subtree[200007];
int good[200007];
int up[200007];
void init(int vertex, int prv) {
subtree[vertex] = 1;
good[vertex] = coef[vertex];
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
init(x, vertex);
subtree[vertex] += subtree[x];
good[vertex] += good[x];
}
}
void calc_up(int vertex, int prv, int hh) {
int tot = coef[vertex];
up[vertex] = hh;
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
tot += good[x];
}
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
calc_up(x, vertex, hh + tot - good[x]);
}
}
int dp[200007];
bool dfs(int vertex, int prv) {
dp[vertex] = 0;
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
if (dfs(x, vertex) == true) {
return true;
}
}
if (coef[vertex] == 1) {
int tot = 0;
int add = 0;
if (up[vertex] == n - subtree[vertex]) {
add = up[vertex];
}
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
if (subtree[x] == good[x]) {
tot += good[x];
}
}
dp[vertex] = tot + 1;
int mx1, mx2;
mx1 = mx2 = 0;
for (auto x : v[vertex]) {
if (x == prv) {
continue;
}
int aux = dp[x];
if (subtree[x] == good[x]) {
aux -= good[x];
}
if (mx1 < aux) {
mx2 = mx1;
mx1 = aux;
} else if (mx2 < aux) {
mx2 = aux;
}
}
dp[vertex] += mx1;
if (dp[vertex] + mx2 + add >= k) {
return true;
}
}
return false;
}
bool f(int sr) {
for (int i = 1; i <= n; ++i) {
coef[i] = (val[i] >= sr);
}
init(1, -1);
calc_up(1, -1, 0);
return dfs(1, -1);
}
void input() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &val[i]);
}
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
}
void solve() {
int l, r, mid;
l = 0;
r = 1000000;
while (r - l > 3) {
mid = (l + r) / 2;
if (f(mid) == true) {
l = mid;
} else {
r = mid;
}
}
while (f(r) == false) {
--r;
}
printf("%d\n", r);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
input();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 7;
int n, k, a[N], sub[N], gsub[N], sol;
bool good[N];
vector<int> g[N], kids[N];
void bok(int a) {
gsub[a] = good[a];
for (auto &b : g[a]) {
bok(b);
gsub[a] += gsub[b];
}
}
int dfs(int a) {
if (good[a] == 0) {
for (auto &b : g[a]) dfs(b);
return 0;
}
int f = 0, s = 0, tot = 1;
for (auto &b : g[a]) {
int dp = dfs(b);
if (dp == sub[b])
tot += dp;
else {
if (dp > f) {
s = f;
f = dp;
} else
s = max(s, dp);
}
}
sol = max(sol, tot + f + s);
if (n - sub[a] == gsub[1] - gsub[a]) sol = max(sol, tot + f + s + n - sub[a]);
return tot + f;
}
bool ok(int x) {
sol = 0;
for (int i = 1; i <= n; i++) good[i] = (a[i] >= x);
bok(1);
dfs(1);
return sol >= k;
}
void build(int a, int p) {
sub[a] = 1;
for (auto &b : g[a])
if (b != p) {
kids[a].push_back(b);
build(b, a);
sub[a] += sub[b];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
build(1, 0);
for (int i = 1; i <= n; i++) g[i] = kids[i];
int l = 1, r = 1000000, ans;
while (l <= r) {
int m = (l + r) / 2;
if (ok(m)) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int BASE = 1000000007;
const int MAX = 200007;
const int MAX2 = 7777;
const int MAXE = 100000;
const int ADD = 1000000;
const int MOD = 1000000007;
const int CNT = 800;
int n, k;
vector<int> G[MAX];
int a[MAX];
bool U[MAX];
int res;
int cnt;
int c[MAX];
int d[MAX];
void dfs2(int v, int p) {
c[v] = U[v];
d[v] = 1;
for (int i = (0); i < (G[v].size()); i++) {
int to = G[v][i];
if (to == p) continue;
dfs2(to, v);
c[v] += c[to];
d[v] += d[to];
}
}
pair<int, int> dfs(int v, int p) {
vector<int> A;
vector<int> B;
bool bad = 0;
for (int i = (0); i < (G[v].size()); i++) {
int to = G[v][i];
if (to == p) continue;
if (U[to]) {
bad = 1;
}
pair<int, int> pr = dfs(to, v);
if (pr.second == 0) {
A.push_back(pr.first);
} else {
bad = 1;
B.push_back(pr.first);
}
}
if (U[v]) return make_pair(0, 1);
sort(B.begin(), B.end());
reverse(B.begin(), B.end());
int add = 1;
for (int i = (0); i < (A.size()); i++) {
add += A[i];
}
int add2 = add;
if (B.size() > 0) add += B[0];
if (B.size() > 1) add += B[1];
if (cnt == c[v]) {
add += n - d[v];
}
res = max(res, add);
if (B.size() > 0) add2 += B[0];
return make_pair(add2, bad);
}
bool check(int X) {
memset(U, 0, sizeof(U));
cnt = 0;
for (int i = (0); i < (n); i++) {
if (a[i] < X) {
U[i] = 1;
cnt++;
}
}
dfs2(0, -1);
res = 0;
dfs(0, -1);
return res >= k;
}
int main() {
cin >> n >> k;
for (int i = (0); i < (n); i++) {
scanf("%d", &a[i]);
}
for (int i = (0); i < (n - 1); i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
G[a].push_back(b);
G[b].push_back(a);
}
int L = 0;
int R = 1000007;
while (R - L > 1) {
int X = (L + R) / 2;
if (check(X)) {
L = X;
} else {
R = X;
}
}
cout << L << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
vector<int> adj[200200];
int n, k;
int dp[200200], sz[200200], val[200200], mx[200200][2], ans, mid;
void dfs(int u, int fa = 0) {
mx[u][0] = mx[u][1] = dp[u] = 0;
sz[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
if (val[u] < mid) continue;
if (dp[v] == sz[v])
dp[u] += dp[v];
else {
smax(mx[u][1], dp[v]);
if (mx[u][0] < mx[u][1]) swap(mx[u][0], mx[u][1]);
}
}
dp[u] += mx[u][0];
if (val[u] >= mid) dp[u]++;
}
void redfs(int u, int fa = 0, int pre = 0) {
if (dp[u]) {
if (pre == n - sz[u])
smax(ans, dp[u] + pre);
else
smax(ans, dp[u] - mx[u][0] + max(mx[u][0], pre));
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
if (!dp[u])
redfs(v, u, 0);
else {
if (dp[v] == sz[v]) {
if (pre == n - sz[u])
redfs(v, u, dp[u] - dp[v] + pre);
else
redfs(v, u, dp[u] - dp[v] - mx[u][0] + max(mx[u][0], pre));
} else if (dp[v] == mx[u][0]) {
if (pre == n - sz[u])
redfs(v, u, dp[u] - dp[v] + pre);
else
redfs(v, u, dp[u] - dp[v] + max(mx[u][1], pre));
} else {
if (pre == n - sz[u])
redfs(v, u, dp[u] + pre);
else
redfs(v, u, dp[u] - mx[u][0] + max(pre, mx[u][0]));
}
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", val + i);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int st = 0, ed = 1000001;
while (ed - st > 1) {
mid = st + ed >> 1;
ans = 0;
dfs(1);
redfs(1);
if (ans >= k)
st = mid;
else
ed = mid;
}
cout << st << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = mod * mod;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
int n, k;
int a[1 << 18];
struct edge {
int to, cost;
};
vector<int> G[200000];
vector<vector<pair<int, int>>> memo;
void init(int id, int fr) {
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
if (to == fr) continue;
init(to, id);
memo[id].push_back({-1, -1});
}
}
int inf;
bool yes = false;
pair<int, int> dfs(int id, int fr) {
if (a[id] < inf) {
return {0, false};
}
pair<int, int> res = {1, true};
vector<pair<int, int>> nex;
vector<int> ids;
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
if (to == fr) continue;
pair<int, int> z = dfs(to, id);
nex.push_back(z);
memo[id][ids.size()] = z;
ids.push_back(to);
}
int ma = -1;
for (int j = 0; j < nex.size(); j++) {
if (nex[j].second == true) {
res.first += nex[j].first;
} else {
ma = max(ma, nex[j].first);
}
}
if (ma < 0) {
return res;
} else {
res.second = false;
res.first += ma;
}
return res;
}
void dfs2(int id, int fr, pair<int, int> frs) {
if (fr < 0) {
if (a[id] < inf) {
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
dfs2(to, id, {0, false});
}
} else {
vector<pair<int, int>> v;
vector<int> ids;
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
v.push_back(memo[id][ids.size()]);
ids.push_back(to);
}
vector<int> mal(v.size() + 1, -1);
vector<int> mar(v.size() + 1, -1);
for (int i = 0; i < v.size(); i++) {
if (!v[i].second) {
mal[i + 1] = max(mal[i], v[i].first);
} else {
mal[i + 1] = mal[i];
}
}
for (int i = (int)v.size() - 1; i >= 0; i--) {
if (!v[i].second) {
mar[i] = max(mar[i + 1], v[i].first);
} else {
mar[i] = mar[i + 1];
}
}
int sum = 1;
for (int j = 0; j < v.size(); j++) {
if (v[j].second) sum += v[j].first;
}
for (int j = 0; j < v.size(); j++) {
int to = ids[j];
if (v[j].second) {
int ssum = sum - v[j].first;
int ma = max(mal[j], mar[j + 1]);
if (ma == -1) {
dfs2(to, id, {ssum, true});
} else {
dfs2(to, id, {ssum + ma, false});
}
} else {
int ssum = sum;
int ma = max(mal[j], mar[j + 1]);
if (ma == -1) {
dfs2(to, id, {ssum, true});
} else {
dfs2(to, id, {ssum + ma, false});
}
}
}
}
} else {
if (a[id] < inf) {
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
if (to == fr) continue;
dfs2(to, id, {0, false});
}
} else {
vector<pair<int, int>> v;
vector<int> ids;
for (int j = 0; j < G[id].size(); j++) {
int to = G[id][j];
if (to == fr) continue;
if (memo[id][ids.size()].first >= 0) {
v.push_back(memo[id][ids.size()]);
} else {
v.push_back(dfs(to, id));
}
ids.push_back(to);
}
v.push_back(frs);
vector<int> mal(v.size() + 1, -1);
vector<int> mar(v.size() + 1, -1);
for (int i = 0; i < v.size(); i++) {
if (!v[i].second) {
mal[i + 1] = max(mal[i], v[i].first);
} else {
mal[i + 1] = mal[i];
}
}
for (int i = (int)v.size() - 1; i >= 0; i--) {
if (!v[i].second) {
mar[i] = max(mar[i + 1], v[i].first);
} else {
mar[i] = mar[i + 1];
}
}
int sum = 1;
for (int j = 0; j < v.size(); j++) {
if (v[j].second) sum += v[j].first;
}
int mma = 0;
for (int j = 0; j < v.size(); j++) {
if (!v[j].second) mma = max(mma, v[j].first);
}
if (sum + mma >= k) yes = true;
for (int j = 0; j < v.size() - 1; j++) {
int to = ids[j];
if (v[j].second) {
int ssum = sum - v[j].first;
int ma = max(mal[j], mar[j + 1]);
if (ma == -1) {
dfs2(to, id, {ssum, true});
} else {
dfs2(to, id, {ssum + ma, false});
}
} else {
int ssum = sum;
int ma = max(mal[j], mar[j + 1]);
if (ma == -1) {
dfs2(to, id, {ssum, true});
} else {
dfs2(to, id, {ssum + ma, false});
}
}
}
}
}
}
bool can() {
yes = false;
pair<int, int> z = dfs(0, -1);
if (z.first >= k) return true;
dfs2(0, -1, {0, 0});
return yes;
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
memo.resize(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
init(0, -1);
int le = 0, ri = 1000001;
while (ri - le > 1) {
int mid = (le + ri) / 2;
for (int i = 0; i < n; i++)
for (int j = 0; j < memo[i].size(); j++) memo[i][j] = {-1, -1};
inf = mid;
if (can()) {
le = mid;
} else {
ri = mid;
}
}
cout << le << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k, head[200000 + 5], cnt = 0, a[200000 + 5], ans = 0, mid, f[200000 + 5],
num[200000 + 5], mx[200000 + 5], mx2[200000 + 5],
from[200000 + 5];
struct edge {
int to, next;
} e[200000 * 2 + 5];
inline void ins(int f, int t) {
e[++cnt] = (edge){t, head[f]};
head[f] = cnt;
e[++cnt] = (edge){f, head[t]};
head[t] = cnt;
}
void Add(int x, int flag, int v, int id) {
if (flag)
f[x] += v;
else {
++num[x];
if (v > mx[x])
mx2[x] = mx[x], mx[x] = v, from[x] = id;
else if (v > mx2[x])
mx2[x] = v;
}
}
void dfs(int x, int fa) {
num[x] = mx[x] = mx2[x] = from[x] = 0;
f[x] = a[x] >= mid;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
int v = e[i].to;
dfs(v, x);
Add(x, !num[v], f[v] + mx[v], v);
}
if (a[x] < mid) f[x] = mx[x] = mx2[x] = 0, ++num[x];
}
void Solve(int x, int fa) {
if (a[x] >= mid) ans = max(ans, f[x] + mx[x]);
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa) {
int v = e[i].to;
if (a[x] >= mid) {
if (!num[v])
Add(v, !num[x], f[x] - f[v] + mx[x], x);
else
Add(v, num[x] == 1, f[x] + (from[x] == v ? mx2[x] : mx[x]), x);
} else
Add(v, 0, 0, x);
Solve(v, x);
}
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i < n; ++i) ins(read(), read());
int l = 1, r = 1e6, res;
while (l <= r) {
mid = l + r >> 1;
ans = 0;
dfs(1, 0);
Solve(1, 0);
if (ans >= k)
res = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, a[N], b[N], dp[N], sz[N], cur[N], ans, cnt, l, r, mid, x, y;
vector<int> g[N];
void dfs1(int v, int pr = -1) {
sz[v] = 1;
for (int to : g[v]) {
if (to != pr) {
dfs1(to, v);
sz[v] += sz[to];
}
}
}
void dfs2(int v, int pr = -1) {
int all = 0, mx1 = 0, mx2 = 0;
for (int to : g[v]) {
if (to != pr) {
dfs2(to, v);
cur[v] += cur[to];
if (dp[to] == sz[to]) {
all += sz[to];
} else if (dp[to] > mx1) {
mx2 = mx1;
mx1 = dp[to];
} else if (dp[to] > mx2) {
mx2 = dp[to];
}
}
}
if (!b[v]) {
dp[v] = 0;
} else {
dp[v] = all + mx1 + 1;
cur[v]++;
}
if (n - sz[v] == cnt - cur[v]) {
all += n - sz[v];
}
if (b[v]) {
ans = max(ans, all + mx1 + mx2 + 1);
}
}
inline bool check(int x) {
ans = cnt = 0;
for (int i = 1; i <= n; i++) {
dp[i] = sz[i] = cur[i] = 0;
b[i] = a[i] >= x;
cnt += b[i];
}
dfs1(1);
dfs2(1);
return ans >= m;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
r = 1e6;
while (r - l > 1) {
mid = (r + l) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
if (check(r)) {
cout << r;
} else {
cout << l;
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 200005;
int a[maxn], f[maxn];
vector<int> g[maxn];
int dp[maxn], sz[maxn], szf[maxn];
struct node {
int mx1 = 0, mx2 = 0, mi1 = 0, mi2 = 0;
void insert(int i, int x) {
if (x >= mx1) {
mx2 = mx1, mi2 = mi1;
mi1 = i, mx1 = x;
} else if (x >= mx2) {
mx2 = x, mi2 = i;
}
}
} b[maxn];
int par[maxn];
void dfs(int u, int fa) {
par[u] = fa;
sz[u] = 1;
if (f[u])
dp[u] = 1;
else
dp[u] = -1e9;
if (f[u])
szf[u] = 1;
else
szf[u] = 0;
for (int v : g[u]) {
if (v == fa) continue;
dfs(v, u);
sz[u] += sz[v];
szf[u] += szf[v];
if (sz[v] == szf[v])
dp[u] += dp[v];
else
b[u].insert(v, dp[v]);
}
dp[u] += b[u].mx1;
}
int ok = 0;
int n, k;
void dfs2(int i) {
if (ok) return;
if (par[i]) {
if (n - sz[i] == szf[1] - szf[i]) {
if (dp[i] + n - sz[i] >= k) {
ok = 1;
return;
}
dp[i] += n - sz[i];
} else {
int ans = dp[par[i]];
if (sz[i] == szf[i]) {
ans -= sz[i];
} else if (i == b[par[i]].mi1) {
ans -= b[par[i]].mx1;
ans += b[par[i]].mx2;
}
if (ans > b[i].mx1) {
dp[i] -= b[i].mx1;
dp[i] += ans;
}
b[i].insert(par[i], ans);
if (dp[i] >= k) {
ok = 1;
return;
}
}
}
for (int v : g[i]) {
if (v == par[i]) continue;
dfs2(v);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int lo = 1, hi = 1e6;
while (lo < hi) {
memset(dp, 0, sizeof(dp));
memset(sz, 0, sizeof(dp));
memset(szf, 0, sizeof(dp));
memset(par, 0, sizeof(dp));
memset(f, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) b[i].mx1 = b[i].mx2 = b[i].mi1 = b[i].mi2 = 0;
int mid = (lo + hi + 1) / 2;
for (int i = 1; i <= n; ++i)
if (a[i] >= mid)
f[i] = 1;
else
f[i] = 0;
dfs(1, -1);
ok = 0;
if (dp[1] >= k)
ok = 1;
else
dfs2(1);
if (ok)
lo = mid;
else
hi = mid - 1;
}
cout << lo << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int val[200005];
vector<int> graph[200005];
int dp[200005];
int cnt[200005];
int cnt2[200005];
int n, k, mid, ans, total;
void dfs(int t, int p) {
int full = 0;
cnt[t] = 1;
cnt2[t] = (val[t] >= mid);
vector<int> vt;
for (int nxt : graph[t]) {
if (nxt == p) continue;
dfs(nxt, t);
cnt[t] += cnt[nxt];
cnt2[t] += cnt2[nxt];
if (cnt[nxt] == dp[nxt])
full += dp[nxt];
else {
vt.push_back(dp[nxt]);
}
}
int upward = 1;
if (total - cnt2[t] == n - cnt[t]) {
upward = n - cnt[t] + 1;
}
if (val[t] < mid) {
dp[t] = 0;
return;
}
sort(vt.begin(), vt.end());
if (cnt[t] == full + 1 || vt.empty()) {
ans = max(ans, full + 1);
dp[t] = full + 1;
return;
} else if (vt.size() == 1) {
ans = max(ans, vt[0] + full + 1);
dp[t] = vt[0] + full + 1;
return;
} else {
ans = max(ans, vt.rbegin()[0] + vt.rbegin()[1] + full + upward);
dp[t] = vt.back() + full + 1;
return;
}
}
bool check() {
ans = 0;
total = 0;
for (int i = 1; i <= n; i++) total += (val[i] >= mid);
dfs(rand() % n + 1, 0);
return ans >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
int lo = 1, hi = 999999, a = 1000000;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check()) {
a = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
printf("%d", a);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 100;
const long long lINF = 1e18;
const double EPS = 1e-12;
int myrand() { return rand(); }
int rnd(int x) { return myrand() % x; }
const int maxn = 5e5;
int n, k;
int a[maxn];
vector<int> tree[maxn];
int mid;
pair<int, bool> dp[maxn];
bool read() {
if (scanf("%d%d", &n, &k) < 1) {
return false;
}
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
tree[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
tree[u].push_back(v);
tree[v].push_back(u);
}
return true;
}
void dfs1(int v, int par = -1) {
int sum = 0, mx = 0;
bool all = true;
for (int i = 0; i < ((int)((tree[v]).size())); i++) {
int to = tree[v][i];
if (to == par) {
continue;
}
dfs1(to, v);
all &= dp[to].second;
if (dp[to].second) {
sum += dp[to].first;
} else {
mx = max(dp[to].first, mx);
}
}
dp[v] = make_pair(sum + mx + 1, all);
if (a[v] < mid) {
dp[v] = make_pair(0, 0);
}
}
bool ok;
void solve(int v, int par = -1, int cnt = 0, int canall = 1) {
int m = ((int)((tree[v]).size()));
vector<int> sumpref(m + 1), sumsuff(m + 1), mxpref(m + 1), mxsuff(m + 1),
allpref(m + 1), allsuff(m + 1);
allpref[0] = 1, allsuff[m] = 1;
for (int i = 0; i < m; i++) {
sumpref[i + 1] = sumpref[i];
mxpref[i + 1] = mxpref[i];
allpref[i + 1] = allpref[i];
if (tree[v][i] != par) {
if (dp[tree[v][i]].second == true) {
sumpref[i + 1] += dp[tree[v][i]].first;
} else {
mxpref[i + 1] = max(mxpref[i + 1], dp[tree[v][i]].first);
allpref[i + 1] = false;
}
}
}
for (int i = m - 1; i >= 0; i--) {
sumsuff[i] = sumsuff[i + 1];
mxsuff[i] = mxsuff[i + 1];
allsuff[i] = allsuff[i + 1];
if (tree[v][i] != par) {
if (dp[tree[v][i]].second == true) {
sumsuff[i] += dp[tree[v][i]].first;
} else {
mxsuff[i] = max(mxsuff[i + 1], dp[tree[v][i]].first);
allsuff[i] = false;
}
}
}
int mxup = 0, sumup = 0;
if (canall) {
sumup += cnt;
} else {
mxup += cnt;
}
if (dp[v].first != 0) {
if (sumup + sumpref[m] + max(mxup, mxpref[m]) + 1 >= k) {
ok = true;
}
}
for (int i = 0; i < m; i++) {
if (tree[v][i] == par) {
continue;
}
if (dp[v].first != 0) {
solve(tree[v][i], v,
sumup + sumpref[i] + sumsuff[i + 1] + 1 +
max(mxup, max(mxpref[i], mxsuff[i + 1])),
canall & allpref[i] & allsuff[i + 1]);
} else {
solve(tree[v][i], v, 0, 0);
}
}
}
void solve() {
long long l = 1, r = 1e6 + 100;
while (l < r - 1) {
mid = (l + r) / 2;
ok = false;
dfs1(0);
solve(0);
if (ok) {
l = mid;
} else {
r = mid;
}
}
printf("%d\n", l);
}
int main() {
while (true) {
if (!read()) {
break;
}
solve();
fprintf(stderr, "Time: %.18f\n", (double)clock() / CLOCKS_PER_SEC);
fflush(stderr);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ww {
int a, b;
void into(int x) {
if (x > a)
b = a, a = x;
else
b = max(b, x);
}
int lu(int x) { return a == x ? b : a; }
} h[200010];
int i, j, k, n, m, K, mid, _, s, an;
int a[200010], f[200010], ff[200010], g[200010], gg[200010];
vector<int> b[200010];
void dfs(int x, int y) {
ff[x] = 1;
s++;
if (f[x]) _ = x;
for (auto i : b[x]) {
if (i == y || a[i] < mid) continue;
dfs(i, x);
}
}
void Dfs(int x, int y) {
g[x] = 1;
int you = f[x];
for (auto i : b[x]) {
if (i == y || a[i] < mid) continue;
Dfs(i, x);
g[x] += g[i];
if (!g[i]) you = 1;
}
if (you) gg[x] = g[x], g[x] = 0;
}
void dp(int x, int y) {
for (auto i : b[x]) {
if (i == y || a[i] < mid || g[i]) continue;
dp(i, x);
h[x].into(h[i].a + gg[i]);
}
}
void Dp(int x, int y) {
an = max(an, gg[x] + h[x].a);
for (auto i : b[x]) {
if (i == y || a[i] < mid || g[i]) continue;
ww A = h[x], B = h[i];
int ge = h[x].lu(h[i].a + gg[i]);
h[i].into(ge + gg[x]);
Dp(i, x);
h[i] = B, h[x] = A;
}
}
inline int suan() {
for (i = 1; i <= n; i++) {
f[i] = ff[i] = g[i] = gg[i] = h[i].a = h[i].b = 0;
for (auto j : b[i])
if (a[j] < mid) f[i] = 1;
}
an = 0;
for (i = 1; i <= n; i++)
if (a[i] >= mid && !ff[i]) {
_ = s = 0;
dfs(i, 0);
if (!_) {
an = max(an, s);
continue;
}
Dfs(_, 0);
dp(_, 0);
Dp(_, 0);
}
return an;
}
int main() {
scanf("%d%d", &n, &K);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
b[x].push_back(y);
b[y].push_back(x);
}
int l = 1, r = 1000000;
for (; l <= r;) {
mid = (l + r) / 2;
if (suan() >= K)
l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", l - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200100;
int n, treb;
int val[MAX];
vector<int> V[MAX];
vector<int> SumL[MAX], SumR[MAX];
vector<int> MaxL[MAX], MaxR[MAX];
vector<int> KrivL[MAX], KrivR[MAX];
int pozl[MAX], pozr[MAX];
int dpdown[MAX], dpup[MAX], bio[MAX];
int krivdown[MAX], krivup[MAX];
int maxup[MAX], sumup[MAX];
int x;
void DfsDown(int node, int par) {
bio[node] = 1;
int kriv = 0;
SumL[node].push_back(0);
MaxL[node].push_back(0);
KrivL[node].push_back(0);
for (auto ch : V[node]) {
if (ch != par) {
pozl[ch] = (int)SumL[node].size() - 1;
if (val[ch] >= x) DfsDown(ch, node);
int nsum = SumL[node].back(), nmax = MaxL[node].back();
if (!krivdown[ch])
nsum += dpdown[ch];
else {
nmax = max(nmax, dpdown[ch]);
kriv = 1;
}
SumL[node].push_back(nsum);
MaxL[node].push_back(nmax);
KrivL[node].push_back(kriv);
}
}
krivdown[node] = kriv;
SumR[node].push_back(0);
MaxR[node].push_back(0);
KrivR[node].push_back(0);
kriv = 0;
for (int i = (int)V[node].size() - 1; i >= 0; i--) {
int ch = V[node][i];
if (ch != par) {
pozr[ch] = (int)SumR[node].size() - 1;
int nsum = SumR[node].back(), nmax = MaxR[node].back();
if (!krivdown[ch])
nsum += dpdown[ch];
else {
nmax = max(nmax, dpdown[ch]);
kriv = 1;
}
SumR[node].push_back(nsum);
MaxR[node].push_back(nmax);
KrivR[node].push_back(kriv);
}
}
krivdown[node] = kriv;
dpdown[node] = 1 + SumL[node].back() + MaxL[node].back();
}
int DfsUp(int node, int par) {
bio[node] = 1;
if (par == -1) {
maxup[node] = 0;
sumup[node] = 0;
dpup[node] = 0;
if (dpdown[node] >= treb) return 1;
} else {
if (krivup[par])
maxup[node] = max(maxup[node], dpup[par]);
else
sumup[node] += dpup[par];
maxup[node] = max(maxup[node], MaxL[par][pozl[node]]);
sumup[node] += SumL[par][pozl[node]];
maxup[node] = max(maxup[node], MaxR[par][pozr[node]]);
sumup[node] += SumR[par][pozr[node]];
krivup[node] =
krivup[par] | KrivL[par][pozl[node]] | KrivR[par][pozr[node]];
dpup[node] = maxup[node] + sumup[node] + 1;
int tmax = MaxL[node].back(), tsum = SumL[node].back();
if (krivup[node])
tmax = max(tmax, dpup[node]);
else
tsum += dpup[node];
if (1 + tmax + tsum >= treb) return 1;
}
for (auto ch : V[node])
if (val[ch] >= x && ch != par)
if (DfsUp(ch, node)) return 1;
return 0;
}
int Moze() {
memset(krivdown, 0, sizeof krivdown);
memset(krivup, 0, sizeof krivup);
memset(dpdown, 0, sizeof dpdown);
memset(dpup, 0, sizeof dpup);
memset(maxup, 0, sizeof maxup);
memset(sumup, 0, sizeof sumup);
for (int i = 0; i < n; i++) {
SumL[i].clear();
SumR[i].clear();
MaxL[i].clear();
MaxR[i].clear();
KrivL[i].clear();
KrivR[i].clear();
}
for (int i = 0; i < n; i++)
if (val[i] < x) {
krivdown[i] = krivup[i] = 1;
}
memset(bio, 0, sizeof bio);
for (int i = 0; i < n; i++)
if (!bio[i] && val[i] >= x) DfsDown(i, -1);
memset(bio, 0, sizeof bio);
for (int i = 0; i < n; i++)
if (!bio[i] && val[i] >= x)
if (DfsUp(i, -1)) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &treb);
for (int i = 0; i < n; i++) scanf("%d", &val[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
V[a].push_back(b);
V[b].push_back(a);
}
int lo = 0, hi = 1 << 20;
for (; lo < hi;) {
x = (lo + hi + 1) / 2;
if (Moze())
lo = x;
else
hi = x - 1;
}
printf("%d\n", lo);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.